= n_batch_per_epoch:\n break\n\n print(\"\")\n print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start))\n\n if e % 5 == 0:\n gen_weights_path = os.path.join('../../models/%s/gen_weights_epoch%s.h5' % (model_name, e))\n generator_model.save_weights(gen_weights_path, overwrite=True)\n\n disc_weights_path = os.path.join('../../models/%s/disc_weights_epoch%s.h5' % (model_name, e))\n discriminator_model.save_weights(disc_weights_path, overwrite=True)\n\n DCGAN_weights_path = os.path.join('../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e))\n DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True)\n\n except KeyboardInterrupt:\n pass","def default_branch_layers(\n inputs, \n kernel_initializer=None,\n **kwargs\n):\n return sequential(\n inputs=inputs, \n layers=[\n (k.layers.Conv2D,\n {'filters':32, 'kernel_size':8, 'strides':4, 'activation':'relu', \n 'padding':'same'}),\n (k.layers.Conv2D,\n {'filters':64, 'kernel_size':4, 'dilation_rate':2, \n 'activation':'relu', 'padding':'same'}),\n (k.layers.Conv2D,\n {'filters':64, 'kernel_size':3, 'activation':'relu', \n 'padding':'same'}),\n (k.layers.UpSampling2D, {'size':4, 'interpolation':'bilinear'})\n ],\n kernel_initializer=kernel_initializer,\n **kwargs,\n )","def __init__(self, options):\r\n nn.Module.__init__(self)\r\n # Convolution and pooling layers of VGG-16.\r\n self.basemodel = torchvision.models.resnet18(pretrained=True)\r\n self.options = options\r\n\r\n #label\r\n self.label_primary = nn.Linear(options['primary_dim'], options['proj_dim'])\r\n self.label_dual = nn.Linear(options['dual_dim'], options['proj_dim'])\r\n\r\n #classifer/regressor\r\n self.fc_primary = nn.Linear(512 + options['proj_dim'], options['primary_dim'])\r\n self.fc_dual = nn.Linear(512 + options['proj_dim'], options['dual_dim'])\r\n\r\n\r\n if self.options['fc'] == True:\r\n # Freeze all previous layers.\r\n for param in self.basemodel.parameters():\r\n param.requires_grad = False\r\n # Initialize the fc layers.\r\n nn.init.kaiming_normal_(self.fc_primary.weight.data)\r\n if self.fc_primary.bias is not None:\r\n nn.init.constant_(self.fc_primary.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.fc_dual.weight.data)\r\n if self.fc_dual.bias is not None:\r\n nn.init.constant_(self.fc_dual.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.label_primary.weight.data)\r\n if self.label_primary.bias is not None:\r\n nn.init.constant_(self.label_primary.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.label_dual.weight.data)\r\n if self.label_dual.bias is not None:\r\n nn.init.constant_(self.label_dual.bias.data, val=0)\r\n\r\n\r\n else:\r\n for param in self.basemodel.conv1.parameters():\r\n param.requires_grad = False\r\n for param in self.basemodel.bn1.parameters():\r\n param.requires_grad = False\r\n for param in self.basemodel.layer1.parameters():\r\n param.requires_grad = False\r\n #for param in self.basemodel.layer2.parameters():\r\n # param.requires_grad = False\r\n #for param in self.basemodel.layer3.parameters():\r\n # param.requires_grad = False\r","def _make_conv_layers(self):\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def define_gender(name_input):\n if not os.path.isfile('train_set.txt') and not os.path.isfile('test_set'):\n \"\"\"\n We take a sample of male and female names and mix\n them in order to create a training set and testing set\n \"\"\"\n labeled_names = ([(name, 'male') for name in names.words('male.txt')] +\n [(name, 'female') for name in names.words(\n 'female.txt')])\n random.shuffle(labeled_names)\n\n \"\"\"\n We train the classifier and return the gender of the name\n \"\"\"\n featuresets = [(gender_features(n), gender) for (n, gender)\n in labeled_names]\n train_set, test_set = featuresets[-500:], featuresets[:500]\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n with open('train_set.txt', 'wb') as handle:\n pickle.dump(train_set, handle)\n with open('test_set.txt', 'wb') as handle:\n pickle.dump(test_set, handle)\n with open('classifier.txt', 'wb') as handle:\n pickle.dump(classifier, handle)\n\n with open('train_set.txt', 'rb') as handle:\n train_set = pickle.load(handle)\n with open('test_set.txt', 'rb') as handle:\n test_set = pickle.load(handle)\n with open('classifier.txt', 'rb') as handle:\n classifier = pickle.load(handle)\n\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n# accuracy = nltk.classify.accuracy(classifier, test_set)\n# classifier.show_most_informative_features(10)\n# print accuracy\n\n \"\"\"\n Accuracy: .804\n Most Informative Features\n last_letter = u'a' female : male = 44.0 : 1.0\n last_letter = u'd' male : female = 23.7 : 1.0\n last_two_letters = u'on' male : female = 11.0 : 1.0\n first_two_letters = u'ha' male : female = 7.8 : 1.0\n last_two_letters = u'ta' female : male = 7.0 : 1.0\n last_letter = u't' male : female = 6.7 : 1.0\n last_letter = u'o' male : female = 6.0 : 1.0\n last_two_letters = u'll' male : female = 4.7 : 1.0\n first_two_letters = u'te' male : female = 4.7 : 1.0\n last_two_letters = u'an' male : female = 4.1 : 1.0\n \"\"\"\n\n return classifier.classify(gender_features(name_input))","def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\n network = Sequential()\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\n return network","def createDiscriminator(imgShape):\n model = tf.keras.Sequential()\n\n model.add(layers.Conv2D(32, kernel_size = 3, strides = 2, input_shape = imgShape, padding = \"same\"))\n model.add(layers.LeakyReLU(alpha = 0.2))\n\n model.add(layers.Dropout(0.25))\n model.add(layers.Conv2D(64, kernel_size = 3, strides = 2, padding = \"same\"))\n model.add(layers.ZeroPadding2D(padding = ((0,1), (0,1))))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.LeakyReLU(alpha = 0.2))\n\n model.add(layers.Dropout(0.25))\n model.add(layers.Conv2D(128, kernel_size = 3, strides = 2, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.LeakyReLU(alpha = 0.2))\n\n model.add(layers.Dropout(0.25))\n model.add(layers.Conv2D(256, kernel_size = 3, strides = 1, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.LeakyReLU(alpha = 0.2))\n\n model.add(layers.Dropout(0.25))\n model.add(layers.Conv2D(512, kernel_size = 3, strides = 1, padding = \"same\"))\n model.add(layers.BatchNormalization(momentum = 0.8))\n model.add(layers.LeakyReLU(alpha = 0.2))\n\n model.add(layers.Dropout(0.25))\n model.add(layers.Flatten())\n model.add(layers.Dense(1, activation = \"sigmoid\"))\n\n return model","def _final_block(self, in_channels, mid_channels, out_channels, kernel_size=3):\n block = nn.Sequential(\n nn.Conv2d(kernel_size=kernel_size, in_channels=in_channels, out_channels=mid_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(mid_channels),\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=mid_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(mid_channels),\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=out_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(out_channels)\n )\n return block","def _final_block(self, in_channels, mid_channels, out_channels, kernel_size=3):\n block = nn.Sequential(\n nn.Conv2d(kernel_size=kernel_size, in_channels=in_channels, out_channels=mid_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(mid_channels),\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=mid_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(mid_channels),\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=out_channels, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(out_channels)\n )\n return block","def build_dc_classifier():\n # return nn.Sequential(\n # Unflatten(Batch_size, 1, 28, 28),\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(2, stride=2),\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(kernel_size=2, stride=2),\n # Flatten(),\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.Linear(4 * 4 * 64, 1)\n # )\n\n return nn.Sequential(\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\n Flatten(),\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\n nn.LeakyReLU(negative_slope=0.01),\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\n )","def define_generator(image_shape=(256, 256, 1)):\n\n # weight initialization\n init = RandomNormal(stddev=0.02)\n # image input\n in_image = Input(shape=image_shape)\n # encoder model\n e1 = define_encoder_block(in_image, 64, batchnorm=False)\n e2 = define_encoder_block(e1, 128)\n e3 = define_encoder_block(e2, 256)\n e4 = define_encoder_block(e3, 512)\n e5 = define_encoder_block(e4, 512)\n e6 = define_encoder_block(e5, 512)\n e7 = define_encoder_block(e6, 512)\n # bottleneck, no batch norm and relu\n b = Conv2D(512, (4, 4), strides=(2, 2), padding='same',\n kernel_initializer=init)(e7)\n b = Activation('relu')(b)\n # decoder model\n d1 = decoder_block(b, e7, 512)\n d2 = decoder_block(d1, e6, 512)\n d3 = decoder_block(d2, e5, 512)\n d4 = decoder_block(d3, e4, 512, dropout=False)\n d5 = decoder_block(d4, e3, 256, dropout=False)\n d6 = decoder_block(d5, e2, 128, dropout=False)\n d7 = decoder_block(d6, e1, 64, dropout=False)\n\n # Changed the 1 below from 3 (gray ipv RGB)\n g = Conv2DTranspose(1, (4, 4), strides=(2, 2), padding='same',\n kernel_initializer=init)(d7)\n out_image = Activation('tanh')(g)\n # define model\n model = Model(in_image, out_image)\n\n return model","def __init__(self, dropout_rate, num_classes, include_top, layer):\r\n super(VGG16_Rand, self).__init__()\r\n print(\"CIFAR VGG16_Rand is used\")\r\n self.dropout_rate = dropout_rate\r\n self.num_classes = num_classes\r\n self.include_top = include_top\r\n self.layer = layer\r\n self.bias = True\r\n\r\n # Define the building blocks\r\n if layer <= 11:\r\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 12:\r\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 21:\r\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 22:\r\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 31:\r\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 32:\r\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 33:\r\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 41:\r\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 42:\r\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 43:\r\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 51:\r\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 52:\r\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 53:\r\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n self.avgpool = nn.AdaptiveAvgPool2d(1)\r\n self.fc = nn.Sequential(nn.Linear(512, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, num_classes))\r\n\r\n # Initialize the weights\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\r\n elif isinstance(m, nn.BatchNorm2d):\r\n # raise Exception('You are using a model without BN!!!')\r\n nn.init.constant_(m.weight, 1)\r\n nn.init.constant_(m.bias, 0)","def __init__(self):\n super(PackageNet, self).__init__()\n \n # remove last layers of vgg19 model, save first fc layer and maxpool layer\n self.vgg = models.vgg19(pretrained=True)\n del self.vgg.classifier[2:]\n\n # get size of some layers\n start_num = self.vgg.classifier[0].out_features\n mid_num0 = int(np.sqrt(start_num))\n mid_num1 = int(start_num**0.667)\n mid_num2 = int(start_num**0.333)\n \n cls_out_num = 9 \n reg_out_num = 16 # 8 3D bounding box coords\n \n # define classifier\n self.classifier = nn.Sequential(\n nn.Linear(start_num,mid_num0,bias=True),\n nn.ReLU(),\n nn.Linear(mid_num0,cls_out_num,bias = True),\n nn.Softmax(dim = 1)\n )\n \n # define regressor\n # try relu and tanh, also try without bias\n self.regressor = nn.Sequential(\n nn.Linear(start_num,mid_num1,bias=True),\n nn.ReLU(),\n nn.Linear(mid_num1,mid_num2,bias = True),\n nn.ReLU(),\n nn.Linear(mid_num2,reg_out_num,bias = True),\n nn.Sigmoid()\n \n )","def discriminator_network(hparams, num_filters=64):\n img = tf.keras.layers.Input(\n shape=(hparams.hr_dimension, hparams.hr_dimension, 3))\n\n x = tf.keras.layers.Conv2D(\n num_filters,\n kernel_size=[3, 3],\n strides=1,\n padding='same',\n use_bias=False)(\n img)\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\n\n x = tf.keras.layers.Conv2D(\n num_filters,\n kernel_size=[3, 3],\n strides=2,\n padding='same',\n use_bias=False)(\n x)\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\n\n x = _conv_block_d(x, num_filters * 2)\n x = _conv_block_d(x, num_filters * 4)\n x = _conv_block_d(x, num_filters * 8)\n\n x = tf.keras.layers.Flatten()(x)\n x = tf.keras.layers.Dense(100)(x)\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\n x = tf.keras.layers.Dense(1)(x)\n\n model = tf.keras.models.Model(inputs=img, outputs=x)\n return model","def GeneratorAndDiscriminator():\n\n # Baseline (G: DCGAN, D: DCGAN)\n return ResnetGenerator, DCGANDiscriminator\n\n # No BN and constant number of filts in G\n # return WGANPaper_CrippledDCGANGenerator, DCGANDiscriminator\n\n # 512-dim 4-layer ReLU MLP G\n # return FCGenerator, DCGANDiscriminator\n\n # No normalization anywhere\n # return functools.partial(DCGANGenerator, bn=False), functools.partial(DCGANDiscriminator, bn=False)\n\n # Gated multiplicative nonlinearities everywhere\n # return MultiplicativeDCGANGenerator, MultiplicativeDCGANDiscriminator\n\n # tanh nonlinearities everywhere\n # return functools.partial(DCGANGenerator, bn=True, nonlinearity=tf.tanh), \\\n # functools.partial(DCGANDiscriminator, bn=True, nonlinearity=tf.tanh)\n\n # 101-layer ResNet G and D\n # return ResnetGenerator, ResnetDiscriminator\n\n raise Exception('You must choose an architecture!')","def VGG_CNN_F(arch_mode='full', weights='imagenet',\n input_shape=(224, 224, 3), pooling=None, classes=1000):\n\n if not (weights in {'imagenet', None} or os.path.exists(weights)):\n raise ValueError('The `weights` argument should be either '\n '`None` (random initialization), `imagenet` '\n '(pre-training on ImageNet), '\n 'or the path to the weights file to be loaded.')\n\n if weights == 'imagenet' and arch_mode == 'full' and classes != 1000:\n raise ValueError('If using `weights` as imagenet with `arch_mode`'\n ' as `full`, `classes` should be 1000')\n\n img_input = Input(shape=input_shape)\n x = Conv2D(64, (11, 11), strides=(4, 4), activation='relu', name='conv1')(img_input) # conv1\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm1')(x) # norm1\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same', name='pool1')(x) # pool1\n\n x = ZeroPadding2D(padding=(2, 2))(x)\n x = Conv2D(256, (5, 5), strides=(1, 1), activation='relu', name='conv2')(x) # conv2\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm2')(x) # norm2\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool2')(x) # pool2\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv3')(x) # conv3\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv4')(x) # conv4\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv5')(x) # conv5\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x) # pool5\n\n if arch_mode == 'notop':\n if pooling == 'avg':\n x = GlobalAveragePooling2D()(x)\n elif pooling == 'max':\n x = GlobalMaxPooling2D()(x)\n else:\n x = Flatten()(x)\n x = Dense(4096, activation='relu', name='fc6')(x) # fc6\n x = Dropout(0.5)(x) # drop6\n x = Dense(4096, activation='relu', name='fc7')(x) # fc7\n x = Dropout(0.5)(x) # drop7\n\n if arch_mode == 'full':\n x = Dense(classes, name='fc8')(x) # fc8\n x = Activation('softmax', name='prob')(x) # prob\n elif arch_mode != 'rmlast':\n raise ValueError('arch_mode: {} is not supported.'.format(arch_mode))\n\n inputs = img_input\n\n # Create model.\n model = Model(inputs, x, name='vgg_cnn_f')\n\n # load weights\n if weights == 'imagenet':\n if arch_mode == 'full':\n weights_path = 'init_weights/vgg_cnn_f.h5'\n elif arch_mode == 'rmlast':\n weights_path = 'init_weights/vgg_cnn_f_rmlast.h5'\n elif arch_mode == 'notop':\n weights_path = 'init_weights/vgg_cnn_f_notop.h5'\n model.load_weights(weights_path)\n\n if K.backend() == 'theano':\n raise NotImplemented('Support for loading imagenet weights with '\n 'theano backend is not implemented yet!')\n\n if K.image_data_format() == 'channels_first':\n raise NotImplemented('Support for loading imagenet weights with '\n 'channels_first image data format is not implemented yet!')\n elif weights is not None:\n model.load_weights(weights)\n return model","def build(width, height, depth, classes, stages, filters, include_top, pooling,\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\n inputShape = (height, width, depth)\n chanDim = -1\n\n if K.image_data_format() == \"channels_first\":\n inputShape = (depth, height, width)\n chanDim = 1\n\n inputs = Input(shape=inputShape)\n\n\n # block 1 (initial conv block)\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\n kernel_initializer=\"he_normal\", kernel_regularizer=l2(reg))(x)\n x = BatchNormalization(axis=chanDim, name=\"bn_conv1\")(x)\n x = Activation(\"relu\")(x)\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\"pool1_pad\")(x)\n x = MaxPooling2D(3, strides=2)(x)\n\n for i in range(0, len(stages)):\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\n\n print(\"Stage {}, Stride={}\".format(i, stride))\n x = SEResNet.residual_module(x, filters[i+1], stride,\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\n chanDim=chanDim, bnEps=bnEps,\n bnMom=bnMom)\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\n momentum=bnMom)(x)\n x = Activation(\"relu\")(x)\n\n if include_top:\n x = GlobalAveragePooling2D()(x)\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\n activation='softmax')(x)\n else:\n if pooling == 'avg':\n print(\"Adding average pool\")\n x = GlobalAveragePooling2D()(x)\n elif pooling == 'max':\n x = GlobalMaxPooling2D()(x)\n\n model = Model(inputs=inputs, outputs=x, name=\"SEResNet\")\n return model"],"string":"[\n \"def build_discriminator(self):\\n img_shape = (self.img_size[0], self.img_size[1], self.channels)\\n\\n model = Sequential()\\n ###############\\n # Conv Stack 1:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=5, strides=2, input_shape=img_shape, padding=\\\"same\\\")\\n ) # 128x128 -> 64x64\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.2))\\n\\n ###############\\n # Conv Stack 2:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=5, strides=2, padding=\\\"same\\\")\\n ) # 64x64 -> 32x32\\n # model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 3:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=4, strides=2, padding=\\\"same\\\")\\n ) # 32x32 -> 16x16\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 4:\\n ###############\\n model.add(Conv2D(128, kernel_size=4, strides=1, padding=\\\"same\\\")) # 16x16 -> 8x8\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 5:\\n ###############\\n model.add(Conv2D(128, kernel_size=3, strides=1, padding=\\\"same\\\")) # 8x8 -> 4x4\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n model.add(Dropout(0.4))\\n\\n model.add(Flatten())\\n model.add(Dense(1, activation=\\\"sigmoid\\\")) # important binary classification.\\n\\n model.summary()\\n\\n # Model require Pair.\\n img = Input(shape=img_shape)\\n validity = model(img)\\n\\n return Model(img, validity)\",\n \"def discriminator_block(in_filters, out_filters):\\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\\n nn.LeakyReLU(0.01)]\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def build_bisenet(inputs, num_classes):\\n\\n ### The spatial path\\n ### The number of feature maps for each convolution is not specified in the paper\\n ### It was chosen here to be equal to the number of feature maps of a classification\\n ### model at each corresponding stage\\n # spatial_net = fluid.layers.resize_bilinear(inputs, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_1',spatial_net)\\n\\n ## spatial path\\n spatial_net = ConvBlock(inputs, num_filters=64, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=128, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=256, kernel_size=3, stride=2)\\n # print(\\\"spatial_net:\\\", spatial_net)\\n\\n # spatial_net = fluid.layers.resize_bilinear(spatial_net, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_2',spatial_net)\\n ### Context path\\n model = ResNet(is_test=False)\\n # spatial_net = model.bottleneck_block1(inputs)\\n end_points_16, end_points_32 = model.net(inputs)\\n net_4 = AttentionRefinementModule(end_points_16, num_filters=512)\\n net_5 = AttentionRefinementModule(end_points_32, num_filters=1024)\\n global_channels = fluid.layers.reduce_mean(net_5, [2, 3], keep_dim=True)\\n net_5_scaled = fluid.layers.elementwise_mul(net_5, global_channels, axis=0)\\n\\n ### Combining the paths\\n net_4 = Upsample(net_4, scale=2)\\n net_5_scaled = Upsample(net_5_scaled, scale=4)\\n # print('net_4, net_5:', [net_4, net_5_scaled])\\n # layers_concat = list()\\n # layers_concat.append(spatial_net)\\n ## layers_concat.append(net_4)\\n # layers_concat.append(net_5_scaled)\\n context_net = fluid.layers.concat([spatial_net, net_4, net_5_scaled], axis=1) #\\n # context_net = fluid.layers.concat(input=layers_concat,axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([net_4, net_5_scaled], axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([spatial_net,context_net], axis=1)\\n # print('context_net2',context_net)\\n\\n ### FFM\\n # net = FeatureFusionModule(input_1=spatial_net, input_2=context_net, num_filters=num_classes)\\n net = FeatureFusionModule(inputs=context_net, num_filters=num_classes)\\n\\n # print('net', net)\\n\\n ## [batch_zize, num_filters, 128, 64]\\n\\n ### Final upscaling and finish\\n # net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 128])\\n # print('conv2d_transpose', net)\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn1')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[128, 256])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn2')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 512])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn3')\\n #net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[512, 1024])\\n #net = batch_normalization(net, relu=True, name='conv2d_transpose_bn4')\\n # print('net',net)\\n net = fluid.layers.image_resize(net, out_shape=[512, 1024], resample='BILINEAR')\\n\\n net = fluid.layers.conv2d(net, num_classes, 1)\\n return net\",\n \"def discriminator_block(in_filters, out_filters, f_size=4, normalize=True,stride=2):\\n layers = [nn.Conv2d(in_filters, out_filters, f_size, stride=stride, padding=0)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n layers = []\\n in_filters = channels\\n for out_filters, stride, normalize in [ (64, 2, False),\\n (128, 2, True),\\n (256, 2, True),\\n (512, 1, True)]:\\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\\n in_filters = out_filters\\n\\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\\n\\n self.model = nn.Sequential(*layers)\\n\\n \\\"\\\"\\\"CycleGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalize=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels, 64, normalize=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n *discriminator_block(256, 512),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(512, 1, 4, padding=1)\\n )\\n\\n \\\"\\\"\\\"DCGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\\n nn.Sigmoid())\\n\\n\\n \\\"\\\"\\\"DiscoGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalization=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels, 64, normalization=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(256, 1, 4, padding=1)\\n )\\n\\n \\\"\\\"\\\"DraGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\\n nn.Sigmoid())\\n\\n \\\"\\\"\\\"EBGAN\\n \\\"\\\"\\\"\\n # Upsampling\\n self.down = nn.Sequential(\\n nn.Conv2d(opt.channels, 64, 3, 2, 1),\\n nn.ReLU(),\\n )\\n # Fully-connected layers\\n self.down_size = (opt.img_size // 2)\\n down_dim = 64 * (opt.img_size // 2)**2\\n\\n self.embedding = nn.Linear(down_dim, 32)\\n\\n self.fc = nn.Sequential(\\n nn.BatchNorm1d(32, 0.8),\\n nn.ReLU(inplace=True),\\n nn.Linear(32, down_dim),\\n nn.BatchNorm1d(down_dim),\\n nn.ReLU(inplace=True)\\n )\\n # Upsampling\\n self.up = nn.Sequential(\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(64, opt.channels, 3, 1, 1)\\n )\\n\\n \\\"\\\"\\\"InfoGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n \\\"\\\"\\\"Returns layers of each discriminator block\\\"\\\"\\\"\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.conv_blocks = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n\\n # Output layers\\n self.adv_layer = nn.Sequential(nn.Linear(128*ds_size**2, 1))\\n self.aux_layer = nn.Sequential(\\n nn.Linear(128*ds_size**2, opt.n_classes),\\n nn.Softmax()\\n )\\n self.latent_layer = nn.Sequential(nn.Linear(128*ds_size**2, opt.code_dim))\\n\\n \\\"\\\"\\\"LSGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Linear(128*ds_size**2, 1)\\n\\n \\\"\\\"\\\"Pix2Pix\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalization=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels*2, 64, normalization=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n *discriminator_block(256, 512),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(512, 1, 4, padding=1, bias=False)\\n )\\n\\n \\\"\\\"\\\"Pixelda\\n \\\"\\\"\\\"\\n def block(in_features, out_features, normalization=True):\\n \\\"\\\"\\\"Discriminator block\\\"\\\"\\\"\\n layers = [ nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),\\n nn.LeakyReLU(0.2, inplace=True) ]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_features))\\n return layers\\n\\n self.model = nn.Sequential(\\n *block(opt.channels, 64, normalization=False),\\n *block(64, 128),\\n *block(128, 256),\\n *block(256, 512),\\n nn.Conv2d(512, 1, 3, 1, 1))\\n\\n \\\"\\\"\\\"SRGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, stride, normalize):\\n \\\"\\\"\\\"Returns layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.BatchNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n layers = []\\n in_filters = in_channels\\n for out_filters, stride, normalize in [ (64, 1, False),\\n (64, 2, True),\\n (128, 1, True),\\n (128, 2, True),\\n (256, 1, True),\\n (256, 2, True),\\n (512, 1, True),\\n (512, 2, True),]:\\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\\n in_filters = out_filters\\n\\n # Output layer\\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\\n\\n self.model = nn.Sequential(*layers)\\n\\n \\\"\\\"\\\"StarGAN\\n \\\"\\\"\\\"\\n channels, img_size, _ = img_shape\\n\\n def discriminator_block(in_filters, out_filters):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\\n nn.LeakyReLU(0.01)]\\n return layers\\n\\n layers = discriminator_block(channels, 64)\\n curr_dim = 64\\n for _ in range(n_strided - 1):\\n layers.extend(discriminator_block(curr_dim, curr_dim*2))\\n curr_dim *= 2\\n\\n self.model = nn.Sequential(*layers)\\n\\n # Output 1: PatchGAN\\n self.out1 = nn.Conv2d(curr_dim, 1, 3, padding=1, bias=False)\\n # Output 2: Class prediction\\n kernel_size = img_size // 2**n_strided\\n self.out2 = nn.Conv2d(curr_dim, c_dim, kernel_size, bias=False)\\n\\n \\\"\\\"\\\"WGAN\\n \\\"\\\"\\\"\\n nn.Linear(int(np.prod(img_shape)), 512),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Linear(512, 256),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Linear(256, 1)\\n\\n \\n\\n\\n# import torch.nn as nn\\n# import torch\\n# from torch.nn.modules import conv, Linear\\n# import torch.nn.functional as F\\n# from src.snlayers.snconv2d import SNConv2d\\n\\n# class _netG(nn.Module):\\n# def __init__(self, nz, nc, ngf):\\n# super(_netG, self).__init__()\\n# self.main = nn.Sequential(\\n# # input is Z, going into a convolution\\n# nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=True),\\n# nn.BatchNorm2d(ngf * 8),\\n# nn.ReLU(True),\\n# # state size. (ngf*8) x 4 x 4\\n# nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf * 4),\\n# nn.ReLU(True),\\n# # state size. (ngf*4) x 8 x 8\\n# nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf * 2),\\n# nn.ReLU(True),\\n# # state size. (ngf*2) x 16 x 16\\n# nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf),\\n# nn.ReLU(True),\\n# # state size. (ngf) x 32 x 32\\n# nn.ConvTranspose2d(ngf, nc, 3, 1, 1, bias=True),\\n# nn.Tanh()\\n# # state size. (nc) x 32 x 32\\n# )\\n\\n# def forward(self, input):\\n# output = self.main(input)\\n# return output\\n\\n# # Actor\\n# class _netE(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netE, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# SNConv2d(nc, ndf, 7, 4, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, 3, 7, 4, 1, bias=False),\\n# nn.Sigmoid()\\n# )\\n# def forward(self, input):\\n# output = self.main(input) \\n# return output.view(-1, 3).squeeze(1)\\n\\n# class _netD1(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD1, self).__init__()\\n\\n self.main = nn.Sequential(\\n SNConv2d(nc, ndf, 5, 2, 2), \\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf, ndf * 2, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 2, ndf * 4, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 4, ndf * 8, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 8, 1, 4),\\n nn.Sigmoid()\\n\\n # input is (nc) x 64 x 64\\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf) x 32 x 32\\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*2) x 16 x 16\\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*4) x 8 x 8\\n nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 8),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*8) x 4 x 4\\n nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\\n nn.Sigmoid()\\n\\n # input is (nc) x 64 x 64\\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf) x 32 x 32\\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*2) x 16 x 16\\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Conv2d(ndf * 4, ndf * 16, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 16),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*16) x 4 x 4\\n nn.Conv2d(ndf * 16, 1, 4, 1, 0, bias=False),\\n nn.Sigmoid()\\n # )\\n # def forward(self, input):\\n # output = self.main(input)\\n # output = output.view(-1, 1).squeeze(1)\\n # return output\\n\\n# class _netD2(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD2, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, ndf, 16, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # ndf x 30 x 30\\n\\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 2, ndf * 2, 16, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # (ndf * 2) x 9 x 9\\n\\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 4, 1, 9, 1, 0, bias=False),\\n# nn.Sigmoid()\\n# # 1 x 1 x 1\\n# )\\n# def forward(self, input):\\n# output = self.main(input)\\n# return output.view(-1, 1).squeeze(1)\\n\\n# class _netD3(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD3, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# # input is (nc) x 32 x 32\\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, ndf, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # state size. (ndf) x 1 x 32\\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf*2, ndf * 2, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # state size. (ndf*2) x 16 x 16\\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n\\n# SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 8, ndf * 8, 4, 2, 1, bias=True),\\n\\n# # state size. (ndf*8) x 4 x 4\\n# SNConv2d(ndf * 8, ndf * 16, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 16, 1, 4, 1, 0, bias=False),\\n# nn.Sigmoid()\\n# )\\n# def forward(self, input):\\n# output = self.main(input)\\n# output = output.view(-1, 1).squeeze(1)\\n# return output\\n\\n\\n# _netD_list = [_netD1]\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\r\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\r\\n if normalize:\\r\\n layers.append(nn.InstanceNorm2d(out_filters))\\r\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\r\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalization=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.BatchNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def DCGAN_discriminator(img_dim, nb_patch, bn_mode, model_name=\\\"DCGAN_discriminator\\\", use_mbd=True):\\n\\n list_input = [Input(shape=img_dim, name=\\\"disc_input_%s\\\" % i) for i in range(nb_patch)]\\n\\n if K.image_dim_ordering() == \\\"th\\\":\\n bn_axis = 1\\n else:\\n bn_axis = -1\\n\\n nb_filters = 64\\n nb_conv = int(np.floor(np.log(img_dim[1]) / np.log(2)))\\n list_filters = [nb_filters * min(8, (2 ** i)) for i in range(nb_conv)]\\n\\n # First conv\\n x_input = Input(shape=img_dim, name=\\\"discriminator_input\\\")\\n # x = Convolution2D(list_filters[0], 3, 3, subsample=(2, 2), name=\\\"disc_conv2d_1\\\", border_mode=\\\"same\\\")(x_input)\\n # x = BatchNormalization(mode=bn_mode, axis=bn_axis)(x)\\n # x = LeakyReLU(0.2)(x)\\n\\n x = MaxPooling2D(\\n pool_size=(2, 2), strides=(2, 2))(x_input)\\n x = Convolution2D(\\n list_filters[0]/8, 1, 1, activation='relu', init='glorot_uniform',\\n border_mode='same', name='disc_conv2d_1')(x)\\n x = BatchNormalization(mode=bn_mode, axis=bn_axis)(x)\\n e1 = Convolution2D(\\n list_filters[0]/2, 1, 1, activation='relu', init='glorot_uniform',\\n border_mode='same')(x)\\n e2 = Convolution2D(\\n list_filters[0]/2, 3, 3, activation='relu', init='glorot_uniform',\\n border_mode='same')(x)\\n x = merge(\\n [e1, e2], mode='concat', concat_axis=bn_axis)\\n\\n # Next convs\\n for i, f in enumerate(list_filters[1:]):\\n name = \\\"disc_conv2d_fire_%s\\\" % (i + 2)\\n # x = Convolution2D(f, 3, 3, subsample=(2, 2), name=name, border_mode=\\\"same\\\")(x)\\n # x = BatchNormalization(mode=bn_mode, axis=bn_axis)(x)\\n # x = LeakyReLU(0.2)(x)\\n x = MaxPooling2D(\\n pool_size=(2, 2), strides=(2, 2))(x)\\n x = Convolution2D(\\n f/8, 1, 1, activation='relu', init='glorot_uniform',\\n border_mode='same', name=name)(x)\\n x = BatchNormalization(mode=bn_mode, axis=bn_axis)(x)\\n e1 = Convolution2D(\\n f/2, 1, 1, activation='relu', init='glorot_uniform',\\n border_mode='same')(x)\\n e2 = Convolution2D(\\n f/2, 3, 3, activation='relu', init='glorot_uniform',\\n border_mode='same')(x)\\n x = merge(\\n [e1, e2], mode='concat', concat_axis=bn_axis)\\n\\n x_flat = Flatten()(x)\\n x = Dense(2, activation='softmax', name=\\\"disc_dense\\\")(x_flat)\\n\\n PatchGAN = Model(input=[x_input], output=[x, x_flat], name=\\\"PatchGAN\\\")\\n print(\\\"PatchGAN summary\\\")\\n PatchGAN.summary()\\n\\n x = [PatchGAN(patch)[0] for patch in list_input]\\n x_mbd = [PatchGAN(patch)[1] for patch in list_input]\\n\\n if len(x) > 1:\\n x = merge(x, mode=\\\"concat\\\", name=\\\"merge_feat\\\")\\n else:\\n x = x[0]\\n\\n if use_mbd:\\n if len(x_mbd) > 1:\\n x_mbd = merge(x_mbd, mode=\\\"concat\\\", name=\\\"merge_feat_mbd\\\")\\n else:\\n x_mbd = x_mbd[0]\\n\\n num_kernels = 100\\n dim_per_kernel = 5\\n\\n M = Dense(num_kernels * dim_per_kernel, bias=False, activation=None)\\n MBD = Lambda(minb_disc, output_shape=lambda_output)\\n\\n x_mbd = M(x_mbd)\\n x_mbd = Reshape((num_kernels, dim_per_kernel))(x_mbd)\\n x_mbd = MBD(x_mbd)\\n x = merge([x, x_mbd], mode='concat')\\n\\n x_out = Dense(2, activation=\\\"softmax\\\", name=\\\"disc_output\\\")(x)\\n\\n discriminator_model = Model(input=list_input, output=[x_out], name=model_name)\\n\\n return discriminator_model\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_model_organs():\\n # Initialize the weights\\n init = tf.random_normal_initializer(0.0, 0.02)\\n\\n img_shape = (512, 512, 1)\\n\\n # Source and target image input\\n source_img = tf.keras.Input(shape=img_shape)\\n target_img = tf.keras.Input(shape=img_shape)\\n\\n # Concatenate images channel-wise\\n src_tgt_img = Concatenate()([source_img, target_img]) # L: 512 x 512 x 1 # G: 256 x 256 x 1\\n\\n # C128\\n d1 = Conv2D(filters=128, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n src_tgt_img) # L: 256 x 256 x 128 # G: 128 x 128 x 128 # RF: 4\\n d1 = LeakyReLU(alpha=0.2)(d1)\\n\\n # C256\\n d2 = Conv2D(filters=256, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n d1) # L: 128 x 128 x 256 # G: 64 x 64 x 256 # RF: 10\\n d2 = BatchNormalization()(d2)\\n d2 = LeakyReLU(alpha=0.2)(d2)\\n\\n # C256\\n d3 = Conv2D(filters=256, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n d2) # L: 64 x 64 x 256 # G: 32 x 32 x 256 # RF: 22\\n d3 = BatchNormalization()(d3)\\n d3 = LeakyReLU(alpha=0.2)(d3)\\n\\n # C512\\n d4 = Conv2D(filters=512, kernel_size=(4, 4), strides=(1, 1), padding='valid', kernel_initializer=init)(\\n d3) # L: 61 x 61 x 512 # G: 29 x 29 x 512 # RF: 46\\n d4 = BatchNormalization()(d4)\\n d4 = LeakyReLU(alpha=0.2)(d4)\\n d4 = ZeroPadding2D()(d4) # L: 63 x 63 x 512 # G: 31 x 31 x 512\\n\\n # Patch output\\n d5 = Conv2D(filters=1, kernel_size=(4, 4), strides=(1, 1), padding='valid', kernel_initializer=init)(\\n d4) # L: 60 x 60 x 1 # G: 28 x 28 x 1 # RF: 70\\n output_patch = Activation('sigmoid')(d5)\\n\\n # Define model\\n discriminator_model = tf.keras.Model([source_img, target_img], output_patch)\\n return discriminator_model\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def Unet4(shape, nb_filters=32, exp=1, kernel_size=3, initialization=\\\"glorot_uniform\\\", activation=\\\"relu\\\", sigma_noise=0, output_channels=1, drop=0.0, regularization=None):\\n \\n \\n input_layer = Input(shape=shape)\\n\\n conv1 = ConvBlock(input_layer, nb_filters=nb_filters, kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n if drop > 0.0: pool1 = Dropout(drop)(pool1)\\n\\n conv2 = ConvBlock(pool1, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n if drop > 0.0: pool2 = Dropout(drop)(pool2)\\n\\n conv3 = ConvBlock(pool2, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n if drop > 0.0: pool3 = Dropout(drop)(pool3)\\n\\n conv4 = ConvBlock(pool3, nb_filters=nb_filters * 2 **(3 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n if drop > 0.0: pool4 = Dropout(drop)(pool4)\\n\\n deconv5 = DeconvBlock(conv4, residual=conv3, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv5 = Dropout(drop)(deconv5)\\n\\n deconv6 = DeconvBlock(deconv5, residual=conv2, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv6 = Dropout(drop)(deconv6)\\n\\n deconv7 = DeconvBlock(deconv6, residual=conv1, nb_filters=nb_filters, kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv7 = Dropout(drop)(deconv7)\\n\\n if sigma_noise > 0:\\n deconv7 = GaussianNoise(sigma_noise)(deconv7)\\n\\n output_layer = Conv2D(filters=output_channels, kernel_size=(1, 1))(deconv7)\\n output_layer = BatchNormalization()(output_layer)\\n output_layer = Activation('softmax')(output_layer)\\n\\n model = Model(inputs=input_layer, outputs=output_layer, name='Unet')\\n return model\",\n \"def discriminator_model():\\n\\n Discriminator = Sequential(name='Discriminator')\\n\\n # Downsampling : 32x32x3 --> 16x16x64\\n Discriminator.add(Conv2D(filters=64, kernel_size=(5, 5), strides=2, padding='same', \\n kernel_initializer=RandomNormal(stddev=GAUSS_SD), \\n input_shape=DISCRIMINATOR_INPUT))\\n Discriminator.add(LeakyReLU(ALPHA))\\n\\n # Downsampling : 16x16x64 --> 8x8x128\\n Discriminator.add(Conv2D(filters=128, kernel_size=(5, 5), strides=2, padding='same'))\\n Discriminator.add(BatchNormalization(momentum=MOMENTUM))\\n Discriminator.add(LeakyReLU(ALPHA))\\n\\n # Downsampling : 8x8x128 --> 4x4x256\\n Discriminator.add(Conv2D(filters=128, kernel_size=(5, 5), strides=2, padding='same'))\\n Discriminator.add(BatchNormalization(momentum=MOMENTUM))\\n Discriminator.add(LeakyReLU(ALPHA))\\n\\n # Downsampling : 4x4x256 --> 2x2x512\\n Discriminator.add(Conv2D(filters=512, kernel_size=(5, 5), strides=2, padding='same'))\\n Discriminator.add(BatchNormalization(momentum=MOMENTUM))\\n Discriminator.add(LeakyReLU(ALPHA))\\n\\n # Fully Connected Layer (classifier) , 2x2x512 (2048) --> 1\\n Discriminator.add(Flatten())\\n Discriminator.add(Dropout(DROPOUT))\\n Discriminator.add(Dense(1))\\n\\n return Discriminator\",\n \"def VGGModel(input_shape):\\n \\n\\n X_input = Input(input_shape)\\n \\n # Creating a Neural Network (VGG-16)\\n\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(X_input)\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(X)\\n\\n # Block 2\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(X)\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(X)\\n\\n # Block 3\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(X)\\n\\n # Block 4\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(X)\\n\\n # Block 5\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(X)\\n \\n X = Flatten()(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc')(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc2')(X)\\n X = Dense(2048, activation='relu', kernel_initializer = 'he_normal', name='fc3')(X)\\n X = Dense(1024, activation='relu', kernel_initializer = 'he_normal', name='fc4')(X)\\n X = Dense(512, activation='relu', kernel_initializer = 'he_normal', name='fc5')(X)\\n X = Dense(256, activation='relu', kernel_initializer = 'he_normal', name='fc6')(X)\\n X = Dense(2, activation='linear', name='regression')(X)\\n model = Model(inputs=X_input, outputs = X, name='HappyModel')\\n print(model.summary())\\n \\n return model\",\n \"def gyf_net(\\n inputs,\\n backbone_layers,\\n num_classes,\\n option = 1,\\n do_dropout = False,\\n nd_weights=[ 0, 0, 0.01 , 0.01] ,\\n wd_weights=[ 0, 0, 0.01, 0.01],\\n name='gyf_net',\\n FC_num_of_nuerons = 128\\n):\\n dropout_param = 0.5\\n\\n C3, C4, C5 = backbone_layers\\n\\n if option == 'reg_baseline_c5_dubreshko':\\n GlobalAvgPool_features = keras.layers.GlobalAveragePooling2D()(C5)\\n FC_regression = keras.layers.Dense(1024, name='FC_regression', activation='relu',\\n kernel_regularizer=keras.regularizers.l2(wd_weights[2]),\\n activity_regularizer=keras.regularizers.l2(nd_weights[2]))(GlobalAvgPool_features)\\n FC_regression2 = keras.layers.Dense(512, name='FC_regression2', activation='relu',\\n kernel_regularizer=keras.regularizers.l2(wd_weights[3]),\\n activity_regularizer=keras.regularizers.l2(nd_weights[3]))(FC_regression)\\n\\n outputs = keras.layers.Dense(1, name='regression')(FC_regression2)\\n\\n if option== 'reg_baseline_c5':\\n GlobalAvgPool_features = keras.layers.GlobalAveragePooling2D()(C5)\\n FC_regression = keras.layers.Dense(1024, name='FC_regression', activation='relu')(GlobalAvgPool_features)\\n if do_dropout:\\n FC_regression = keras.layers.Dropout(dropout_param)(FC_regression)\\n\\n FC_regression2 = keras.layers.Dense(512, name='FC_regression2', activation='relu')(FC_regression)\\n if do_dropout:\\n FC_regression2 = keras.layers.Dropout(dropout_param)(FC_regression2)\\n\\n outputs = keras.layers.Dense(1, name='regression')(FC_regression2)\\n\\n if option== 'reg_fpn_p3':\\n p3 = create_p3_feature(C3, C4, C5)\\n GlobalAvgPool_features = keras.layers.GlobalAveragePooling2D()(p3)\\n FC_regression = keras.layers.Dense(128, name='FC_regression', activation='relu')(GlobalAvgPool_features)\\n FC_regression2 = keras.layers.Dense(64, name='FC_regression2', activation='relu')(FC_regression)\\n outputs = keras.layers.Dense(1, name='regression')(FC_regression2)\\n\\n if option== 'reg_fpn_p3_p7_avg':\\n # compute pyramid features as per https://arxiv.org/abs/1708.02002\\n features = create_pyramid_features(C3, C4, C5)\\n FC_submodel = submodel_single_out(do_dropout=do_dropout, dropout_param=dropout_param)\\n outputs = [FC_submodel(GAF) for GAF in features]\\n\\n if option== 'reg_fpn_p3_p7_min_sig' or option== 'reg_fpn_p3_p7_mle' or option== 'reg_fpn_p3_p7_min_sig_L1' or option=='reg_fpn_p3_p7_mle_L1':\\n # compute pyramid features as per https://arxiv.org/abs/1708.02002\\n features = create_pyramid_features(C3, C4, C5)\\n FC_submodel = submodel(do_dropout=do_dropout, dropout_param=dropout_param)\\n outputs = [FC_submodel(GAF) for GAF in features]\\n\\n if option== 'reg_fpn_p3_p7_min_sig' or option== 'reg_fpn_p3_p7_mle' or option== 'reg_fpn_p3_p7_min_sig_L1' or option=='reg_fpn_p3_p7_mle_L1':\\n # compute pyramid features as per https://arxiv.org/abs/1708.02002\\n features = create_pyramid_features(C3, C4, C5)\\n FC_submodel = submodel(do_dropout=do_dropout, dropout_param=dropout_param)\\n outputs = [FC_submodel(GAF) for GAF in features]\\n\\n\\n return keras.models.Model(inputs=inputs, outputs=outputs, name=name)\",\n \"def VGGFace(input_shape=(224, 224, 3), n_classes=10, include_top=True):\\n # Create the Tensor\\n input = Input(shape=input_shape)\\n\\n # Block 1\\n # 1st Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv1')(input)\\n x = Activation('relu', name='block1_relu1')(x)\\n\\n # 2nd Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv2')(x)\\n x = Activation('relu', name='block1_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block1_pool')(x)\\n\\n # Block 2\\n # 3rd Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv1')(x)\\n x = Activation('relu', name='block2_relu1')(x)\\n\\n # 4th Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv2')(x)\\n x = Activation('relu', name='block2_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block2_pool')(x)\\n\\n # Block 3\\n # 5th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv1')(x)\\n x = Activation('relu', name='block3_relu1')(x)\\n\\n # 6th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv2')(x)\\n x = Activation('relu', name='block3_relu2')(x)\\n\\n # 7th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv3')(x)\\n x = Activation('relu', name='block3_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block3_pool')(x)\\n\\n # Block 4\\n # 8th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv1')(x)\\n x = Activation('relu', name='block4_relu1')(x)\\n\\n # 9th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv2')(x)\\n x = Activation('relu', name='block4_relu2')(x)\\n\\n # 10th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv3')(x)\\n x = Activation('relu', name='block4_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block4_pool')(x)\\n\\n # Block 5\\n # 11th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv1')(x)\\n x = Activation('relu', name='block5_relu1')(x)\\n\\n # 12th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv2')(x)\\n x = Activation('relu', name='block5_relu2')(x)\\n\\n # 13th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv3')(x)\\n x = Activation('relu', name='block5_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block5_pool')(x)\\n\\n # Block 6\\n # 14th Convulation Layer\\n x = Conv2D(4096, (7, 7), strides=(1, 1), name='fc1_conv1')(x)\\n x = Activation('relu', name='fc1_relu1')(x)\\n x = Dropout(0.5)(x)\\n\\n # 15th Convulation Layer\\n x = Conv2D(4096, (1, 1), strides=(1, 1), name='fc2_conv1')(x)\\n x = Activation('relu', name='fc2_relu2')(x)\\n x = Dropout(0.5, name='fc2_dropout')(x)\\n\\n # 16th Convulation Layer\\n x = Conv2D(2622, (1, 1), strides=(1, 1), name='fc3_conv1')(x)\\n x = Flatten(name='fc3_flatten')(x)\\n\\n if include_top:\\n # Output Layer\\n x = Activation('softmax', name='predictions_softmax')(x)\\n\\n # Create model\\n model = keras.models.Model(input, x, name='vggface')\\n return model\",\n \"def discriminator_block(in_filters, out_filters, normalization=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalization=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def __init__(self, num_gpus):\\n\\n super(Discriminator, self).__init__()\\n n_in = IMG_CHANNELS\\n n_out = 1\\n\\n feature_map = IMG_SIZE\\n kernel_size = 4\\n stride = 2\\n padding = 1\\n bias = False\\n\\n self.num_gpus = num_gpus\\n\\n self.network = nn.Sequential(\\n # input is image\\n nn.Conv2d(n_in, feature_map, kernel_size, stride, padding, bias=bias),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 2\\n nn.Conv2d(feature_map, feature_map * 2, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 4\\n nn.Conv2d(feature_map * 2, feature_map * 4, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 8\\n nn.Conv2d(feature_map * 4, feature_map * 8, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 8),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = 1\\n nn.Conv2d(feature_map * 8, n_out, kernel_size, 1, 0, bias=bias),\\n nn.Sigmoid()\\n )\",\n \"def _build(self, generation):\\n with tf.variable_scope ('discriminator') as scope:\\n \\n image_unflatten = unflatten_layer ( self.images )\\n gen_unflatten = unflatten_layer ( generation )\\n\\n # Conv Layer 1 - image\\n conv1_out_image, params = conv_2d_layer (\\n input = image_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'conv_1_img',\\n visualize = True ) \\n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \\n \\n # Conv Layer 1 - gen\\n conv1_out_gen, params = conv_2d_layer (\\n input = gen_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n params = params,\\n name = 'conv_1_gen',\\n visualize = False )\\n\\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \\n process_params(params, name = self.name)\\n c1_params = params\\n\\n\\n\\n\\n\\n # Conv Layer 2 - image\\n conv2_out_image, params = conv_2d_layer (\\n input = lrn1_out_img,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'conv_2_img' )\\n\\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \\n\\n\\n # Conv Layer 2 - gen\\n conv2_out_gen, params = conv_2d_layer (\\n input = lrn1_out_gen,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n params = params,\\n name = 'conv_2_gen' )\\n\\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \\n process_params(params, name = self.name)\\n c2_params = params\\n\\n # Dropout Layer\\n flat_gen = flatten_layer(lrn2_out_gen)\\n flat_img = flatten_layer(lrn2_out_img)\\n\\n flat_gen_dropout = dropout_layer ( input = flat_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_1_gen') \\n\\n flat_img_dropout = dropout_layer ( input = flat_img,\\n prob = self.dropout_prob,\\n name = 'dropout_1_img') \\n\\n\\n\\n # Dot Product Layer 1 -img\\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\\n neurons = HIDDEN_1,\\n name = 'image_disc_dot_1')\\n # Dot Product Layer 1 - gen\\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_1')\\n\\n process_params(params, name = self.name)\\n d1_params = params\\n \\n ##\\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_2_gen') \\n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_2_img')\\n\\n # Dot Product Layer 2 -img\\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\\n neurons = HIDDEN_2,\\n name = 'image_disc_dot_2')\\n # Dot Product Layer 2 - gen\\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_2')\\n process_params(params, name = self.name)\\n d2_params = params\\n\\n ##\\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_3_gen') \\n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_3_img')\\n\\n # Dot Product Layer 1 -img\\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'real')\\n # Dot Product Layer 1 -gen\\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\\n params = params,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'fake')\\n\\n process_params(params, name = self.name)\\n d3_params = params\\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \\n\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \\n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\\\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\\\\n 0.5 * tf.reduce_mean ((self.fake)**2)\\n tf.summary.scalar('discriminator_obj', discriminator_obj)\\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \\n\\n with tf.variable_scope (self.name + '_probabilites') as scope: \\n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\\n \\n self._cook_optimizer( \\n lr = DIS_GAN_LR, \\n optimizer = DIS_GAN_OPTIMIZER,\\n l1_coeff = DIS_GAN_L1_COEFF,\\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)\",\n \"def _init_predictor(self):\\n self.conv_cls_prev = self._init_branch(\\n conv_channels=self.cls_branch,\\n conv_strides=(1, ) * len(self.cls_branch))\\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\\n 1)\\n # init regression head\\n self.conv_reg_prevs = nn.ModuleList()\\n # init output head\\n self.conv_regs = nn.ModuleList()\\n # group_reg_dims:\\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\\n for i in range(len(self.group_reg_dims)):\\n reg_dims = self.group_reg_dims[i]\\n reg_branch_channels = self.reg_branch[i]\\n out_channel = self.out_channels[i]\\n reg_list = nn.ModuleList()\\n if len(reg_branch_channels) > 0:\\n self.conv_reg_prevs.append(\\n self._init_branch(\\n conv_channels=reg_branch_channels,\\n conv_strides=(1, ) * len(reg_branch_channels)))\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\\n self.conv_regs.append(reg_list)\\n else:\\n self.conv_reg_prevs.append(None)\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\\n self.conv_regs.append(reg_list)\",\n \"def build_graph(self):\\n n_classes = self.n_classes\\n\\n (self.feed('data')\\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\\n .conv(3, 3, 256, 1, 1, name='conv3_1')\\n .conv(3, 3, 256, 1, 1, name='conv3_2')\\n .conv(3, 3, 256, 1, 1, name='conv3_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\\n .conv(3, 3, 512, 1, 1, name='conv4_1')\\n .conv(3, 3, 512, 1, 1, name='conv4_2')\\n .conv(3, 3, 512, 1, 1, name='conv4_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\\n .conv(3, 3, 512, 1, 1, name='conv5_1')\\n .conv(3, 3, 512, 1, 1, name='conv5_2')\\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\\n\\n self.compute_rDeRF() # dummy\\n\\n # Classification\\n (self.feed('conv5_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\\n .fc(4096, name='fc6')\\n .dropout(0.5, name='drop6')\\n .fc(4096, name='fc7')\\n .dropout(0.5, name='drop7')\\n # .make_time(name='drop7_reduced')\\n .fc(n_classes, relu=False, name='cls_score')\\n .softmax(name='cls_prob'))\\n pass\",\n \"def build_discriminator():\\n leakyrelu_alpha = 0.2\\n momentum = 0.8\\n input_shape = (256, 256, 3)\\n\\n input_layer = Input(shape=input_shape)\\n\\n # Add the first convolution block\\n dis1 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(input_layer)\\n dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)\\n\\n # Add the 2nd convolution block\\n dis2 = Conv2D(filters=64, kernel_size=3, strides=2, padding='same')(dis1)\\n dis2 = LeakyReLU(alpha=leakyrelu_alpha)(dis2)\\n dis2 = BatchNormalization(momentum=momentum)(dis2)\\n\\n # Add the third convolution block\\n dis3 = Conv2D(filters=128, kernel_size=3, strides=1, padding='same')(dis2)\\n dis3 = LeakyReLU(alpha=leakyrelu_alpha)(dis3)\\n dis3 = BatchNormalization(momentum=momentum)(dis3)\\n\\n # Add the fourth convolution block\\n dis4 = Conv2D(filters=128, kernel_size=3, strides=2, padding='same')(dis3)\\n dis4 = LeakyReLU(alpha=leakyrelu_alpha)(dis4)\\n dis4 = BatchNormalization(momentum=0.8)(dis4)\\n\\n # Add the fifth convolution block\\n dis5 = Conv2D(256, kernel_size=3, strides=1, padding='same')(dis4)\\n dis5 = LeakyReLU(alpha=leakyrelu_alpha)(dis5)\\n dis5 = BatchNormalization(momentum=momentum)(dis5)\\n\\n # Add the sixth convolution block\\n dis6 = Conv2D(filters=256, kernel_size=3, strides=2, padding='same')(dis5)\\n dis6 = LeakyReLU(alpha=leakyrelu_alpha)(dis6)\\n dis6 = BatchNormalization(momentum=momentum)(dis6)\\n\\n # Add the seventh convolution block\\n dis7 = Conv2D(filters=512, kernel_size=3, strides=1, padding='same')(dis6)\\n dis7 = LeakyReLU(alpha=leakyrelu_alpha)(dis7)\\n dis7 = BatchNormalization(momentum=momentum)(dis7)\\n\\n # Add the eight convolution block\\n dis8 = Conv2D(filters=512, kernel_size=3, strides=2, padding='same')(dis7)\\n dis8 = LeakyReLU(alpha=leakyrelu_alpha)(dis8)\\n dis8 = BatchNormalization(momentum=momentum)(dis8)\\n\\n # Add a dense layer\\n #avgd = keras.layers.AveragePooling2D(pool_size=(4,4) , strides = (4,4))(dis8)\\n\\n #flat = keras.layers.Flatten()(dis8)\\n dis9 = Dense(units=1024)(dis8)\\n dis9 = LeakyReLU(alpha=0.2)(dis9)\\n\\n # Last dense layer - for classification\\n output = Dense(units=1, activation='sigmoid')(dis9)\\n\\n model = Model(inputs=[input_layer], outputs=[output], name='discriminator')\\n return model\",\n \"def build_discriminator2D(self, model_shape, filters=32, k_size=4, drop=False, rate=0.5, extra_conv=False, summary=False, ln=False, model_file=None, name='gan_d_'):\\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 Create a Discriminator Model using hyperparameters values defined as follows\\n \\\"\\\"\\\"\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n\\n input_shape = (n_rows, n_cols, c_dims) \\n input_layer = Input(shape=input_shape, name=name+'input')\\n\\n d = self.Conv2D_Block(input_layer, filters, k_size=k_size, name=name+'1', bn=False) # 30x30x32\\n d = self.Conv2D_Block(d, 2*filters, k_size=k_size, ln=ln, name=name+'2') # 15x15x64\\n d = self.Conv2D_Block(d, 4*filters, k_size=k_size, ln=ln, name=name+'3') # 8x8x128\\n if extra_conv:\\n d = self.Conv2D_Block(d, 8*filters, strides=2, k_size=k_size, ln=ln, name=name+'4') # 8x8x256 \\n d = self.Conv2D_Block(d, 16*filters, strides=1, k_size=k_size, ln=ln, name=name+'5') # 8x8x256\\n else:\\n d = self.Conv2D_Block(d, 8*filters, strides=1, k_size=k_size, ln=ln, name=name+'4')\\n\\n d = Flatten(name=name+'flatten')(d)\\n if drop:\\n d = Dropout(rate=rate, name=name+'dropout')(d, training=True)\\n logits = Dense(1, activation='linear', kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(d)\\n out = Activation('sigmoid', name=name+'sigmoid')(logits)\\n\\n model = Model(inputs=[input_layer], outputs=[out, logits], name='Discriminator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def _model_definition(self, net):\\n \\n # Input filtering and downsampling with max pooling\\n print(net.shape) #channels must be specified first otherwise keras assumes channels last\\n print('resnet17_scp')\\n \\n net = Conv2D( filters=128, kernel_size=5, activation=None, padding='same', \\n data_format=\\\"channels_first\\\", input_shape=(1, 100, 100))(net)\\n net = BatchNormalization(axis=1)(net) #axis is set to the dimension which hold the colour channels\\n net = LeakyReLU()(net)\\n net= MaxPooling2D(pool_size=(2,2))(net)\\n \\n net = Conv2D( filters=64, kernel_size=3, activation=None, padding='same', data_format=\\\"channels_first\\\")(net)\\n net = BatchNormalization(axis=1)(net) #axis is set to the dimension which hold the colour channels\\n net = LeakyReLU()(net)\\n net= MaxPooling2D(pool_size=(2,2))(net)\\n \\n net = Conv2D( filters=64, kernel_size=3,activation=None, padding='same', data_format=\\\"channels_first\\\")(net)\\n net = BatchNormalization(axis=1)(net) #axis is set to the dimension which hold the colour channels \\n net = LeakyReLU()(net)\\n net= MaxPooling2D(pool_size=(2,2))(net)\\n \\n\\n\\n \\n return net\",\n \"def build_discriminator():\\n\\n #Slope and weight initializer are chosen to match parmeters in the paper\\n weight_initializer = tf.keras.initializers.RandomNormal(stddev=0.02)\\n slope = 0.2\\n inputs = keras.Input(shape=(64,64,3))\\n x = preprocessing.Rescaling(scale=1./127.5, offset=-1.)(inputs)\\n\\n # First conv layer\\n x = Conv2D(\\n 64,\\n 4,\\n 2,\\n padding='same',\\n use_bias=False,\\n kernel_initializer=weight_initializer\\n )(x)\\n x = LeakyReLU(alpha=slope)(x)\\n\\n # Second conv layer\\n x = Conv2D(\\n 128,\\n 4,\\n 2,\\n padding='same',\\n use_bias=False,\\n kernel_initializer=weight_initializer\\n )(x)\\n x = BatchNormalization()(x)\\n x = LeakyReLU(alpha=slope)(x)\\n \\n # Third conv layer\\n x = Conv2D(\\n 256,\\n 4,\\n 2,\\n padding='same',\\n use_bias=False,\\n kernel_initializer=weight_initializer\\n )(x)\\n x = BatchNormalization()(x)\\n x = LeakyReLU(alpha=slope)(x)\\n\\n # Fourth conv layer\\n x = Conv2D(\\n 512,\\n 4,\\n 2,\\n padding='same',\\n use_bias=False,\\n kernel_initializer=weight_initializer\\n )(x)\\n x = BatchNormalization()(x)\\n x = LeakyReLU(alpha=slope)(x)\\n\\n # Predictions. Note that we use logits so thhere is no activation at the end. \\n x = layers.Flatten()(x)\\n x = layers.Dense(1,kernel_initializer=weight_initializer)(x)\\n \\n model = keras.Model(inputs=inputs, outputs=x)\\n return model\",\n \"def build_discriminator(shape):\\n input_img = Input(shape=(shape)) \\n x = Conv2D(64, (3, 3), padding='same')(input_img)\\n x = LeakyReLU()(x)\\n x = Dropout(0.25)(x)\\n x = BatchNormalization(momentum=0.8)(x)\\n x = AveragePooling2D((2, 2), padding='same')(x)\\n x = Conv2D(8, (3, 3), padding='same')(x)\\n x = LeakyReLU()(x)\\n x = Dropout(0.25)(x)\\n x = BatchNormalization(momentum=0.8)(x)\\n x = AveragePooling2D((2, 2), padding='same')(x)\\n x = Conv2D(8, (3, 3), padding='same')(x)\\n x = LeakyReLU()(x)\\n x = Dropout(0.25)(x)\\n x = BatchNormalization(momentum=0.8)(x)\\n x = AveragePooling2D((2, 2), padding='same')(x)\\n x = Conv2D(1, (3, 3), padding='same')(x)\\n x = LeakyReLU()(x)\\n x = Flatten()(x)\\n o = Dense(1,activation='sigmoid')(x)\\n Discriminator=Model(input_img,o,name='discriminator')\\n return input_img,o,Discriminator\",\n \"def model_build(self):\\n\\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\\n X_input = Input(self.inputData[0].shape)\\n\\n '''\\n # CONV -> BN -> RELU Block applied to X\\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\\n X = BatchNormalization(name='bn0')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\\n X = Dropout(0.1, name='dropout0')(X)\\n\\n X = Conv2D(16, (16, 16), name='conv1')(X)\\n X = BatchNormalization(name='bn1')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\\n X = Dropout(0.1, name='dropout1')(X)\\n\\n X = Conv2D(16, (32, 32), name='conv2')(X)\\n X = BatchNormalization(name='bn2')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n' '''\\n\\n X = Dense(500, activation='relu', name='fc0')(X_input)\\n X = Dropout(0.1, name='dropout1')(X)\\n X = Dense(500, activation='relu', name='fc1')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n X = Dense(3, activation='softmax', name='fc2')(X)\\n\\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')\",\n \"def construct_gumbel_selector(X_ph, num_words, embedding_dims, maxlen):\\n emb_layer = Embedding(num_words, embedding_dims, input_length = maxlen, name = 'emb_gumbel')\\n emb = emb_layer(X_ph) #(400, 50) \\n net = Dropout(0.2, name = 'dropout_gumbel')(emb)\\n net = emb\\n first_layer = Conv1D(100, kernel_size, padding='same', activation='relu', strides=1, name = 'conv1_gumbel')(net) # bs, 400, 100\\n\\n # global info\\n net_new = GlobalMaxPooling1D(name = 'new_global_max_pooling1d_1')(first_layer) # bs, 100\\n global_info = Dense(100, name = 'new_dense_1', activation='relu')(net_new) # bs, 100\\n\\n # local info\\n net = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv2_gumbel')(first_layer) # bs, 400, 100\\n local_info = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv3_gumbel')(net) # bs, 400, 100\\n combined = Concatenate()([global_info,local_info]) \\n net = Dropout(0.2, name = 'new_dropout_2')(combined)\\n net = Conv1D(100, 1, padding='same', activation='relu', strides=1, name = 'conv_last_gumbel')(net) \\n\\n logits_T = Conv1D(1, 1, padding='same', activation=None, strides=1, name = 'conv4_gumbel')(net) # bs, 400, 1\\n # wanna make it bs, maxlen*num_groups\\n squeeze_layer = Lambda(lambda x:tf.squeeze(x), output_shape=lambda x:x[:-1])\\n\\n logits_T_grp = Dense(maxlen*num_groups)(squeeze_layer(logits_T))\\n #print(logits_T_grp.shape)\\n return logits_T_grp # bs, 400* num_groups\",\n \"def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\\n\\t\\t# We have to match this output size.\\n\\t\\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\\n\\t\\n\\t\\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\\n\\t\\n\\t\\t# Convolutional ops will go here.\\n\\t\\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tconv_output = c5\\n\\t\\n\\t\\t# Transition to FC layers.\\n\\t\\tpre_flat_shape = conv_output.get_shape().as_list()\\n\\t\\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\\n\\t\\n\\t\\t# Dense connections\\n\\t\\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\\n\\t\\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\\n\\t\\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\\n\\t\\tfc_out = fc2\\n\\t\\n\\t\\t# Output point and our encoder mix-in.\\n\\t\\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\\n\\t\\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\\n\\t\\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\\n\\t\\n\\t\\t# More dense connections on the offset.\\n\\t\\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\\n\\t\\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\\n\\t\\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\\n\\t\\n\\t\\t# Expand for more convolutional operations.\\n\\t\\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\\n\\t\\n\\t\\t# More convolutions here.\\n\\t\\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\\n\\t\\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\\n\\t\\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\\n\\t\\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tdeconv_output = dc0\\n\\t\\n\\t\\t# Return result + encoder output\\n\\t\\treturn deconv_output, encoded_output\",\n \"def build_discriminator(self):\\n with tf.variable_scope(\\\"discriminator\\\") as scope:\\n\\n # --- build the convolutional layers\\n self.d_convlayers = list()\\n mi = self.num_colors\\n dim = self.img_dim\\n count = 0\\n for mo, filter_size, stride, apply_batch_norm in self.d_sizes['conv_layers']:\\n name = f\\\"convlayer_{count}\\\" # name is used for get_variable later\\n count += 1\\n layer = ConvLayer(name, mi, mo, apply_batch_norm, filter_size, stride, lrelu)\\n self.d_convlayers.append(layer)\\n mi = mo\\n print(f\\\"dim: {dim}\\\")\\n # --- keep track of image dimensionality: need this for the first Dense layer\\n dim = int(np.ceil(float(dim) / stride))\\n\\n # --- get the input dimensionalith for the first Dense layer\\n mi = mi * dim * dim\\n\\n # --- build the dense layers\\n self.d_denselayers = list()\\n for mo, apply_batch_norm in self.d_sizes['dense_layers']:\\n name = f\\\"denselayer_{count}\\\"\\n count += 1\\n layer = DenseLayer(name, mi, mo, apply_batch_norm, lrelu)\\n mi = mo\\n self.d_denselayers.append(layer)\\n\\n # --- final logistic regression layer (use it in the d_forward\\n # function below to get the final logits)\\n name = f\\\"denselayer_{count}\\\"\\n self.d_finallayer = DenseLayer(name, mi, 1, False, lambda x: x)\\n\\n # --- get and return the logits\\n logits = self.d_forward(self.X)\\n return logits\",\n \"def faceRecoModel(input_shape):\\n\\n # Define the input as a tensor with shape input_shape\\n X_input = Input(input_shape)\\n\\n # Zero-Padding\\n X = ZeroPadding2D((3, 3))(X_input)\\n\\n # First Block\\n X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X)\\n X = BatchNormalization(axis=1, name='bn1')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n X = MaxPooling2D((3, 3), strides=2)(X)\\n\\n # Second Block\\n X = Conv2D(64, (1, 1), strides=(1, 1), name='conv2')(X)\\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn2')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n\\n # Second Block\\n X = Conv2D(192, (3, 3), strides=(1, 1), name='conv3')(X)\\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn3')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n X = MaxPooling2D(pool_size=3, strides=2)(X)\\n\\n # Inception 1: a/b/c\\n X = inception_block_1a(X)\\n X = inception_block_1b(X)\\n X = inception_block_1c(X)\\n\\n # Inception 2: a/b\\n X = inception_block_2a(X)\\n X = inception_block_2b(X)\\n\\n # Inception 3: a/b\\n X = inception_block_3a(X)\\n X = inception_block_3b(X)\\n\\n # Top layer\\n X = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\\n X = Flatten()(X)\\n X = Dense(128, name='dense_layer')(X)\\n\\n # L2 normalization\\n X = Lambda(lambda x: tf.nn.l2_normalize(x, dim=1))(X)\\n\\n # Create model instance\\n model = Model(inputs=X_input, outputs=X, name='FaceRecoModel')\\n\\n return model\",\n \"def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\\\"sigmoid\\\"):\\n\\n # inizializzo il modello come sequenziale\\n model = Sequential()\\n inputShape = (imageHeight, imageWidth, imageDepth)\\n chanDim = -1\\n\\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\\n # Utilizzo 32 filtri 3*3\\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\\\"same\\\", input_shape=inputShape))\\n # con attivazione Rectified Linear Unit\\n model.add(Activation(\\\"relu\\\"))\\n # applico una batch normalization\\n model.add(BatchNormalization(axis=chanDim))\\n # un MaxPooling 3*3\\n model.add(MaxPooling2D(pool_size=(3, 3)))\\n # ed un 25% di dropout per ridurre overfitting\\n model.add(Dropout(0.25))\\n\\n # Secondo blocco\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Terzo blocco\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Passo ai Fully Connected Layers\\n # Trasformo il modello in un vettore\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Activation(\\\"sigmoid\\\"))\\n model.add(BatchNormalization())\\n model.add(Dropout(0.5))\\n\\n # Infine utilizzo l'attivazione per la rete\\n model.add(Dense(classesNumber))\\n model.add(Activation(finalAct))\\n\\n return model\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def global_discriminator(images,\\n # is_training,\\n reuse=None):\\n # batch_size = images.get_shape().as_list()[0]\\n conv_layers = []\\n # bn_layers = []\\n with tf.variable_scope('global_discriminator', reuse=reuse):\\n conv1 = Conv2dLayer(images, [3, 3, 3, 64], stride=2, name='conv1')\\n # bn1_layer = BatchNormLayer(conv1.output, is_training, name='bn1')\\n bn1 = tf.nn.leaky_relu(conv1.output)\\n conv_layers.append(conv1)\\n # bn_layers.append(bn1_layer)\\n\\n conv2 = Conv2dLayer(bn1, [3, 3, 64, 128], stride=2, name='conv2')\\n # bn2_layer = BatchNormLayer(conv2.output, is_training, name='bn2')\\n bn2 = tf.nn.leaky_relu(conv2.output)\\n conv_layers.append(conv2)\\n # bn_layers.append(bn2_layer)\\n\\n conv3 = Conv2dLayer(bn2, [3, 3, 128, 256], stride=2, name='conv3')\\n # bn3_layer = BatchNormLayer(conv3.output, is_training, name='bn3')\\n bn3 = tf.nn.leaky_relu(conv3.output)\\n conv_layers.append(conv3)\\n # bn_layers.append(bn3_layer)\\n\\n conv4 = Conv2dLayer(bn3, [3, 3, 256, 512], stride=2, name='conv4')\\n # bn4_layer = BatchNormLayer(conv4.output, is_training, name='bn4')\\n bn4 = tf.nn.leaky_relu(conv4.output)\\n conv_layers.append(conv4)\\n # bn_layers.append(bn4_layer)\\n\\n conv5 = Conv2dLayer(bn4, [3, 3, 512, 512], stride=2, name='conv5')\\n # bn5_layer = BatchNormLayer(conv5.output, is_training, name='bn5')\\n bn5 = tf.nn.leaky_relu(conv5.output)\\n conv_layers.append(conv5)\\n # bn_layers.append(bn5_layer)\\n\\n conv6 = Conv2dLayer(bn5, [3, 3, 512, 512], stride=2, name='conv6')\\n # bn6_layer = BatchNormLayer(conv6.output, is_training, name='bn6')\\n bn6 = tf.nn.leaky_relu(conv6.output)\\n conv_layers.append(conv6)\\n # bn_layers.append(bn6_layer)\\n\\n fc7 = FCLayer(bn6, 1, name='fc7')\\n conv_layers.append(fc7)\\n\\n print('Print the global discriminator network constructure:')\\n for conv_layer in conv_layers:\\n tf.add_to_collection('global_dis_params_conv', conv_layer.w)\\n tf.add_to_collection('global_dis_params_conv', conv_layer.b)\\n tf.add_to_collection('weight_decay_global_dis', tf.nn.l2_loss(conv_layer.w))\\n print('conv_{} shape:{}'.format(conv_layers.index(conv_layer) + 1, conv_layer.output_shape))\\n\\n # for bn_layer in bn_layers:\\n # tf.add_to_collection('global_dis_params_bn', bn_layer.scale)\\n # tf.add_to_collection('global_dis_params_bn', bn_layer.beta)\\n\\n return fc7.output[:, 0]\",\n \"def discriminator(self):\\n\\n # Initializate the neural network\\n discriminator = Sequential()\\n\\n # Convolution, bias, activate\\n discriminator.add(Conv2D(filters=self.first_layer_filter,\\n kernel_size=self.kernel_size,\\n strides=self.stride_size,\\n padding='same',\\n data_format='channels_last',\\n kernel_initializer='glorot_uniform',\\n input_shape=self.image_shape))\\n # Activate\\n discriminator.add(LeakyReLU(0.2))\\n # Convolution\\n discriminator.add(Conv2D(filters=self.second_layer_filter,\\n kernel_size=self.kernel_size,\\n strides=self.stride_size,\\n padding='same',\\n data_format='channels_last',\\n kernel_initializer='glorot_uniform'))\\n\\n # Normalize\\n discriminator.add(BatchNormalization(momentum=0.5, epsilon=1e-5))\\n # Activate\\n discriminator.add(LeakyReLU(0.2))\\n\\n # Convolution\\n discriminator.add(Conv2D(filters=self.third_layer_filter,\\n kernel_size=self.kernel_size,\\n strides=self.stride_size,\\n padding='same',\\n data_format='channels_last',\\n kernel_initializer='glorot_uniform'))\\n\\n # Normalize\\n discriminator.add(BatchNormalization(momentum=0.5, epsilon=1e-5))\\n # Activate\\n discriminator.add(LeakyReLU(0.2))\\n # Convolution\\n discriminator.add(Conv2D(filters=self.last_layer_size,\\n kernel_size=self.kernel_size,\\n strides=self.stride_size,\\n padding='same',\\n data_format='channels_last',\\n kernel_initializer='glorot_uniform'))\\n # Normalize\\n discriminator.add(BatchNormalization(momentum=0.5, epsilon=1e-5))\\n # Activate\\n discriminator.add(LeakyReLU(0.2))\\n\\n discriminator.add(Flatten())\\n discriminator.add(Dense(1))\\n discriminator.add(Activation('sigmoid'))\\n\\n optimizer = Adam(lr=self.lr, beta_1=self.beta)\\n discriminator.compile(loss=self.loss,\\n optimizer=optimizer,\\n metrics=None)\\n\\n return discriminator\",\n \"def faceRecoModel(input_shape):\\n\\t# Define the input as a tensor with shape input_shape\\n\\tX_input = Input(input_shape)\\n\\t# Zero-Padding\\n\\tX = ZeroPadding2D((3, 3))(X_input)\\n\\t# First Block\\n\\tX = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1')(X)\\n\\tX = BatchNormalization(axis = 1, name = 'bn1')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\tX = MaxPooling2D((3, 3), strides = 2)(X)\\n\\t# Second Block\\n\\tX = Conv2D(64, (1, 1), strides = (1, 1), name = 'conv2')(X)\\n\\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn2')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\t# Second Block\\n\\tX = Conv2D(192, (3, 3), strides = (1, 1), name = 'conv3')(X)\\n\\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn3')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\tX = MaxPooling2D(pool_size = 3, strides = 2)(X)\\n\\t# Inception 1: a/b/c\\n\\t# X = inception_block_1a(X)\\n\\t# X = inception_block_1b(X)\\n\\t# X = inception_block_1c(X)\\n\\t# # Inception 2: a/b\\n\\t# X = inception_block_2a(X)\\n\\t# X = inception_block_2b(X)\\n\\t# # Inception 3: a/b\\n\\t# X = inception_block_3a(X)\\n\\t# X = inception_block_3b(X)\\n\\t# Top layer\\n\\tX = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\\n\\tX = Flatten()(X)\\n\\tX = Dense(10, name='dense_layer')(X)\\n\\t# L2 normalization\\n\\tX = Lambda(lambda x: K.l2_normalize(x,axis=1))(X)\\n\\t# Create model instance\\n\\tmodel = Model(inputs = X_input, outputs = X, name='FaceRecoModel')\\n\\treturn model\",\n \"def define_discriminator(image_shape=(256, 256, 1)):\\n\\n # weight initialization\\n init = RandomNormal(stddev=0.02)\\n # source image input\\n in_src_image = Input(shape=image_shape)\\n # target image input\\n in_target_image = Input(shape=image_shape)\\n # concatenate images channel-wise\\n merged = Concatenate()([in_src_image, in_target_image])\\n # C64\\n d = Conv2D(64, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(merged)\\n d = LeakyReLU(alpha=0.2)(d)\\n # C128\\n d = Conv2D(128, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(d)\\n d = BatchNormalization()(d)\\n d = LeakyReLU(alpha=0.2)(d)\\n # C256\\n d = Conv2D(256, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(d)\\n d = BatchNormalization()(d)\\n d = LeakyReLU(alpha=0.2)(d)\\n # C512\\n d = Conv2D(512, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(d)\\n d = BatchNormalization()(d)\\n d = LeakyReLU(alpha=0.2)(d)\\n # second last output layer\\n d = Conv2D(512, (4, 4), padding='same', kernel_initializer=init)(d)\\n d = BatchNormalization()(d)\\n d = LeakyReLU(alpha=0.2)(d)\\n # patch output\\n d = Conv2D(1, (4, 4), padding='same', kernel_initializer=init)(d)\\n patch_out = Activation('sigmoid')(d)\\n # define model\\n model = Model([in_src_image, in_target_image], patch_out)\\n # compile model\\n opt = Adam(lr=0.0002, beta_1=0.5)\\n model.compile(loss='binary_crossentropy', optimizer=opt,\\n loss_weights=[0.5])\\n\\n return model\",\n \"def build(self):\\n\\n # bgr_ = bgr*255.0\\n bgr_= self.X\\n start_time = time.time()\\n print(\\\"build model started\\\")\\n\\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n # blue - VGG_MEAN[0],\\n # green - VGG_MEAN[1],\\n # red - VGG_MEAN[2],\\n\\n red - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n blue - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n\\n\\n\\n print(bgr.shape)\\n\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n\\n\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\\n\\n\\n\\n\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\\n\\n self.fc6 = self.fc_layer(self.pool5, \\\"fc6\\\")\\n assert self.fc6.get_shape().as_list()[1:] == [4096]\\n self.relu6 = tf.nn.relu(self.fc6)\\n\\n self.fc7 = self.fc_layer(self.relu6, \\\"fc7\\\")\\n self.relu7 = tf.nn.relu(self.fc7)\\n\\n self.fc8 = self.fc_layer(self.relu7, \\\"fc8\\\")\\n\\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\\n # self.relu9 = tf.nn.relu(self.fc9)\\n\\n\\n\\n\\n relu8 = tf.nn.relu(self.fc8)\\n fc9 = self.fc_layer(relu8, 'fc9')\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\\n return fc9\\n\\n # self.prob = tf.nn.softmax(self.fc8, name=\\\"prob\\\")\",\n \"def __init__(self):\\n super(Generator_Model, self).__init__()\\n\\n # audio encoder\\n self.audio_encoder = nn.Sequential(\\n conv_block(1, 32, kernel_size=1, stride=1, padding=1),\\n conv_block(32, 32, kernel_size=1, stride=1, padding=1, residual=True),\\n \\n conv_block(32, 64, kernel_size=3, stride=(3, 1), padding=1),\\n conv_block(64, 64, kernel_size=3, stride=1, padding=1, residual=True),\\n\\n conv_block(64, 128, kernel_size=3, stride=3, padding=1),\\n conv_block(128, 128, kernel_size=3, stride=1, padding=1, residual=True),\\n\\n conv_block(128, 256, kernel_size=3, stride=(3, 2), padding=1),\\n conv_block(256, 256, kernel_size=3, stride=1, padding=1, residual=True),\\n\\n conv_block(256, 512, kernel_size=3, stride=1, padding=0),\\n conv_block(512, 512, kernel_size=1, stride=1, padding=0)\\n )\\n\\n # face encoder\\n self.face_encoder = nn.ModuleList([\\n nn.Sequential(conv_block(6, 16, kernel_size=7, stride=1, padding=3)),\\n\\n nn.Sequential(conv_block(16, 32, kernel_size=3, stride=2, padding=1),\\n conv_block(32, 32, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_block(32, 64, kernel_size=3, stride=2, padding=1),\\n conv_block(64, 64, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_block(64, 128, kernel_size=3, stride=2, padding=1),\\n conv_block(128, 128, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_block(128, 256, kernel_size=3, stride=2, padding=1),\\n conv_block(256, 256, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_block(256, 512, kernel_size=3, stride=2, padding=1),\\n conv_block(512, 512, kernel_size=3, stride=1, padding=1, residual=True)),\\n \\n nn.Sequential(conv_block(512, 512, kernel_size=3, stride=1, padding=0),\\n conv_block(512, 512, kernel_size=1, stride=1, padding=0))\\n ])\\n\\n # face decoder\\n self.face_decoder = nn.ModuleList([\\n nn.Sequential(conv_block(512, 512, kernel_size=1, stride=1, padding=0),),\\n\\n nn.Sequential(conv_t_block(512, 512, kernel_size=3, stride=1, padding=0),\\n conv_block(512, 1024, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_t_block(1024, 512, kernel_size=3, stride=2, padding=1, output_padding=1),\\n conv_block(512, 768, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_t_block(768, 384, kernel_size=3, stride=2, padding=1, output_padding=1),\\n conv_block(384, 512, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_t_block(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1),\\n conv_block(256, 320, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_t_block(320, 128, kernel_size=3, stride=2, padding=1, output_padding=1), \\n conv_block(128, 160, kernel_size=3, stride=1, padding=1, residual=True)),\\n\\n nn.Sequential(conv_t_block(160, 64, kernel_size=3, stride=2, padding=1, output_padding=1),\\n conv_block(64, 64, kernel_size=3, stride=1, padding=1, residual=True))\\n ])\\n\\n # output blocks for face prediction\\n self.pred_output = nn.Sequential(conv_block(64, 32, kernel_size=3, stride=1, padding=1),\\n conv_block(32, 3, kernel_size=1, stride=1, padding=0),\\n nn.Sigmoid())\\n\\n # optimizer\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=0.001, betas=(0.5, 0.999))\",\n \"def create_model(input_shape=None):\\n\\n model = Sequential()\\n #n,height,width,chennel = input_shape\\n height = 146\\n width = 243\\n chennel = 3\\n\\n model.add(Conv2D(filters=4, input_shape=(width, height, chennel), kernel_size=(3, 3), padding='same'))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=4,kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=4, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=16, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=16, kernel_size=(5, 5)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Flatten())\\n model.add(Dense(64))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.25))\\n model.add(Dense(32))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.25))\\n model.add(Dense(8))\\n model.add(Activation('softmax'))\\n\\n sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.87, nesterov=True)\\n model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=[\\\"accuracy\\\"])\\n return model\",\n \"def build_model(self):\\n \\n start_time = time.time()\\n print(\\\"build model started\\\")\\n # label\\n self.FA = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.ges = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.obj = tf.placeholder(dtype=tf.int32, shape=[None])\\n \\n self.images = tf.placeholder(dtype=tf.float32, shape=[None, height, width, 3])\\n batch_size = tf.shape(self.images)[0]\\n rgb_scaled = self.images * 255.0\\n\\n # Convert RGB to BGR\\n VGG_MEAN = [103.939, 116.779, 123.68]\\n red, green, blue = tf.split(axis=3, num_or_size_splits=3, value=rgb_scaled)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n blue - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n red - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n \\n with tf.variable_scope(\\\"vgg19\\\"):\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.conv3_4 = self.conv_layer(self.conv3_3, \\\"conv3_4\\\")\\n self.pool3 = self.max_pool(self.conv3_4, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.conv4_4 = self.conv_layer(self.conv4_3, \\\"conv4_4\\\")\\n self.pool4 = self.max_pool(self.conv4_4, 'pool4')\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.conv5_4 = self.conv_layer(self.conv5_3, \\\"conv5_4\\\")\\n self.pool5 = self.max_pool(self.conv5_4, 'pool5')\\n\\n \\n shape = self.pool5.get_shape()\\n size = 1\\n for dim in shape[1:]:\\n size *= dim.value\\n \\n # dense\\n with tf.variable_scope('dense') as scope:\\n # Move everything into depth so we can perform a single matrix multiply.\\n reshape = tf.reshape(self.pool5, [-1, size])\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[size, 192]))\\n biases = tf.get_variable('biases', [192], initializer=tf.constant_initializer(0.1))\\n dense = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\\n\\n\\n # linear layer(WX + b),\\n with tf.variable_scope('softmax_linear_FA') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 2]))\\n biases = tf.get_variable('biases', [2], initializer=tf.constant_initializer(0.1))\\n softmax_linear_FA = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_FA = tf.nn.softmax(softmax_linear_FA)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.FA, logits=softmax_linear_FA, name='cross_entropy')\\n cross_entropy_mean_FA = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_ges') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 13]))\\n biases = tf.get_variable('biases', [13], initializer=tf.constant_initializer(0.1))\\n softmax_linear_ges = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_ges = tf.nn.softmax(softmax_linear_ges)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.ges, logits=softmax_linear_ges, name='cross_entropy')\\n cross_entropy_mean_ges = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_obj') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 24]))\\n biases = tf.get_variable('biases', [24], initializer=tf.constant_initializer(0.1))\\n softmax_linear_obj = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_obj = tf.nn.softmax(softmax_linear_obj)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.obj, logits=softmax_linear_obj, name='cross_entropy')\\n cross_entropy_mean_obj = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n self.loss = cross_entropy_mean_FA + cross_entropy_mean_ges + cross_entropy_mean_obj\\n self.lr = tf.placeholder(tf.float32, [])\\n self.global_step = tf.Variable(0, name=\\\"global_step\\\", trainable=False)\\n optimizer = tf.train.AdamOptimizer(self.lr)\\n grads_and_vars = optimizer.compute_gradients(self.loss)\\n self.train_op = optimizer.apply_gradients(grads_and_vars, global_step=self.global_step)\\n self.data_dict = None\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\",\n \"def build_model_mobilenet(num_classes):\",\n \"def baseUNet(input_shape,conv_depth,n_classes,init_w,dropout):\\n inputs = Input(input_shape)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding='same',\\n kernel_initializer=init_w)(inputs)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding=\\\"same\\\",\\n kernel_initializer=init_w)(c1)\\n\\n # pool down to next layer\\n pool1 = MaxPooling2D((2,2),strides = (2,2))(c1)\\n\\n conv_depth *= 2\\n\\n # convolute down again\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool1)\\n\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv2)\\n \\n # pool down again\\n pool2 = MaxPooling2D((2,2),strides = (2,2))(conv2)\\n\\n conv_depth *= 2 \\n\\n # Convolution\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool2)\\n\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv3)\\n \\n # pool down\\n pool3 = MaxPooling2D((2,2),strides = (2,2))(conv3)\\n\\n conv_depth *= 2 \\n # Convolution\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool3)\\n\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv4)\\n \\n # pool down \\n pool4 = MaxPooling2D((2,2),strides = (2,2))(conv4)\\n\\n conv_depth *=2 \\n\\n # Convolution\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool4)\\n\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv5)\\n\\n drop = Dropout(dropout)(conv5)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth) \\n # do upsampling\\n up1 = UpSampling2D(size = (2,2))(drop)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up1)\\n \\n # add in skip info\\n cat1 = concatenate([conv4,conv6],axis = 3)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat1)\\n\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv6)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up2 = UpSampling2D(size = (2,2))(conv6)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up2)\\n \\n # add in skip info\\n cat2 = concatenate([conv3,conv7],axis = 3)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat2)\\n\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv7)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up3 = UpSampling2D(size = (2,2))(conv7)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size=(3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up3)\\n \\n # add in skip info\\n cat3 = concatenate([conv2,conv8],axis = 3)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat3)\\n\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv8)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up4 = UpSampling2D(size = (2,2))(conv8)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up4)\\n \\n # add in skip info\\n cat4 = concatenate([c1,conv9],axis = 3)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat4)\\n\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv9)\\n\\n outputs = Conv2D(n_classes, 1, activation = 'softmax')(conv9)\\n\\n return outputs,inputs\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def discriminator_block_conditionnal(self, name):\\n \\n if self.fit_mask : \\n \\n im = Input(shape=(2+self.nb_classe_mask, self.image_row, self.image_column, self.image_depth), name='dis_input')\\n \\n else :\\n # In:\\n im = Input(shape=(2, self.image_row, self.image_column, self.image_depth), name='dis_input')\\n\\n\\n res = Input(shape=(1, self.image_row, self.image_column, self.image_depth), name='dis_input_res')\\n\\n inputs = Concatenate(axis=-4)([im, res])\\n\\n # Input 64\\n disnet = Conv3D(self.discriminator_kernel * 1, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_1')(inputs)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 1 : 32\\n disnet = Conv3D(self.discriminator_kernel * 2, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_2')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 2 : 16\\n disnet = Conv3D(self.discriminator_kernel * 4, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_3')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 3 : 8\\n disnet = Conv3D(self.discriminator_kernel * 8, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_4')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 4 : 4\\n disnet = Conv3D(self.discriminator_kernel * 16, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_5')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n\\n \\n decision = Conv3D(1, 2, strides=1,\\n use_bias=False,\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name='dis_decision')(disnet)\\n\\n decision = Reshape((1,))(decision)\\n\\n model = Model(inputs=[im, res], outputs=[decision], name=name)\\n\\n return model\",\n \"def build_discriminator(self):\\n # label input\\n in_label = Input(shape=(1,))\\n # embedding for categorical input\\n li = Embedding(self.n_classes, 50)(in_label)\\n # scale up to image dimensions with linear activation\\n n_nodes = self.in_shape[0] * self.in_shape[1]\\n li = Dense(n_nodes)(li)\\n # reshape to additional channel\\n li = Reshape((self.in_shape[0], self.in_shape[1], 1))(li)\\n # image input\\n in_image = Input(shape=self.in_shape)\\n # concat label as a channel\\n merge = Concatenate()([in_image, li])\\n # downsample\\n fe = Conv2D(128, (3,3), strides=(2,2), padding='same')(merge)\\n fe = LeakyReLU(alpha=0.2)(fe)\\n # downsample\\n fe = Conv2D(128, (3,3), strides=(2,2), padding='same')(fe)\\n fe = LeakyReLU(alpha=0.2)(fe)\\n # flatten feature maps\\n fe = Flatten()(fe)\\n # dropout\\n fe = Dropout(0.4)(fe)\\n # output\\n out_layer = Dense(1, activation='sigmoid')(fe)\\n # define model\\n self.d_model = Model([in_image, in_label], out_layer)\\n # compile model\\n opt = Adam(lr=0.0002, beta_1=0.5)\\n self.d_model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])\",\n \"def __init__(self, num_channels, conv_dim, image_size, num_gpu,\\n num_extra_layers, use_BN):\\n super(Discriminator, self).__init__()\\n assert image_size % 16 == 0, \\\"image size must be a multiple of 16!\\\"\\n\\n self.num_gpu = num_gpu\\n self.layer = nn.Sequential()\\n # input conv layer\\n # input num_channels x image_size x image_size\\n # output conv_dim x (image_size / 2) x (image_size / 2)\\n self.layer.add_module(\\\"init.{}-{}.conv\\\".format(num_channels, conv_dim),\\n nn.Conv2d(num_channels, conv_dim, 4, 2, 1,\\n bias=False))\\n self.layer.add_module(\\\"init.{}.relu\\\".format(conv_dim),\\n nn.LeakyReLU(0.2, inplace=True))\\n\\n conv_size = image_size / 2\\n conv_depth = conv_dim\\n\\n # extra conv layers\\n for idx in range(num_extra_layers):\\n self.layer.add_module(\\n \\\"extra-{}.{}-{}.conv\\\".format(idx, conv_depth, conv_depth),\\n nn.Conv2d(conv_depth, conv_depth, 3, 1, 0, bias=False))\\n if use_BN:\\n self.layer.add_module(\\n \\\"extra-{}.{}.batchnorm\\\".format(idx, conv_depth),\\n nn.BatchNorm2d(conv_depth * 2))\\n self.layer.add_module(\\n \\\"extra-{}.{}.relu\\\".format(idx, conv_depth),\\n nn.LeakyReLU(0.2, inplace=True))\\n\\n # pyramid conv layer\\n while conv_size > 4:\\n # output (conv_depth * 2) * (conv_size / 2) * (conv_size / 2)\\n self.layer.add_module(\\n \\\"pyramid.{}-{}.conv\\\".format(conv_depth, conv_depth * 2),\\n nn.Conv2d(conv_depth, conv_depth * 2, 4, 2, 1, bias=False))\\n if use_BN:\\n self.layer.add_module(\\n \\\"pyramid.{}.batchnorm\\\".format(conv_depth * 2),\\n nn.BatchNorm2d(conv_depth * 2))\\n self.layer.add_module(\\n \\\"pyramid.{}.relu\\\".format(conv_depth * 2),\\n nn.LeakyReLU(0.2, inplace=True))\\n conv_depth *= 2\\n conv_size /= 2\\n\\n # output conv layer\\n # no more sigmoid function\\n # input [conv_depth x 4 x 4], output [1 x 1 x1]\\n # e.g. if image_size = 64, then input is [(conv_dim * 8) x 4 x 4]\\n self.layer.add_module(\\\"final.{}-{}.conv\\\".format(conv_depth, 1),\\n nn.Conv2d(conv_depth, 1, 4, 1, 0, bias=False))\",\n \"def build_gan(self):\\n # make weights in the discriminator not trainable\\n self.d_model.trainable = False\\n # get noise and label inputs from generator model\\n gen_noise, gen_label = self.g_model.input\\n # get image output from the generator model\\n gen_output = self.g_model.output\\n # connect image output and label input from generator as inputs to discriminator\\n gan_output = self.d_model([gen_output, gen_label])\\n # define gan model as taking noise and label and outputting a classification\\n self.gan_model = Model([gen_noise, gen_label], gan_output)\\n # compile model\\n opt = Adam(lr=0.0002, beta_1=0.5)\\n self.gan_model.compile(loss='binary_crossentropy', optimizer=opt)\",\n \"def get_unet0(nClasses, input_height, input_width, nchannel=3):\\n\\n inputs = Input(shape=(input_height, input_width, nchannel))\\n # temp = BatchNormalization()(inputs)\\n\\n conv1 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(inputs)\\n conv1 = BatchNormalization()(conv1)\\n conv1 = Activation(\\\"relu\\\")(conv1)\\n conv1 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(conv1)\\n conv1 = BatchNormalization()(conv1)\\n conv1 = Activation(\\\"relu\\\")(conv1)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n conv2 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(pool1)\\n conv2 = BatchNormalization()(conv2)\\n conv2 = Activation(\\\"relu\\\")(conv2)\\n conv2 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(conv2)\\n conv2 = BatchNormalization()(conv2)\\n conv2 = Activation(\\\"relu\\\")(conv2)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n conv3 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(pool2)\\n conv3 = BatchNormalization()(conv3)\\n conv3 = Activation(\\\"relu\\\")(conv3)\\n conv3 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(conv3)\\n conv3 = BatchNormalization()(conv3)\\n conv3 = Activation(\\\"relu\\\")(conv3)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n\\n conv4 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(pool3)\\n conv4 = BatchNormalization()(conv4)\\n conv4 = Activation(\\\"relu\\\")(conv4)\\n conv4 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(conv4)\\n conv4 = BatchNormalization()(conv4)\\n conv4 = Activation(\\\"relu\\\")(conv4)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n\\n conv5 = Conv2D(512, (3, 3), padding='same', kernel_initializer='he_uniform')(pool4)\\n conv5 = BatchNormalization()(conv5)\\n conv5 = Activation(\\\"relu\\\")(conv5)\\n conv5 = Conv2D(512, (3, 3), padding='same', kernel_initializer='he_uniform')(conv5)\\n conv5 = BatchNormalization()(conv5)\\n conv5 = Activation(\\\"relu\\\")(conv5)\\n\\n up6 = concatenate([UpSampling2D(size=(2, 2))(conv5), conv4], axis=3)\\n conv6 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(up6)\\n conv6 = BatchNormalization()(conv6)\\n conv6 = Activation(\\\"relu\\\")(conv6)\\n conv6 = Conv2D(256, (3, 3), padding='same', kernel_initializer='he_uniform')(conv6)\\n conv6 = BatchNormalization()(conv6)\\n conv6 = Activation(\\\"relu\\\")(conv6)\\n\\n up7 = concatenate([UpSampling2D(size=(2, 2))(conv6), conv3], axis=3)\\n conv7 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(up7)\\n conv7 = BatchNormalization()(conv7)\\n conv7 = Activation(\\\"relu\\\")(conv7)\\n conv7 = Conv2D(128, (3, 3), padding='same', kernel_initializer='he_uniform')(conv7)\\n conv7 = BatchNormalization()(conv7)\\n conv7 = Activation(\\\"relu\\\")(conv7)\\n\\n up8 = concatenate([UpSampling2D(size=(2, 2))(conv7), conv2], axis=3)\\n conv8 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(up8)\\n conv8 = BatchNormalization()(conv8)\\n conv8 = Activation(\\\"relu\\\")(conv8)\\n conv8 = Conv2D(64, (3, 3), padding='same', kernel_initializer='he_uniform')(conv8)\\n conv8 = BatchNormalization()(conv8)\\n conv8 = Activation(\\\"relu\\\")(conv8)\\n\\n up9 = concatenate([UpSampling2D(size=(2, 2))(conv8), conv1], axis=3)\\n conv9 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(up9)\\n conv9 = BatchNormalization()(conv9)\\n conv9 = Activation(\\\"relu\\\")(conv9)\\n conv9 = Conv2D(32, (3, 3), padding='same', kernel_initializer='he_uniform')(conv9)\\n conv9 = BatchNormalization()(conv9)\\n conv9 = Activation(\\\"relu\\\")(conv9)\\n\\n conv10 = Conv2D(nClasses, (1, 1), activation='relu', padding='same')(conv9)\\n conv10 = Reshape((input_height * input_width, nClasses))(conv10)\\n # conv10 = Permute((2, 1))(conv10)\\n\\n conv11 = Activation('softmax')(conv10)\\n\\n\\n model = Model(inputs=inputs, outputs=conv11)\\n\\n return model\",\n \"def discriminator_block(self, name):\\n\\n if self.fit_mask : \\n \\n inputs = Input(shape=(2+self.nb_classe_mask, self.image_row, self.image_column, self.image_depth), name='dis_input')\\n else :\\n # In:\\n inputs = Input(shape=(2, self.image_row, self.image_column, self.image_depth), name='dis_input')\\n\\n # Input 64\\n disnet = Conv3D(self.discriminator_kernel * 1, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_1')(inputs)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 1 : 32\\n disnet = Conv3D(self.discriminator_kernel * 2, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_2')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 2 : 16\\n disnet = Conv3D(self.discriminator_kernel * 4, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_3')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 3 : 8\\n disnet = Conv3D(self.discriminator_kernel * 8, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_4')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Hidden 4 : 4\\n disnet = Conv3D(self.discriminator_kernel * 16, 4, strides=2,\\n padding='same',\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name=name + '_conv_dis_5')(disnet)\\n disnet = LeakyReLU(0.01)(disnet)\\n\\n # Decision : 2\\n decision = Conv3D(1, 2, strides=1,\\n use_bias=False,\\n kernel_initializer='he_normal',\\n data_format='channels_first',\\n name='dis_decision')(disnet)\\n\\n decision = Reshape((1,))(decision)\\n\\n model = Model(inputs=[inputs], outputs=[decision], name=name)\\n return model\",\n \"def VGGWithCustomLayers(nb_classes, input_shape, fc_size):\\n # setup model\\n base_model = VGGFace(include_top=False, input_tensor=Input(shape=input_shape))\\n x = base_model.output\\n x = GlobalAveragePooling2D()(x)\\n x = Dense(fc_size, activation='relu')(x) # new FC layer, random init\\n x = Dense(fc_size * 2, activation='relu')(x) # new FC layer, random init\\n x = Dense(fc_size * 4, activation='relu')(x) # new FC layer, random init\\n predictions = Dense(nb_classes, activation='softmax')(x) # new softmax layer\\n model = Model(outputs=predictions, inputs=base_model.input)\\n return model, base_model\",\n \"def discriminator_model_lungs():\\n # Initialize the weights\\n init = tf.random_normal_initializer(0.0, 0.02)\\n\\n img_shape = (400, 400, 1)\\n\\n # Source and target image input\\n source_img = tf.keras.Input(shape=img_shape)\\n target_img = tf.keras.Input(shape=img_shape)\\n\\n # Concatenate images channel-wise\\n src_tgt_img = Concatenate()([source_img, target_img]) # L : 400 x 400 x 1 # G: 200 x 200 x 1\\n\\n # C128\\n d1 = Conv2D(filters=128, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n src_tgt_img) # L: 200 x 200 x 128 # G: 100 x 100 x 128 # RF: 4\\n d1 = LeakyReLU(alpha=0.2)(d1)\\n\\n # C256\\n d2 = Conv2D(filters=256, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n d1) # G: 100 x 100 x 256 # L: 50 x 50 x 256 # RF: 10\\n d2 = BatchNormalization()(d2)\\n d2 = LeakyReLU(alpha=0.2)(d2)\\n\\n # C512\\n d3 = Conv2D(filters=512, kernel_size=(4, 4), strides=(2, 2), padding='same', kernel_initializer=init)(\\n d2) # G: 50 x 50 x 512 # L: 25 x 25 x 512 # RF: 22\\n d3 = BatchNormalization()(d3)\\n d3 = LeakyReLU(alpha=0.2)(d3)\\n d3 = ZeroPadding2D()(d3) # G: 52 x 52 x 512 # L: 27 x 27 x 512\\n\\n # Patch output\\n d4 = Conv2D(filters=1, kernel_size=(3, 3), strides=(1, 1), padding='valid', kernel_initializer=init)(\\n d3) # G: 50 x 50 x 1 # L: 25 x 25 x 1 # RF: 38\\n output_patch = Activation('sigmoid')(d4)\\n\\n # Define model\\n discriminator_model = tf.keras.Model([source_img, target_img], output_patch)\\n return discriminator_model\",\n \"def get_gender(image_file=\\\"/data/datasets/CelebA-HQ/celeba-1024/000004.jpg\\\"):\\n cap = cv.VideoCapture(image_file)\\n padding = 20\\n while cv.waitKey(1) < 0:\\n # Read frame\\n t = time.time()\\n hasFrame, frame = cap.read()\\n if not hasFrame:\\n cv.waitKey()\\n break\\n\\n frameFace, bboxes = getFaceBox(faceNet, frame)\\n if not bboxes:\\n print(\\\"No face Detected, Checking next frame\\\")\\n continue\\n\\n for bbox in bboxes:\\n # print(bbox)\\n face = frame[max(0, bbox[1] - padding):min(bbox[3] + padding, frame.shape[0] - 1),\\n max(0, bbox[0] - padding):min(bbox[2] + padding, frame.shape[1] - 1)]\\n\\n blob = cv.dnn.blobFromImage(face, 1.0, (227, 227), MODEL_MEAN_VALUES, swapRB=False)\\n genderNet.setInput(blob)\\n genderPreds = genderNet.forward()\\n gender = genderList[genderPreds[0].argmax()]\\n confidence = genderPreds[0].max()\\n # print(\\\"Gender Output : {}\\\".format(genderPreds))\\n print(\\\"Gender : {}, conf = {:.3f}\\\".format(gender, confidence))\\n return gender, confidence\",\n \"def vanilla_unet(input_shape=(512, 512, 3), base_depth=32, drop_rate=0,\\n seed=1337):\\n input = Input(input_shape)\\n\\n conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(input)\\n bn1 = BatchNormalization()(conv1)\\n drop1 = Dropout(drop_rate, seed=seed)(bn1)\\n conv2 = Conv2D(base_depth, 3, activation='relu', padding='same')(drop1)\\n bn2 = BatchNormalization()(conv2)\\n mp1 = MaxPooling2D(pool_size=(2, 2))(bn2)\\n\\n conv3 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(mp1)\\n bn3 = BatchNormalization()(conv3)\\n drop2 = Dropout(drop_rate, seed=seed+1)(bn3)\\n conv4 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(drop2)\\n bn4 = BatchNormalization()(conv4)\\n mp2 = MaxPooling2D(pool_size=(2, 2))(bn4)\\n\\n conv5 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(mp2)\\n bn5 = BatchNormalization()(conv5)\\n drop3 = Dropout(drop_rate, seed=seed+2)(bn5)\\n conv6 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(drop3)\\n bn6 = BatchNormalization()(conv6)\\n mp3 = MaxPooling2D(pool_size=(2, 2))(bn6)\\n\\n conv7 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(mp3)\\n bn7 = BatchNormalization()(conv7)\\n drop4 = Dropout(drop_rate, seed=seed+3)(bn7)\\n conv8 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(drop4)\\n bn8 = BatchNormalization()(conv8)\\n mp4 = MaxPooling2D(pool_size=(2, 2))(bn8)\\n\\n conv9 = Conv2D(base_depth*16, 3, activation='relu', padding='same')(mp4)\\n bn9 = BatchNormalization()(conv9)\\n drop5 = Dropout(drop_rate, seed=seed+4)(bn9)\\n deconv0 = Conv2DTranspose(base_depth*16, 3, activation='relu',\\n padding='same')(drop5)\\n bn10 = BatchNormalization()(deconv0)\\n up1 = UpSampling2D(interpolation='bilinear')(bn10)\\n\\n deconv1 = Conv2DTranspose(base_depth*8, 3, activation='relu',\\n padding='same')(up1)\\n bn11 = BatchNormalization()(deconv1)\\n cat1 = concatenate([bn11, bn8])\\n drop6 = Dropout(drop_rate, seed=seed+5)(cat1)\\n deconv2 = Conv2DTranspose(base_depth*8, 3, activation='relu',\\n padding='same')(drop6)\\n bn12 = BatchNormalization()(deconv2)\\n up2 = UpSampling2D(interpolation='bilinear')(bn12)\\n\\n deconv3 = Conv2DTranspose(base_depth*4, 3, activation='relu',\\n padding='same')(up2)\\n bn13 = BatchNormalization()(deconv3)\\n cat2 = concatenate([bn13, bn6])\\n drop7 = Dropout(drop_rate, seed=seed+6)(cat2)\\n deconv4 = Conv2DTranspose(base_depth*4, 3, activation='relu',\\n padding='same')(drop7)\\n bn14 = BatchNormalization()(deconv4)\\n up3 = UpSampling2D(interpolation='bilinear')(bn14)\\n\\n deconv5 = Conv2DTranspose(base_depth*2, 3, activation='relu',\\n padding='same')(up3)\\n bn15 = BatchNormalization()(deconv5)\\n cat3 = concatenate([bn15, bn4])\\n drop8 = Dropout(drop_rate, seed=seed+7)(cat3)\\n deconv6 = Conv2DTranspose(base_depth*2, 3, activation='relu',\\n padding='same')(drop8)\\n bn16 = BatchNormalization()(deconv6)\\n up4 = UpSampling2D(interpolation='bilinear')(bn16)\\n\\n deconv7 = Conv2DTranspose(base_depth, 3, activation='relu',\\n padding='same')(up4)\\n bn17 = BatchNormalization()(deconv7)\\n cat4 = concatenate([bn17, bn2])\\n drop7 = Dropout(drop_rate, seed=seed+8)(cat4)\\n deconv8 = Conv2DTranspose(base_depth, 3, activation='relu',\\n padding='same')(drop7)\\n bn18 = BatchNormalization()(deconv8)\\n\\n out = Conv2DTranspose(1, 1, activation='sigmoid', padding='same')(bn18)\\n\\n return Model(input, out)\",\n \"def build_vgg(self):\\n # Get the vgg network. Extract features from Block 5, last convolution.\\n vgg = tf.keras.applications.VGG19(weights=\\\"imagenet\\\", input_shape=self.hr_shape, include_top=False)\\n vgg.trainable = False\\n for layer in vgg.layers:\\n layer.trainable = False\\n\\n # Create model and compile\\n model = tf.keras.models.Model(inputs=vgg.input, outputs=vgg.get_layer(\\\"block5_conv4\\\").output)\\n\\n return model\",\n \"def identity_block(self, input_tensor, kernel_size, filters, stage, block):\\r\\n\\t\\tfilters1, filters2, filters3 = filters # this indicates the number of filter (here, assume that all filter number are same)\\r\\n\\r\\n\\t\\tbn_axis = self.channel_last # number of classes being classified\\r\\n \\r\\n\\t\\t# names for the layers\\r\\n\\t\\tconv_name_base = 'res' + str(stage) + block + '_branch'\\r\\n\\t\\tbn_name_base = 'bn' + str(stage) + block + '_branch'\\r\\n\\r\\n\\t\\t# model definition\\r\\n\\t\\tx = Conv2D(filters1, (1, 1),\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2a')(input_tensor)\\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n\\r\\n\\t\\tx = Conv2D(filters2, kernel_size,\\r\\n\\t\\t\\t\\t\\t\\t padding='same',\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2b')(x)\\r\\n \\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n\\r\\n\\t\\tx = Conv2D(filters3, (1, 1),\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2c')(x)\\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)\\r\\n\\r\\n\\t\\t# Here, we add the outcome tensor(layer) x to original input tensor\\r\\n\\t\\tx = add([x, input_tensor])\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n \\r\\n\\t\\treturn x\",\n \"def bisenet_face_parsing():\\r\\n network = BiSeNet_keras()\\r\\n network.load_weights(MODEL_PATH)\\r\\n return network\",\n \"def build_patch_discriminator(self, model_shape, filters=32, k_size=4, drop=False, rate=0.5, summary=False, model_file=None, name='gan_d_'):\\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 Create a Discriminator Model using hyperparameters values defined as follows\\n \\\"\\\"\\\"\\n init = RandomNormal(stddev=0.02)\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n\\n input_shape = (n_rows, n_cols, c_dims)\\n input_layer = Input(shape=input_shape, name=name+'input')\\n\\n d = self.Conv2D_Block(input_layer, filters, k_size=k_size, name=name+'1', bn=False)\\n d = self.Conv2D_Block(d, 2*filters, k_size=k_size, name=name+'2')\\n d = self.Conv2D_Block(d, 4*filters, k_size=k_size, name=name+'3')\\n d = self.Conv2D_Block(d, 8*filters, strides=1, k_size=k_size, name=name+'4')\\n d = self.Conv2D_Block(d, 8*filters, strides=1, k_size=k_size, name=name+'5')\\n\\n if drop:\\n d = Dropout(rate=0.5, name=name+'_dropout')(d, training=True)\\n logits = Conv2D(1, k_size, strides=1, padding='same', kernel_initializer=init, name=name+'logits')(d)\\n out = Activation('sigmoid', name=name+'sigmoid')(logits)\\n\\n model = Model(inputs=[input_layer], outputs=[out, logits], name='Discriminator_'+name[-3:])\\n if (summary):\\n model.summary()\\n return model\",\n \"def darknet_body():\\n return compose(DarknetConv2D_BN_Leaky(32, (3, 3)), MaxPooling2D(), DarknetConv2D_BN_Leaky(64, (3, 3)),\\n MaxPooling2D(), bottleneck_block(128, 64), MaxPooling2D(), bottleneck_block(256, 128),\\n MaxPooling2D(), bottleneck_x2_block(512, 256), MaxPooling2D(), bottleneck_x2_block(1024, 512))\",\n \"def build_vgg(self, weights=\\\"imagenet\\\"): \\n \\n # Input image to extract features from\\n img = Input(shape=(self.img_rows, self.img_cols, 3))\\n\\n # Mean center and rescale by variance as in PyTorch\\n processed = Lambda(lambda x: (x-self.mean) / self.std)(img)\\n \\n # If inference only, just return empty model \\n if self.inference_only:\\n model = Model(inputs=img, outputs=[img for _ in range(len(self.vgg_layers))])\\n model.trainable = False\\n model.compile(loss='mse', optimizer='adam')\\n return model\\n \\n # Get the vgg network from Keras applications\\n if weights in ['imagenet', None]:\\n vgg = VGG16(weights=weights, include_top=False)\\n else:\\n vgg = VGG16(weights=None, include_top=False)\\n vgg.load_weights(weights, by_name=True)\\n\\n # Output the first three pooling layers\\n vgg.outputs = [vgg.layers[i].output for i in self.vgg_layers] \\n \\n # Create model and compile\\n model = Model(inputs=img, outputs=vgg(processed))\\n model.trainable = False\\n model.compile(loss='mse', optimizer='adam')\\n\\n return model\",\n \"def build_discriminator(self):\\n\\n def d_block(layer_input, filters, strides=1, bn=True):\\n\\n d = tf.keras.layers.Conv2D(filters, kernel_size=3, strides=strides, padding='same')(layer_input)\\n if bn:\\n d = tf.keras.layers.BatchNormalization(momentum=0.8)(d)\\n d = tf.keras.layers.LeakyReLU(alpha=0.2)(d)\\n \\n return d\\n\\n # Input img\\n d0 = tf.keras.layers.Input(shape=self.hr_shape)\\n\\n d1 = d_block(d0, self.df, bn=False)\\n d2 = d_block(d1, self.df, strides=2)\\n d3 = d_block(d2, self.df)\\n d4 = d_block(d3, self.df, strides=2)\\n d5 = d_block(d4, self.df * 2)\\n d6 = d_block(d5, self.df * 2, strides=2)\\n d7 = d_block(d6, self.df * 2)\\n d8 = d_block(d7, self.df * 2, strides=2)\\n\\n validity = tf.keras.layers.Conv2D(1, kernel_size=1, strides=1, activation='sigmoid', padding='same')(d8)\\n\\n return tf.keras.models.Model(d0, validity)\",\n \"def __init__(self):\\n super(Discriminator, self).__init__()\\n\\n self.conv = nn.Sequential(\\n # conv1\\n nn.Conv2d(in_channels=3, out_channels=196, kernel_size=3, padding=1, stride=1),\\n nn.LayerNorm(normalized_shape=[32, 32]),\\n nn.LeakyReLU(),\\n\\n # conv2\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=2),\\n nn.LayerNorm(normalized_shape=[16, 16]),\\n nn.LeakyReLU(),\\n\\n # conv3\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=1),\\n nn.LayerNorm(normalized_shape=[16, 16]),\\n nn.LeakyReLU(),\\n\\n # conv4\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=2),\\n nn.LayerNorm(normalized_shape=[8, 8]),\\n nn.LeakyReLU(),\\n\\n # conv5\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=1),\\n nn.LayerNorm(normalized_shape=[8, 8]),\\n nn.LeakyReLU(),\\n\\n # conv6\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=1),\\n nn.LayerNorm(normalized_shape=[8, 8]),\\n nn.LeakyReLU(),\\n\\n # conv7\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=1),\\n nn.LayerNorm(normalized_shape=[8, 8]),\\n nn.LeakyReLU(),\\n\\n # conv8\\n nn.Conv2d(in_channels=196, out_channels=196, kernel_size=3, padding=1, stride=2),\\n nn.LayerNorm(normalized_shape=[4, 4]),\\n nn.LeakyReLU(),\\n\\n nn.MaxPool2d(kernel_size=4, stride=4, padding=0)\\n )\\n\\n self.fc1 = nn.Linear(196, 1)\\n self.fc10 = nn.Linear(196, 10)\",\n \"def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\\r\\n\\r\\n super().__init__()\\r\\n\\r\\n self.input_size = input_dim\\r\\n self.input_dim =input_dim\\r\\n\\r\\n if type(hidden_dim) != list:\\r\\n self.hidden_sizes = [hidden_dim]*num_layers\\r\\n else:\\r\\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\\r\\n self.hidden_sizes = hidden_dim\\r\\n if type(kernel_sizes) != list:\\r\\n self.kernel_sizes = [kernel_sizes]*num_layers\\r\\n else:\\r\\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\\r\\n self.kernel_sizes = kernel_sizes\\r\\n\\r\\n self.n_layers = num_layers\\r\\n\\r\\n cells = nn.ModuleList()\\r\\n squenceCells=nn.ModuleList()\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n if i == 0:\\r\\n input_dim = self.input_size\\r\\n else:\\r\\n input_dim = self.hidden_sizes[i-1]\\r\\n\\r\\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\\r\\n\\r\\n cells.append(cell)\\r\\n\\r\\n self.cells = cells\\r\\n\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n squenceCell = SequenceGRU(gb_hidden_size[i])\\r\\n\\r\\n squenceCells.append(squenceCell)\\r\\n\\r\\n self.squenceCells = squenceCells\",\n \"def build_encoder2D(self, model_shape, filters=32, k_size=4, z_size=500, drop=True, rate=0.5, bn=True, summary=False, model_file=None, name='gan_e_'):\\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 Create a Discriminator Model using hyperparameters values defined as follows\\n \\\"\\\"\\\"\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n\\n input_shape = (n_rows, n_cols, c_dims)\\n input_layer = Input(shape=input_shape, name=name+'input')\\n\\n x = self.Conv2D_Block(input_layer, filters, k_size=k_size, name=name+'1', bn=False)\\n x = self.Conv2D_Block(x, 2*filters, k_size=k_size, name=name+'2')\\n x = self.Conv2D_Block(x, 4*filters, k_size=k_size, name=name+'3')\\n x = self.Conv2D_Block(x, 8*filters, strides=1, k_size=k_size, name=name+'4')\\n\\n x = Flatten(name=name+'flatten')(x)\\n if drop:\\n x = Dropout(rate=rate, name=name+'dropout')(x)\\n x = Dense(z_size, activation='linear', kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(x)\\n if bn:\\n x = BatchNormalization(center=False, scale=False, name=name+\\\"bn_out\\\")(x)\\n\\n model = Model(inputs=[input_layer], outputs=[x], name='Encoder')\\n if (summary):\\n model.summary()\\n return model\",\n \"def build_age_branch(self, inputs):\\n x = self.make_default_hidden_layers(inputs)\\n\\n x = Flatten()(x)\\n x = Dense(128)(x)\\n x = Activation(\\\"relu\\\")(x)\\n x = BatchNormalization()(x)\\n x = Dropout(0.5)(x)\\n x = Dense(1)(x)\\n x = Activation(\\\"linear\\\", name=\\\"age_output\\\")(x)\\n\\n return x\",\n \"def __init__(self, kernel_size, filters, stage, block):\\n super().__init__(name='identity' + str(stage) + block)\\n filters1, filters2, filters3 = filters\\n if K.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n self.conv1 = layers.Conv2D(\\n filters1, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2a')\\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\\n self.act1 = layers.Activation('relu')\\n\\n self.conv2 = layers.Conv2D(\\n filters2,\\n kernel_size,\\n padding='same',\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2b')\\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\\n self.act2 = layers.Activation('relu')\\n\\n self.conv3 = layers.Conv2D(\\n filters3, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2c')\\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\\n\\n self.add = layers.Add()\\n self.act = layers.Activation('relu')\",\n \"def build_dcgan_discriminator(input_op, is_training=True, scope='UDiscriminator', reuse=False,\\n block_num=4, min_filters=64, kernel_size=3, activation=tf.nn.leaky_relu):\\n with tf.variable_scope(scope, reuse=reuse):\\n net = input_op\\n end_points = dict()\\n for idx in range(block_num):\\n net = tf.layers.conv2d(net, min_filters * (idx + 1), kernel_size=kernel_size, padding='same',\\n name='conv_' + str(2 * idx), use_bias=False, activation=None,\\n kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d())\\n net = activation(batch_norm(net, is_training=is_training, name='bn_' + str(2 * idx)))\\n net = tf.layers.conv2d(net, min_filters * (idx + 1), kernel_size=kernel_size, strides=2, padding='same',\\n name='conv_' + str(2 * idx + 1), activation=None, use_bias=False,\\n kernel_initializer=tf.contrib.layers.xavier_initializer_conv2d())\\n net = activation(batch_norm(net, is_training=is_training, name='bn_' + str(2 * idx + 1)))\\n # end_points should be returned to calculate the\\n end_points['pool_' + str(idx)] = net\\n\\n batch_size = net.get_shape().as_list()[0]\\n net = tf.reshape(net, [batch_size, -1])\\n logits = tf.layers.dense(net, 1, use_bias=True, kernel_initializer=tf.contrib.layers.xavier_initializer())\\n return logits, end_points\",\n \"def img_gender_gen(gen_img, gen_gender): \\n \\n while True:\\n X1i = gen_img.next()\\n X2i = gen_gender.next()\\n yield [X1i[0], X2i[1]], X1i[1]\",\n \"def build_unet(input_layer = Input((128,128,3)), start_depth=64, activation='relu', initializer='he_normal'):\\n\\n # 128 -> 64\\n conv1 = Conv2D_BN(input_layer, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv1 = Conv2D_BN(conv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool1 = MaxPooling2D((2, 2))(conv1)\\n\\n # 64 -> 32\\n conv2 = Conv2D_BN(pool1, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv2 = Conv2D_BN(conv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool2 = MaxPooling2D((2, 2))(conv2)\\n\\n # 32 -> 16\\n conv3 = Conv2D_BN(pool2, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv3 = Conv2D_BN(conv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool3 = MaxPooling2D((2, 2))(conv3)\\n\\n # 16 -> 8\\n conv4 = Conv2D_BN(pool3, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv4 = Conv2D_BN(conv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool4 = MaxPooling2D((2, 2))(conv4)\\n\\n # Middle\\n convm=cbam_block(pool4)\\n\\n # 8 -> 16\\n deconv4 = Conv2DTranspose(convm, start_depth * 8, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv4 = concatenate([deconv4, conv4])\\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 16 -> 32\\n deconv3 = Conv2DTranspose(uconv4, start_depth * 4, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv3 = concatenate([deconv3, conv3])\\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 32 -> 64\\n deconv2 = Conv2DTranspose(uconv3, start_depth * 2, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv2 = concatenate([deconv2, conv2])\\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 64 -> 128\\n deconv1 = Conv2DTranspose(uconv2, start_depth * 1, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv1 = concatenate([deconv1, conv1])\\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n output_layer = Conv2D(1, (1,1), padding=\\\"same\\\", activation=\\\"sigmoid\\\")(uconv1)\\n\\n return output_layer\",\n \"def unet_network(input_tensor, nb_classes):\\n # contraction 1\\n conv1 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv1')(\\n input_tensor) # (batch_size, ?, ?, 64)\\n conv2 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv2')(\\n conv1) # (batch_size, ?, ?, 64)\\n crop2 = Cropping2D(\\n cropping=((88, 88), (88, 88)),\\n name=\\\"crop2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n maxpool2 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n\\n # contraction 2\\n conv3 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv3')(\\n maxpool2) # (batch_size, ?, ?, 128)\\n conv4 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv4')(\\n conv3) # (batch_size, ?, ?, 128)\\n crop4 = Cropping2D(\\n cropping=((40, 40), (40, 40)),\\n name=\\\"crop4\\\")(\\n conv4) # (batch_size, ?, ?, 128)\\n maxpool4 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool4\\\")(\\n conv4) # ((batch_size, ?, ?, 128)\\n\\n # contraction 3\\n conv5 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv5')(\\n maxpool4) # (batch_size, ?, ?, 256)\\n conv6 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv6')(\\n conv5) # (batch_size, ?, ?, 256)\\n crop6 = Cropping2D(\\n cropping=((16, 16), (16, 16)),\\n name=\\\"crop6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n maxpool6 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n\\n # contraction 4\\n conv7 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv7')(\\n maxpool6) # (batch_size, ?, ?, 512)\\n conv8 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv8')(\\n conv7) # (batch_size, ?, ?, 512)\\n crop8 = Cropping2D(\\n cropping=((4, 4), (4, 4)),\\n name=\\\"crop8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n maxpool8 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n\\n # bottom\\n conv9 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv9')(\\n maxpool8) # (batch_size, ?, ?, 1024)\\n conv10 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv10')(\\n conv9) # (batch_size, ?, ?, 1024)\\n\\n # expansion 1\\n upconv11 = up_conv_2d(\\n input_tensor=conv10,\\n nb_filters=512,\\n name='upconv11') # (batch_size, ?, ?, 512)\\n concat11 = tf.concat(\\n values=[crop8, upconv11],\\n axis=-1,\\n name='concat11') # (batch_size, ?, ?, 1024)\\n conv12 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv12')(\\n concat11) # (batch_size, ?, ?, 512)\\n conv13 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv13')(\\n conv12) # (batch_size, ?, ?, 512)\\n\\n # expansion 2\\n upconv14 = up_conv_2d(\\n input_tensor=conv13,\\n nb_filters=256,\\n name='upconv14') # (batch_size, ?, ?, 256)\\n concat14 = tf.concat(\\n values=[crop6, upconv14],\\n axis=-1,\\n name='concat14') # (batch_size, ?, ?, 512)\\n conv15 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv15')(\\n concat14) # (batch_size, ?, ?, 256)\\n conv16 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv16')(\\n conv15) # (batch_size, ?, ?, 256)\\n\\n # expansion 3\\n upconv17 = up_conv_2d(\\n input_tensor=conv16,\\n nb_filters=128,\\n name='upconv17') # (batch_size, ?, ?, 128)\\n concat17 = tf.concat(\\n values=[crop4, upconv17],\\n axis=-1,\\n name='concat17') # (batch_size, ?, ?, 256)\\n conv18 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv18')(\\n concat17) # (batch_size, ?, ?, 128)\\n conv19 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv19')(\\n conv18) # (batch_size, ?, ?, 128)\\n\\n # expansion 4\\n upconv20 = up_conv_2d(\\n input_tensor=conv19,\\n nb_filters=64,\\n name='upconv20') # (batch_size, ?, ?, 64)\\n concat20 = tf.concat(\\n values=[crop2, upconv20],\\n axis=-1,\\n name='concat20') # (batch_size, ?, ?, 128)\\n conv21 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv21')(\\n concat20) # (batch_size, ?, ?, 64)\\n conv22 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv22')(\\n conv21) # (batch_size, ?, ?, 64)\\n conv23 = Conv2D(\\n filters=nb_classes,\\n kernel_size=(1, 1),\\n activation='sigmoid',\\n name='conv23')(\\n conv22) # (batch_size, ?, ?, nb_classes)\\n\\n return conv23\",\n \"def build_model(self):\\n \\n # initalizing generators\\n self.g12 = G12(conv_dim=self.numGenFilter, domainA_channels = self.domainA_channels, domainB_channels = self.domainB_channels)\\n self.g21 = G21(conv_dim=self.numGenFilter, domainA_channels = self.domainA_channels, domainB_channels = self.domainB_channels)\\n \\n # initializing discriminators\\n self.d1 = D1(conv_dim=self.numDiscFilter, domainA_channels = self.domainA_channels, use_labels=self.use_labels)\\n self.d2 = D2(conv_dim=self.numDiscFilter, domainB_channels = self.domainB_channels, use_labels=self.use_labels)\\n \\n\\n g_params = list(self.g12.parameters()) + list(self.g21.parameters())\\n d_params = list(self.d1.parameters()) + list(self.d2.parameters())\\n \\n self.g_optimizer = optim.Adam(g_params, self.lr, [self.beta1, self.beta2])\\n self.d_optimizer = optim.Adam(d_params, self.lr, [self.beta1, self.beta2])\\n \\n if torch.cuda.is_available():\\n self.g12.cuda()\\n self.g21.cuda()\\n self.d1.cuda()\\n self.d2.cuda()\",\n \"def __init__(self, num_channels, conv_dim, num_gpu):\\n super(Discriminator, self).__init__()\\n self.num_gpu = num_gpu\\n self.layer = nn.Sequential(\\n # 1st conv layer\\n # input num_channels x 64 x 64, output conv_dim x 32 x 32\\n nn.Conv2d(num_channels, conv_dim, 4, 2, 1, bias=False),\\n nn.LeakyReLU(0.2, inplace=True),\\n # 2nd conv layer, output (conv_dim*2) x 16 x 16\\n nn.Conv2d(conv_dim, conv_dim * 2, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(conv_dim * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n # 3rd conv layer, output (conv_dim*4) x 8 x 8\\n nn.Conv2d(conv_dim * 2, conv_dim * 4, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(conv_dim * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n # 4th conv layer, output (conv_dim*8) x 4 x 4\\n nn.Conv2d(conv_dim * 4, conv_dim * 8, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(conv_dim * 8),\\n nn.LeakyReLU(0.2, inplace=True),\\n # output layer\\n nn.Conv2d(conv_dim * 8, 1, 4, 1, 0, bias=False),\\n nn.Sigmoid()\\n )\",\n \"def discriminator(self, inputs,\\n\\t\\t\\tnum_classes=1000,\\n\\t\\t\\tis_training=False,\\n\\t\\t\\tdropout_keep_prob=0.5,\\n\\t\\t\\tspatial_squeeze=True,\\n\\t\\t\\tscope='vgg_16',\\n\\t\\t\\tfc_conv_padding='VALID',\\n\\t\\t\\tglobal_pool=False):\\n\\n\\t\\twith tf.variable_scope(scope, 'vgg_16', [inputs], reuse=tf.AUTO_REUSE) as sc:\\n\\t\\t\\tend_points_collection = sc.original_name_scope + '_end_points'\\n\\t\\t\\t# Collect outputs for conv2d, fully_connected and max_pool2d.\\n\\t\\t\\twith slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],\\n\\t\\t\\t\\t\\t\\t\\t\\toutputs_collections=end_points_collection):\\n\\t\\t\\t\\tnet = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')\\n\\t\\t\\t\\tnet = slim.max_pool2d(net, [2, 2], scope='pool1')\\n\\t\\t\\t\\tnet = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')\\n\\t\\t\\t\\tnet = slim.max_pool2d(net, [2, 2], scope='pool2')\\n\\t\\t\\t\\tnet = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')\\n\\t\\t\\t\\tnet = slim.max_pool2d(net, [2, 2], scope='pool3')\\n\\t\\t\\t\\tnet = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')\\n\\t\\t\\t\\tnet = slim.max_pool2d(net, [2, 2], scope='pool4')\\n\\t\\t\\t\\tnet = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')\\n\\t\\t\\t\\tnet = slim.max_pool2d(net, [2, 2], scope='pool5')\\n\\n\\t\\t\\t\\t# Use conv2d instead of fully_connected layers.\\n\\t\\t\\t\\tnet = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')\\n\\t\\t\\t\\tnet = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tscope='dropout6')\\n\\t\\t\\t\\tnet = slim.conv2d(net, 4096, [1, 1], scope='fc7')\\n\\t\\t\\t\\t# Convert end_points_collection into a end_point dict.\\n\\t\\t\\t\\tend_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n\\t\\t\\t\\tif global_pool:\\n\\t\\t\\t\\t\\tnet = tf.reduce_mean(net, [1, 2], keep_dims=True, name='global_pool')\\n\\t\\t\\t\\t\\tend_points['global_pool'] = net\\n\\t\\t\\t\\tif num_classes:\\n\\t\\t\\t\\t\\tnet = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tscope='dropout7')\\n\\t\\t\\t\\t\\tnet = slim.conv2d(net, num_classes, [1, 1],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tactivation_fn=None,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormalizer_fn=None,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tscope='fc8')\\n\\t\\t\\t\\t\\tif spatial_squeeze:\\n\\t\\t\\t\\t\\t\\tnet = tf.squeeze(net, [1, 2], name='fc8/squeezed')\\n\\t\\t\\t\\t\\tend_points[sc.name + '/fc8'] = net\\n\\n\\t\\t\\t\\tprint('Net: ',net.get_shape())\\n\\t\\t#\\t\\tprint('End_point: ',end_points.get_shape())\\n\\t\\t\\t\\treturn net, end_points\",\n \"def VGG(model_type='D', dropout=0.5, num_classes=1000, input_shape=(224, 224, 3)):\\n \\n model_type = model_type.upper()\\n assert model_type in ['A', 'B', 'C', 'D', 'E'], \\\"Invalid value of 'model_type'\\\\n\\\" \\\\\\n \\\"It should be one of {'A', 'B', 'C', 'D', 'E'}\\\"\\n \\n assert (type(input_shape) == tuple), \\\"Invalid value of 'input_shape'\\\\n\\\" \\\\\\n \\\"It should be of form (<image_height>, <image_width>, <channels>)\\\"\\n \\n assert (len(input_shape) == 3), \\\"Invalid value of 'input_shape'\\\\n\\\" \\\\\\n \\\"It should be of form (<image_height>, <image_width>, <channels>)\\\"\\n \\n if(dropout != None):\\n assert ((type(dropout) == float) and (0 <= dropout <= 1)), \\\"Invalid value of 'dropout'.\\\\n\\\" \\\\\\n \\\"It should be a real number between 0 and 1 (inclusive).\\\"\\n\\n # Implementing the model\\n model = Sequential()\\n\\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu', input_shape=input_shape))\\n if model_type in ['B', 'C', 'D', 'E']:\\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['B', 'C', 'D', 'E']:\\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=256, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Flatten())\\n model.add(Dense(units=4096, activation='relu'))\\n if(dropout != None):\\n model.add(Dropout(dropout))\\n model.add(Dense(units=4096, activation='relu'))\\n if(dropout != None):\\n model.add(Dropout(dropout))\\n model.add(Dense(units=num_classes, activation='softmax'))\\n\\n return model\",\n \"def __conv_block(self, x, stage, branch, nb_filter, dropout_rate=None, weight_decay=1e-4):\\n\\t\\teps = 1.1e-5\\n\\t\\tconv_name_base = \\\"conv\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\t\\trelu_name_base = \\\"relu\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\n\\t\\t# 1x1 Convolution (Bottleneck layer)\\n\\t\\tinter_channel = nb_filter * 4 \\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x1_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x1_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x1\\\")(x)\\n\\t\\tx = Conv2D(inter_channel, (1, 1), name=conv_name_base+\\\"_x1\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\t# 3x3 Convolution\\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x2_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x2_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x2\\\")(x)\\n\\t\\tx = ZeroPadding2D((1, 1), name=conv_name_base+\\\"_x2_zeropadding\\\")(x)\\n\\t\\tx = Conv2D(nb_filter, (3, 3), name=conv_name_base+\\\"_x2\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\treturn x\",\n \"def build_network(self):\\n\\n input_placeholder = Input(shape = self.input_shape)\\n\\n # Stage 1\\n x = self.main_path_block(\\n input_placeholder,\\n 64, (7, 7), 'same',\\n 'conv1', 'bn_conv1',\\n activation = 'relu',\\n strides = (2, 2)\\n )\\n x = MaxPooling2D((3, 3), strides = (2, 2), padding = 'same')(x)\\n\\n # Stage 2\\n x = self.identity_block(x, 64, 'relu', 2, 'a', False)\\n x = self.identity_block(x, 64, 'relu', 2, 'b')\\n\\n # Stage 3\\n x = self.convolutional_block(x, [128, 128, 128], 'relu', 3, 'a')\\n x = self.identity_block(x, 128, 'relu', 3, 'b')\\n\\n # Stage 4\\n x = self.convolutional_block(x, [256, 256, 256], 'relu', 4, 'a')\\n x = self.identity_block(x, 256, 'relu', 4, 'b')\\n\\n # Stage 5\\n x = self.convolutional_block(x, [512, 512, 512], 'relu', 5, 'a')\\n x = self.identity_block(x, 512, 'relu', 4, 'b')\\n\\n # Fully Connected Layers\\n x = BatchNormalization(axis = 3)(x)\\n x = Activation('relu')(x)\\n x = AveragePooling2D((2, 1), padding = 'valid', strides = (2, 2))(x)\\n x = Flatten()(x)\\n x = Dense(512)\\n x = Dense(\\n self.classes, activation = 'softmax',\\n name = 'fc_' + str(self.classes),\\n kernel_initializer = glorot_uniform(seed = 0)\\n )(x)\\n\\n self.model = Model(input_placeholder, x, name = 'Resnet18')\",\n \"def vgg_16(input_shape=(224, 224, 3), output_shape=1000):\\n model = Sequential()\\n \\n # layer 1 ~ 2 (filter: 64)\\n model.add(Input(shape=input_shape))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(64, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(64, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 112 x 112 x 64\\n \\n # layer 3 ~ 4 (filter: 128)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(128, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(128, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 56 x 56 x 128\\n \\n # layer 5 ~ 7 (filter: 256)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 28 x 28 x 256\\n \\n # layer 8 ~ 10 (filter: 512)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 14 x 14 x 512\\n \\n # layer 11 ~ 13 (filter: 512)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 7 x 7 x 512\\n \\n # layer 14 ~ 16 (Fully Connected)\\n model.add(Flatten())\\n # flatten: 7 x 7 x 512 = 25,088\\n model.add(Dense(4096, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(4096, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(output_shape, activation='softmax'))\\n # categorized by output shape\\n \\n return model\",\n \"def train(**kwargs):\\n\\n # Roll out the parameters\\n batch_size = kwargs[\\\"batch_size\\\"]\\n n_batch_per_epoch = kwargs[\\\"n_batch_per_epoch\\\"]\\n nb_epoch = kwargs[\\\"nb_epoch\\\"]\\n model_name = kwargs[\\\"model_name\\\"]\\n generator = kwargs[\\\"generator\\\"]\\n image_dim_ordering = kwargs[\\\"image_dim_ordering\\\"]\\n img_dim = kwargs[\\\"img_dim\\\"]\\n patch_size = kwargs[\\\"patch_size\\\"]\\n bn_mode = kwargs[\\\"bn_mode\\\"]\\n label_smoothing = kwargs[\\\"use_label_smoothing\\\"]\\n label_flipping = kwargs[\\\"label_flipping\\\"]\\n dset = kwargs[\\\"dset\\\"]\\n use_mbd = kwargs[\\\"use_mbd\\\"]\\n\\n epoch_size = n_batch_per_epoch * batch_size\\n\\n # Setup environment (logging directory etc)\\n general_utils.setup_logging(model_name)\\n\\n # Load and rescale data\\n X_full_train, X_sketch_train, X_full_val, X_sketch_val = data_utils.load_data(dset, image_dim_ordering)\\n img_dim = X_full_train.shape[-3:]\\n\\n # Get the number of non overlapping patch and the size of input image to the discriminator\\n nb_patch, img_dim_disc = data_utils.get_nb_patch(img_dim, patch_size, image_dim_ordering)\\n\\n try:\\n\\n # Create optimizers\\n opt_dcgan = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n # opt_discriminator = SGD(lr=1E-3, momentum=0.9, nesterov=True)\\n opt_discriminator = Adam(lr=1E-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08)\\n\\n # Load generator model\\n generator_model = models.load(\\\"generator_unet_%s\\\" % generator,\\n img_dim,\\n nb_patch,\\n bn_mode,\\n use_mbd,\\n batch_size)\\n # Load discriminator model\\n discriminator_model = models.load(\\\"DCGAN_discriminator\\\",\\n img_dim_disc,\\n nb_patch,\\n bn_mode,\\n use_mbd,\\n batch_size)\\n\\n generator_model.compile(loss='mae', optimizer=opt_discriminator)\\n discriminator_model.trainable = False\\n\\n DCGAN_model = models.DCGAN(generator_model,\\n discriminator_model,\\n img_dim,\\n patch_size,\\n image_dim_ordering)\\n\\n loss = ['mae', 'binary_crossentropy']\\n loss_weights = [1E2, 1]\\n DCGAN_model.compile(loss=loss, loss_weights=loss_weights, optimizer=opt_dcgan)\\n\\n discriminator_model.trainable = True\\n discriminator_model.compile(loss='binary_crossentropy', optimizer=opt_discriminator)\\n\\n gen_loss = 100\\n disc_loss = 100\\n\\n # Start training\\n print(\\\"Start training\\\")\\n for e in range(nb_epoch):\\n # Initialize progbar and batch counter\\n progbar = generic_utils.Progbar(epoch_size)\\n batch_counter = 1\\n start = time.time()\\n\\n for X_full_batch, X_sketch_batch in data_utils.gen_batch(X_full_train, X_sketch_train, batch_size):\\n\\n # Create a batch to feed the discriminator model\\n X_disc, y_disc = data_utils.get_disc_batch(X_full_batch,\\n X_sketch_batch,\\n generator_model,\\n batch_counter,\\n patch_size,\\n image_dim_ordering,\\n label_smoothing=label_smoothing,\\n label_flipping=label_flipping)\\n\\n # Update the discriminator\\n disc_loss = discriminator_model.train_on_batch(X_disc, y_disc)\\n\\n # Create a batch to feed the generator model\\n X_gen_target, X_gen = next(data_utils.gen_batch(X_full_train, X_sketch_train, batch_size))\\n y_gen = np.zeros((X_gen.shape[0], 2), dtype=np.uint8)\\n y_gen[:, 1] = 1\\n\\n # Freeze the discriminator\\n discriminator_model.trainable = False\\n gen_loss = DCGAN_model.train_on_batch(X_gen, [X_gen_target, y_gen])\\n # Unfreeze the discriminator\\n discriminator_model.trainable = True\\n\\n batch_counter += 1\\n progbar.add(batch_size, values=[(\\\"D logloss\\\", disc_loss),\\n (\\\"G tot\\\", gen_loss[0]),\\n (\\\"G mae\\\", gen_loss[1]),\\n (\\\"G logloss\\\", gen_loss[2])])\\n\\n # Save images for visualization\\n if batch_counter % (n_batch_per_epoch / 2) == 0:\\n # Get new images from validation\\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\\n batch_size, image_dim_ordering, \\\"training\\\")\\n X_full_batch, X_sketch_batch = next(data_utils.gen_batch(X_full_val, X_sketch_val, batch_size))\\n data_utils.plot_generated_batch(X_full_batch, X_sketch_batch, generator_model,\\n batch_size, image_dim_ordering, \\\"validation\\\")\\n\\n if batch_counter >= n_batch_per_epoch:\\n break\\n\\n print(\\\"\\\")\\n print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start))\\n\\n if e % 5 == 0:\\n gen_weights_path = os.path.join('../../models/%s/gen_weights_epoch%s.h5' % (model_name, e))\\n generator_model.save_weights(gen_weights_path, overwrite=True)\\n\\n disc_weights_path = os.path.join('../../models/%s/disc_weights_epoch%s.h5' % (model_name, e))\\n discriminator_model.save_weights(disc_weights_path, overwrite=True)\\n\\n DCGAN_weights_path = os.path.join('../../models/%s/DCGAN_weights_epoch%s.h5' % (model_name, e))\\n DCGAN_model.save_weights(DCGAN_weights_path, overwrite=True)\\n\\n except KeyboardInterrupt:\\n pass\",\n \"def default_branch_layers(\\n inputs, \\n kernel_initializer=None,\\n **kwargs\\n):\\n return sequential(\\n inputs=inputs, \\n layers=[\\n (k.layers.Conv2D,\\n {'filters':32, 'kernel_size':8, 'strides':4, 'activation':'relu', \\n 'padding':'same'}),\\n (k.layers.Conv2D,\\n {'filters':64, 'kernel_size':4, 'dilation_rate':2, \\n 'activation':'relu', 'padding':'same'}),\\n (k.layers.Conv2D,\\n {'filters':64, 'kernel_size':3, 'activation':'relu', \\n 'padding':'same'}),\\n (k.layers.UpSampling2D, {'size':4, 'interpolation':'bilinear'})\\n ],\\n kernel_initializer=kernel_initializer,\\n **kwargs,\\n )\",\n \"def __init__(self, options):\\r\\n nn.Module.__init__(self)\\r\\n # Convolution and pooling layers of VGG-16.\\r\\n self.basemodel = torchvision.models.resnet18(pretrained=True)\\r\\n self.options = options\\r\\n\\r\\n #label\\r\\n self.label_primary = nn.Linear(options['primary_dim'], options['proj_dim'])\\r\\n self.label_dual = nn.Linear(options['dual_dim'], options['proj_dim'])\\r\\n\\r\\n #classifer/regressor\\r\\n self.fc_primary = nn.Linear(512 + options['proj_dim'], options['primary_dim'])\\r\\n self.fc_dual = nn.Linear(512 + options['proj_dim'], options['dual_dim'])\\r\\n\\r\\n\\r\\n if self.options['fc'] == True:\\r\\n # Freeze all previous layers.\\r\\n for param in self.basemodel.parameters():\\r\\n param.requires_grad = False\\r\\n # Initialize the fc layers.\\r\\n nn.init.kaiming_normal_(self.fc_primary.weight.data)\\r\\n if self.fc_primary.bias is not None:\\r\\n nn.init.constant_(self.fc_primary.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.fc_dual.weight.data)\\r\\n if self.fc_dual.bias is not None:\\r\\n nn.init.constant_(self.fc_dual.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.label_primary.weight.data)\\r\\n if self.label_primary.bias is not None:\\r\\n nn.init.constant_(self.label_primary.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.label_dual.weight.data)\\r\\n if self.label_dual.bias is not None:\\r\\n nn.init.constant_(self.label_dual.bias.data, val=0)\\r\\n\\r\\n\\r\\n else:\\r\\n for param in self.basemodel.conv1.parameters():\\r\\n param.requires_grad = False\\r\\n for param in self.basemodel.bn1.parameters():\\r\\n param.requires_grad = False\\r\\n for param in self.basemodel.layer1.parameters():\\r\\n param.requires_grad = False\\r\\n #for param in self.basemodel.layer2.parameters():\\r\\n # param.requires_grad = False\\r\\n #for param in self.basemodel.layer3.parameters():\\r\\n # param.requires_grad = False\\r\",\n \"def _make_conv_layers(self):\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def define_gender(name_input):\\n if not os.path.isfile('train_set.txt') and not os.path.isfile('test_set'):\\n \\\"\\\"\\\"\\n We take a sample of male and female names and mix\\n them in order to create a training set and testing set\\n \\\"\\\"\\\"\\n labeled_names = ([(name, 'male') for name in names.words('male.txt')] +\\n [(name, 'female') for name in names.words(\\n 'female.txt')])\\n random.shuffle(labeled_names)\\n\\n \\\"\\\"\\\"\\n We train the classifier and return the gender of the name\\n \\\"\\\"\\\"\\n featuresets = [(gender_features(n), gender) for (n, gender)\\n in labeled_names]\\n train_set, test_set = featuresets[-500:], featuresets[:500]\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n with open('train_set.txt', 'wb') as handle:\\n pickle.dump(train_set, handle)\\n with open('test_set.txt', 'wb') as handle:\\n pickle.dump(test_set, handle)\\n with open('classifier.txt', 'wb') as handle:\\n pickle.dump(classifier, handle)\\n\\n with open('train_set.txt', 'rb') as handle:\\n train_set = pickle.load(handle)\\n with open('test_set.txt', 'rb') as handle:\\n test_set = pickle.load(handle)\\n with open('classifier.txt', 'rb') as handle:\\n classifier = pickle.load(handle)\\n\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n# accuracy = nltk.classify.accuracy(classifier, test_set)\\n# classifier.show_most_informative_features(10)\\n# print accuracy\\n\\n \\\"\\\"\\\"\\n Accuracy: .804\\n Most Informative Features\\n last_letter = u'a' female : male = 44.0 : 1.0\\n last_letter = u'd' male : female = 23.7 : 1.0\\n last_two_letters = u'on' male : female = 11.0 : 1.0\\n first_two_letters = u'ha' male : female = 7.8 : 1.0\\n last_two_letters = u'ta' female : male = 7.0 : 1.0\\n last_letter = u't' male : female = 6.7 : 1.0\\n last_letter = u'o' male : female = 6.0 : 1.0\\n last_two_letters = u'll' male : female = 4.7 : 1.0\\n first_two_letters = u'te' male : female = 4.7 : 1.0\\n last_two_letters = u'an' male : female = 4.1 : 1.0\\n \\\"\\\"\\\"\\n\\n return classifier.classify(gender_features(name_input))\",\n \"def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\\n network = Sequential()\\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\\n return network\",\n \"def createDiscriminator(imgShape):\\n model = tf.keras.Sequential()\\n\\n model.add(layers.Conv2D(32, kernel_size = 3, strides = 2, input_shape = imgShape, padding = \\\"same\\\"))\\n model.add(layers.LeakyReLU(alpha = 0.2))\\n\\n model.add(layers.Dropout(0.25))\\n model.add(layers.Conv2D(64, kernel_size = 3, strides = 2, padding = \\\"same\\\"))\\n model.add(layers.ZeroPadding2D(padding = ((0,1), (0,1))))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.LeakyReLU(alpha = 0.2))\\n\\n model.add(layers.Dropout(0.25))\\n model.add(layers.Conv2D(128, kernel_size = 3, strides = 2, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.LeakyReLU(alpha = 0.2))\\n\\n model.add(layers.Dropout(0.25))\\n model.add(layers.Conv2D(256, kernel_size = 3, strides = 1, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.LeakyReLU(alpha = 0.2))\\n\\n model.add(layers.Dropout(0.25))\\n model.add(layers.Conv2D(512, kernel_size = 3, strides = 1, padding = \\\"same\\\"))\\n model.add(layers.BatchNormalization(momentum = 0.8))\\n model.add(layers.LeakyReLU(alpha = 0.2))\\n\\n model.add(layers.Dropout(0.25))\\n model.add(layers.Flatten())\\n model.add(layers.Dense(1, activation = \\\"sigmoid\\\"))\\n\\n return model\",\n \"def _final_block(self, in_channels, mid_channels, out_channels, kernel_size=3):\\n block = nn.Sequential(\\n nn.Conv2d(kernel_size=kernel_size, in_channels=in_channels, out_channels=mid_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(mid_channels),\\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=mid_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(mid_channels),\\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=out_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(out_channels)\\n )\\n return block\",\n \"def _final_block(self, in_channels, mid_channels, out_channels, kernel_size=3):\\n block = nn.Sequential(\\n nn.Conv2d(kernel_size=kernel_size, in_channels=in_channels, out_channels=mid_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(mid_channels),\\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=mid_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(mid_channels),\\n nn.Conv2d(kernel_size=kernel_size, in_channels=mid_channels, out_channels=out_channels, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(out_channels)\\n )\\n return block\",\n \"def build_dc_classifier():\\n # return nn.Sequential(\\n # Unflatten(Batch_size, 1, 28, 28),\\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(2, stride=2),\\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(kernel_size=2, stride=2),\\n # Flatten(),\\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.Linear(4 * 4 * 64, 1)\\n # )\\n\\n return nn.Sequential(\\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\\n Flatten(),\\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\\n )\",\n \"def define_generator(image_shape=(256, 256, 1)):\\n\\n # weight initialization\\n init = RandomNormal(stddev=0.02)\\n # image input\\n in_image = Input(shape=image_shape)\\n # encoder model\\n e1 = define_encoder_block(in_image, 64, batchnorm=False)\\n e2 = define_encoder_block(e1, 128)\\n e3 = define_encoder_block(e2, 256)\\n e4 = define_encoder_block(e3, 512)\\n e5 = define_encoder_block(e4, 512)\\n e6 = define_encoder_block(e5, 512)\\n e7 = define_encoder_block(e6, 512)\\n # bottleneck, no batch norm and relu\\n b = Conv2D(512, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(e7)\\n b = Activation('relu')(b)\\n # decoder model\\n d1 = decoder_block(b, e7, 512)\\n d2 = decoder_block(d1, e6, 512)\\n d3 = decoder_block(d2, e5, 512)\\n d4 = decoder_block(d3, e4, 512, dropout=False)\\n d5 = decoder_block(d4, e3, 256, dropout=False)\\n d6 = decoder_block(d5, e2, 128, dropout=False)\\n d7 = decoder_block(d6, e1, 64, dropout=False)\\n\\n # Changed the 1 below from 3 (gray ipv RGB)\\n g = Conv2DTranspose(1, (4, 4), strides=(2, 2), padding='same',\\n kernel_initializer=init)(d7)\\n out_image = Activation('tanh')(g)\\n # define model\\n model = Model(in_image, out_image)\\n\\n return model\",\n \"def __init__(self, dropout_rate, num_classes, include_top, layer):\\r\\n super(VGG16_Rand, self).__init__()\\r\\n print(\\\"CIFAR VGG16_Rand is used\\\")\\r\\n self.dropout_rate = dropout_rate\\r\\n self.num_classes = num_classes\\r\\n self.include_top = include_top\\r\\n self.layer = layer\\r\\n self.bias = True\\r\\n\\r\\n # Define the building blocks\\r\\n if layer <= 11:\\r\\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 12:\\r\\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 21:\\r\\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 22:\\r\\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 31:\\r\\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 32:\\r\\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 33:\\r\\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 41:\\r\\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 42:\\r\\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 43:\\r\\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 51:\\r\\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 52:\\r\\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 53:\\r\\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n self.avgpool = nn.AdaptiveAvgPool2d(1)\\r\\n self.fc = nn.Sequential(nn.Linear(512, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, num_classes))\\r\\n\\r\\n # Initialize the weights\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\r\\n elif isinstance(m, nn.BatchNorm2d):\\r\\n # raise Exception('You are using a model without BN!!!')\\r\\n nn.init.constant_(m.weight, 1)\\r\\n nn.init.constant_(m.bias, 0)\",\n \"def __init__(self):\\n super(PackageNet, self).__init__()\\n \\n # remove last layers of vgg19 model, save first fc layer and maxpool layer\\n self.vgg = models.vgg19(pretrained=True)\\n del self.vgg.classifier[2:]\\n\\n # get size of some layers\\n start_num = self.vgg.classifier[0].out_features\\n mid_num0 = int(np.sqrt(start_num))\\n mid_num1 = int(start_num**0.667)\\n mid_num2 = int(start_num**0.333)\\n \\n cls_out_num = 9 \\n reg_out_num = 16 # 8 3D bounding box coords\\n \\n # define classifier\\n self.classifier = nn.Sequential(\\n nn.Linear(start_num,mid_num0,bias=True),\\n nn.ReLU(),\\n nn.Linear(mid_num0,cls_out_num,bias = True),\\n nn.Softmax(dim = 1)\\n )\\n \\n # define regressor\\n # try relu and tanh, also try without bias\\n self.regressor = nn.Sequential(\\n nn.Linear(start_num,mid_num1,bias=True),\\n nn.ReLU(),\\n nn.Linear(mid_num1,mid_num2,bias = True),\\n nn.ReLU(),\\n nn.Linear(mid_num2,reg_out_num,bias = True),\\n nn.Sigmoid()\\n \\n )\",\n \"def discriminator_network(hparams, num_filters=64):\\n img = tf.keras.layers.Input(\\n shape=(hparams.hr_dimension, hparams.hr_dimension, 3))\\n\\n x = tf.keras.layers.Conv2D(\\n num_filters,\\n kernel_size=[3, 3],\\n strides=1,\\n padding='same',\\n use_bias=False)(\\n img)\\n x = tf.keras.layers.BatchNormalization()(x)\\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\\n\\n x = tf.keras.layers.Conv2D(\\n num_filters,\\n kernel_size=[3, 3],\\n strides=2,\\n padding='same',\\n use_bias=False)(\\n x)\\n x = tf.keras.layers.BatchNormalization()(x)\\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\\n\\n x = _conv_block_d(x, num_filters * 2)\\n x = _conv_block_d(x, num_filters * 4)\\n x = _conv_block_d(x, num_filters * 8)\\n\\n x = tf.keras.layers.Flatten()(x)\\n x = tf.keras.layers.Dense(100)(x)\\n x = tf.keras.layers.LeakyReLU(alpha=0.2)(x)\\n x = tf.keras.layers.Dense(1)(x)\\n\\n model = tf.keras.models.Model(inputs=img, outputs=x)\\n return model\",\n \"def GeneratorAndDiscriminator():\\n\\n # Baseline (G: DCGAN, D: DCGAN)\\n return ResnetGenerator, DCGANDiscriminator\\n\\n # No BN and constant number of filts in G\\n # return WGANPaper_CrippledDCGANGenerator, DCGANDiscriminator\\n\\n # 512-dim 4-layer ReLU MLP G\\n # return FCGenerator, DCGANDiscriminator\\n\\n # No normalization anywhere\\n # return functools.partial(DCGANGenerator, bn=False), functools.partial(DCGANDiscriminator, bn=False)\\n\\n # Gated multiplicative nonlinearities everywhere\\n # return MultiplicativeDCGANGenerator, MultiplicativeDCGANDiscriminator\\n\\n # tanh nonlinearities everywhere\\n # return functools.partial(DCGANGenerator, bn=True, nonlinearity=tf.tanh), \\\\\\n # functools.partial(DCGANDiscriminator, bn=True, nonlinearity=tf.tanh)\\n\\n # 101-layer ResNet G and D\\n # return ResnetGenerator, ResnetDiscriminator\\n\\n raise Exception('You must choose an architecture!')\",\n \"def VGG_CNN_F(arch_mode='full', weights='imagenet',\\n input_shape=(224, 224, 3), pooling=None, classes=1000):\\n\\n if not (weights in {'imagenet', None} or os.path.exists(weights)):\\n raise ValueError('The `weights` argument should be either '\\n '`None` (random initialization), `imagenet` '\\n '(pre-training on ImageNet), '\\n 'or the path to the weights file to be loaded.')\\n\\n if weights == 'imagenet' and arch_mode == 'full' and classes != 1000:\\n raise ValueError('If using `weights` as imagenet with `arch_mode`'\\n ' as `full`, `classes` should be 1000')\\n\\n img_input = Input(shape=input_shape)\\n x = Conv2D(64, (11, 11), strides=(4, 4), activation='relu', name='conv1')(img_input) # conv1\\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm1')(x) # norm1\\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same', name='pool1')(x) # pool1\\n\\n x = ZeroPadding2D(padding=(2, 2))(x)\\n x = Conv2D(256, (5, 5), strides=(1, 1), activation='relu', name='conv2')(x) # conv2\\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm2')(x) # norm2\\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool2')(x) # pool2\\n\\n x = ZeroPadding2D(padding=(1, 1))(x)\\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv3')(x) # conv3\\n\\n x = ZeroPadding2D(padding=(1, 1))(x)\\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv4')(x) # conv4\\n\\n x = ZeroPadding2D(padding=(1, 1))(x)\\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv5')(x) # conv5\\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x) # pool5\\n\\n if arch_mode == 'notop':\\n if pooling == 'avg':\\n x = GlobalAveragePooling2D()(x)\\n elif pooling == 'max':\\n x = GlobalMaxPooling2D()(x)\\n else:\\n x = Flatten()(x)\\n x = Dense(4096, activation='relu', name='fc6')(x) # fc6\\n x = Dropout(0.5)(x) # drop6\\n x = Dense(4096, activation='relu', name='fc7')(x) # fc7\\n x = Dropout(0.5)(x) # drop7\\n\\n if arch_mode == 'full':\\n x = Dense(classes, name='fc8')(x) # fc8\\n x = Activation('softmax', name='prob')(x) # prob\\n elif arch_mode != 'rmlast':\\n raise ValueError('arch_mode: {} is not supported.'.format(arch_mode))\\n\\n inputs = img_input\\n\\n # Create model.\\n model = Model(inputs, x, name='vgg_cnn_f')\\n\\n # load weights\\n if weights == 'imagenet':\\n if arch_mode == 'full':\\n weights_path = 'init_weights/vgg_cnn_f.h5'\\n elif arch_mode == 'rmlast':\\n weights_path = 'init_weights/vgg_cnn_f_rmlast.h5'\\n elif arch_mode == 'notop':\\n weights_path = 'init_weights/vgg_cnn_f_notop.h5'\\n model.load_weights(weights_path)\\n\\n if K.backend() == 'theano':\\n raise NotImplemented('Support for loading imagenet weights with '\\n 'theano backend is not implemented yet!')\\n\\n if K.image_data_format() == 'channels_first':\\n raise NotImplemented('Support for loading imagenet weights with '\\n 'channels_first image data format is not implemented yet!')\\n elif weights is not None:\\n model.load_weights(weights)\\n return model\",\n \"def build(width, height, depth, classes, stages, filters, include_top, pooling,\\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\\n inputShape = (height, width, depth)\\n chanDim = -1\\n\\n if K.image_data_format() == \\\"channels_first\\\":\\n inputShape = (depth, height, width)\\n chanDim = 1\\n\\n inputs = Input(shape=inputShape)\\n\\n\\n # block 1 (initial conv block)\\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\\n kernel_initializer=\\\"he_normal\\\", kernel_regularizer=l2(reg))(x)\\n x = BatchNormalization(axis=chanDim, name=\\\"bn_conv1\\\")(x)\\n x = Activation(\\\"relu\\\")(x)\\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\\\"pool1_pad\\\")(x)\\n x = MaxPooling2D(3, strides=2)(x)\\n\\n for i in range(0, len(stages)):\\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\\n\\n print(\\\"Stage {}, Stride={}\\\".format(i, stride))\\n x = SEResNet.residual_module(x, filters[i+1], stride,\\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\\n chanDim=chanDim, bnEps=bnEps,\\n bnMom=bnMom)\\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\\n momentum=bnMom)(x)\\n x = Activation(\\\"relu\\\")(x)\\n\\n if include_top:\\n x = GlobalAveragePooling2D()(x)\\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\\n activation='softmax')(x)\\n else:\\n if pooling == 'avg':\\n print(\\\"Adding average pool\\\")\\n x = GlobalAveragePooling2D()(x)\\n elif pooling == 'max':\\n x = GlobalMaxPooling2D()(x)\\n\\n model = Model(inputs=inputs, outputs=x, name=\\\"SEResNet\\\")\\n return model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66957885","0.66077316","0.63622165","0.6342879","0.633063","0.6302211","0.6302211","0.62979877","0.6269781","0.62534744","0.623655","0.62052697","0.61675453","0.61575735","0.61488783","0.61291873","0.61201566","0.61011446","0.60958564","0.6083565","0.60602874","0.60557455","0.60557455","0.60513604","0.6042773","0.6036498","0.60193926","0.60167605","0.60156554","0.5968898","0.59549713","0.5940637","0.59318775","0.59034526","0.58762485","0.5873326","0.5855461","0.5854434","0.58514965","0.5841217","0.5834706","0.5831107","0.58184487","0.5809972","0.58033866","0.57852095","0.5780063","0.577306","0.5772649","0.57657254","0.5765639","0.5764071","0.5762611","0.576108","0.57486206","0.5747609","0.5714594","0.5696453","0.5693452","0.5685477","0.5682961","0.56778485","0.56709635","0.56696624","0.5669585","0.5656217","0.5655619","0.56548536","0.56425565","0.56402916","0.56327045","0.5623843","0.56218797","0.5617579","0.5615164","0.56109977","0.560198","0.56008196","0.5591301","0.5582381","0.55765474","0.5571727","0.55515826","0.5550826","0.55468225","0.55432343","0.5539852","0.55377984","0.55364114","0.5535775","0.5533432","0.5533432","0.55308723","0.55290157","0.55275345","0.552479","0.5520258","0.5512617","0.55067694","0.54984987"],"string":"[\n \"0.66957885\",\n \"0.66077316\",\n \"0.63622165\",\n \"0.6342879\",\n \"0.633063\",\n \"0.6302211\",\n \"0.6302211\",\n \"0.62979877\",\n \"0.6269781\",\n \"0.62534744\",\n \"0.623655\",\n \"0.62052697\",\n \"0.61675453\",\n \"0.61575735\",\n \"0.61488783\",\n \"0.61291873\",\n \"0.61201566\",\n \"0.61011446\",\n \"0.60958564\",\n \"0.6083565\",\n \"0.60602874\",\n \"0.60557455\",\n \"0.60557455\",\n \"0.60513604\",\n \"0.6042773\",\n \"0.6036498\",\n \"0.60193926\",\n \"0.60167605\",\n \"0.60156554\",\n \"0.5968898\",\n \"0.59549713\",\n \"0.5940637\",\n \"0.59318775\",\n \"0.59034526\",\n \"0.58762485\",\n \"0.5873326\",\n \"0.5855461\",\n \"0.5854434\",\n \"0.58514965\",\n \"0.5841217\",\n \"0.5834706\",\n \"0.5831107\",\n \"0.58184487\",\n \"0.5809972\",\n \"0.58033866\",\n \"0.57852095\",\n \"0.5780063\",\n \"0.577306\",\n \"0.5772649\",\n \"0.57657254\",\n \"0.5765639\",\n \"0.5764071\",\n \"0.5762611\",\n \"0.576108\",\n \"0.57486206\",\n \"0.5747609\",\n \"0.5714594\",\n \"0.5696453\",\n \"0.5693452\",\n \"0.5685477\",\n \"0.5682961\",\n \"0.56778485\",\n \"0.56709635\",\n \"0.56696624\",\n \"0.5669585\",\n \"0.5656217\",\n \"0.5655619\",\n \"0.56548536\",\n \"0.56425565\",\n \"0.56402916\",\n \"0.56327045\",\n \"0.5623843\",\n \"0.56218797\",\n \"0.5617579\",\n \"0.5615164\",\n \"0.56109977\",\n \"0.560198\",\n \"0.56008196\",\n \"0.5591301\",\n \"0.5582381\",\n \"0.55765474\",\n \"0.5571727\",\n \"0.55515826\",\n \"0.5550826\",\n \"0.55468225\",\n \"0.55432343\",\n \"0.5539852\",\n \"0.55377984\",\n \"0.55364114\",\n \"0.5535775\",\n \"0.5533432\",\n \"0.5533432\",\n \"0.55308723\",\n \"0.55290157\",\n \"0.55275345\",\n \"0.552479\",\n \"0.5520258\",\n \"0.5512617\",\n \"0.55067694\",\n \"0.54984987\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7864113"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17077,"cells":{"query":{"kind":"string","value":"Used to build the age branch of our face recognition network. This branch is composed of three Conv > BN > Pool > Dropout blocks, followed by the Dense output layer."},"document":{"kind":"string","value":"def build_age_branch(self, inputs):\n x = self.make_default_hidden_layers(inputs)\n\n x = Flatten()(x)\n x = Dense(128)(x)\n x = Activation(\"relu\")(x)\n x = BatchNormalization()(x)\n x = Dropout(0.5)(x)\n x = Dense(1)(x)\n x = Activation(\"linear\", name=\"age_output\")(x)\n\n return x"},"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 discriminator_block(in_filters, out_filters):\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\n nn.LeakyReLU(0.01)]\n return layers","def build_bisenet(inputs, num_classes):\n\n ### The spatial path\n ### The number of feature maps for each convolution is not specified in the paper\n ### It was chosen here to be equal to the number of feature maps of a classification\n ### model at each corresponding stage\n # spatial_net = fluid.layers.resize_bilinear(inputs, [Image_Height/8, Image_Width/8])\n # print('spatial_net_1',spatial_net)\n\n ## spatial path\n spatial_net = ConvBlock(inputs, num_filters=64, kernel_size=3, stride=2)\n spatial_net = ConvBlock(spatial_net, num_filters=128, kernel_size=3, stride=2)\n spatial_net = ConvBlock(spatial_net, num_filters=256, kernel_size=3, stride=2)\n # print(\"spatial_net:\", spatial_net)\n\n # spatial_net = fluid.layers.resize_bilinear(spatial_net, [Image_Height/8, Image_Width/8])\n # print('spatial_net_2',spatial_net)\n ### Context path\n model = ResNet(is_test=False)\n # spatial_net = model.bottleneck_block1(inputs)\n end_points_16, end_points_32 = model.net(inputs)\n net_4 = AttentionRefinementModule(end_points_16, num_filters=512)\n net_5 = AttentionRefinementModule(end_points_32, num_filters=1024)\n global_channels = fluid.layers.reduce_mean(net_5, [2, 3], keep_dim=True)\n net_5_scaled = fluid.layers.elementwise_mul(net_5, global_channels, axis=0)\n\n ### Combining the paths\n net_4 = Upsample(net_4, scale=2)\n net_5_scaled = Upsample(net_5_scaled, scale=4)\n # print('net_4, net_5:', [net_4, net_5_scaled])\n # layers_concat = list()\n # layers_concat.append(spatial_net)\n ## layers_concat.append(net_4)\n # layers_concat.append(net_5_scaled)\n context_net = fluid.layers.concat([spatial_net, net_4, net_5_scaled], axis=1) #\n # context_net = fluid.layers.concat(input=layers_concat,axis=1)\n # print('context_net', context_net)\n # context_net = fluid.layers.concat([net_4, net_5_scaled], axis=1)\n # print('context_net', context_net)\n # context_net = fluid.layers.concat([spatial_net,context_net], axis=1)\n # print('context_net2',context_net)\n\n ### FFM\n # net = FeatureFusionModule(input_1=spatial_net, input_2=context_net, num_filters=num_classes)\n net = FeatureFusionModule(inputs=context_net, num_filters=num_classes)\n\n # print('net', net)\n\n ## [batch_zize, num_filters, 128, 64]\n\n ### Final upscaling and finish\n # net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 128])\n # print('conv2d_transpose', net)\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn1')\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[128, 256])\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn2')\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 512])\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn3')\n #net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[512, 1024])\n #net = batch_normalization(net, relu=True, name='conv2d_transpose_bn4')\n # print('net',net)\n net = fluid.layers.image_resize(net, out_shape=[512, 1024], resample='BILINEAR')\n\n net = fluid.layers.conv2d(net, num_classes, 1)\n return net","def __init__(self, kernel_size, filters, stage, block):\n super().__init__(name='identity' + str(stage) + block)\n filters1, filters2, filters3 = filters\n if K.image_data_format() == 'channels_last':\n bn_axis = 3\n else:\n bn_axis = 1\n\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n self.conv1 = layers.Conv2D(\n filters1, (1, 1),\n kernel_initializer='he_normal',\n name=conv_name_base + '2a')\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\n self.act1 = layers.Activation('relu')\n\n self.conv2 = layers.Conv2D(\n filters2,\n kernel_size,\n padding='same',\n kernel_initializer='he_normal',\n name=conv_name_base + '2b')\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\n self.act2 = layers.Activation('relu')\n\n self.conv3 = layers.Conv2D(\n filters3, (1, 1),\n kernel_initializer='he_normal',\n name=conv_name_base + '2c')\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\n\n self.add = layers.Add()\n self.act = layers.Activation('relu')","def construct_gumbel_selector(X_ph, num_words, embedding_dims, maxlen):\n emb_layer = Embedding(num_words, embedding_dims, input_length = maxlen, name = 'emb_gumbel')\n emb = emb_layer(X_ph) #(400, 50) \n net = Dropout(0.2, name = 'dropout_gumbel')(emb)\n net = emb\n first_layer = Conv1D(100, kernel_size, padding='same', activation='relu', strides=1, name = 'conv1_gumbel')(net) # bs, 400, 100\n\n # global info\n net_new = GlobalMaxPooling1D(name = 'new_global_max_pooling1d_1')(first_layer) # bs, 100\n global_info = Dense(100, name = 'new_dense_1', activation='relu')(net_new) # bs, 100\n\n # local info\n net = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv2_gumbel')(first_layer) # bs, 400, 100\n local_info = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv3_gumbel')(net) # bs, 400, 100\n combined = Concatenate()([global_info,local_info]) \n net = Dropout(0.2, name = 'new_dropout_2')(combined)\n net = Conv1D(100, 1, padding='same', activation='relu', strides=1, name = 'conv_last_gumbel')(net) \n\n logits_T = Conv1D(1, 1, padding='same', activation=None, strides=1, name = 'conv4_gumbel')(net) # bs, 400, 1\n # wanna make it bs, maxlen*num_groups\n squeeze_layer = Lambda(lambda x:tf.squeeze(x), output_shape=lambda x:x[:-1])\n\n logits_T_grp = Dense(maxlen*num_groups)(squeeze_layer(logits_T))\n #print(logits_T_grp.shape)\n return logits_T_grp # bs, 400* num_groups","def VGGFace(input_shape=(224, 224, 3), n_classes=10, include_top=True):\n # Create the Tensor\n input = Input(shape=input_shape)\n\n # Block 1\n # 1st Convolutional Layer\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv1')(input)\n x = Activation('relu', name='block1_relu1')(x)\n\n # 2nd Convolutional Layer\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv2')(x)\n x = Activation('relu', name='block1_relu2')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block1_pool')(x)\n\n # Block 2\n # 3rd Convolutional Layer\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv1')(x)\n x = Activation('relu', name='block2_relu1')(x)\n\n # 4th Convolutional Layer\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv2')(x)\n x = Activation('relu', name='block2_relu2')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block2_pool')(x)\n\n # Block 3\n # 5th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv1')(x)\n x = Activation('relu', name='block3_relu1')(x)\n\n # 6th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv2')(x)\n x = Activation('relu', name='block3_relu2')(x)\n\n # 7th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv3')(x)\n x = Activation('relu', name='block3_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block3_pool')(x)\n\n # Block 4\n # 8th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv1')(x)\n x = Activation('relu', name='block4_relu1')(x)\n\n # 9th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv2')(x)\n x = Activation('relu', name='block4_relu2')(x)\n\n # 10th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv3')(x)\n x = Activation('relu', name='block4_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block4_pool')(x)\n\n # Block 5\n # 11th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv1')(x)\n x = Activation('relu', name='block5_relu1')(x)\n\n # 12th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv2')(x)\n x = Activation('relu', name='block5_relu2')(x)\n\n # 13th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv3')(x)\n x = Activation('relu', name='block5_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block5_pool')(x)\n\n # Block 6\n # 14th Convulation Layer\n x = Conv2D(4096, (7, 7), strides=(1, 1), name='fc1_conv1')(x)\n x = Activation('relu', name='fc1_relu1')(x)\n x = Dropout(0.5)(x)\n\n # 15th Convulation Layer\n x = Conv2D(4096, (1, 1), strides=(1, 1), name='fc2_conv1')(x)\n x = Activation('relu', name='fc2_relu2')(x)\n x = Dropout(0.5, name='fc2_dropout')(x)\n\n # 16th Convulation Layer\n x = Conv2D(2622, (1, 1), strides=(1, 1), name='fc3_conv1')(x)\n x = Flatten(name='fc3_flatten')(x)\n\n if include_top:\n # Output Layer\n x = Activation('softmax', name='predictions_softmax')(x)\n\n # Create model\n model = keras.models.Model(input, x, name='vggface')\n return model","def LadderNet(input_size = (256, 256, 1), num_classes=2, filters=30): \n \n # X's denote standard flow\n # XNUM denote ResBlock outputs\n \n # \"First\" UNet\n \n # Input branch\n inputs = Input(input_size)\n X = Conv2D(filters=filters, kernel_size=3, activation=\"relu\", padding = 'same', kernel_initializer = 'he_normal')(inputs)\n\n # Down branch\n X1 = ResBlock(input_tensor=X, filters=filters) # ResBlock located in the first layer of the paper scheme\n X = Conv2D(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X1) \n X = Activation(\"relu\")(X) # This ReLU is not shown in the paper scheme\n \n X2 = ResBlock(input_tensor=X, filters=filters*2)\n X = Conv2D(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X2)\n X = Activation(\"relu\")(X)\n \n X3 = ResBlock(input_tensor=X, filters=filters*4)\n X = Conv2D(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X3)\n X = Activation(\"relu\")(X)\n \n X4 = ResBlock(input_tensor=X, filters=filters*8)\n X = Conv2D(filters=filters*16, kernel_size=3, strides=2, kernel_initializer='he_normal')(X4)\n X = Activation(\"relu\")(X)\n \n # Bottom block \n X = ResBlock(input_tensor=X, filters=filters*16)\n \n # Up branch\n X = Conv2DTranspose(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\n X = Add()([X, X4])\n # X = Activation(\"relu\")(X) # This ReLU is commented in the paper code\n X5 = ResBlock(input_tensor=X, filters=filters*8)\n \n X = Conv2DTranspose(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X5)\n X = Add()([X, X3])\n # X = Activation(\"relu\")(X)\n X6 = ResBlock(input_tensor=X, filters=filters*4)\n \n X = Conv2DTranspose(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X6)\n X = Add()([X, X2])\n # X = Activation(\"relu\")(X)\n X7 = ResBlock(input_tensor=X, filters=filters*2)\n \n X = Conv2DTranspose(filters=filters, kernel_size=3, strides=2, output_padding=1, kernel_initializer='he_normal')(X7)\n X = Add()([X, X1])\n # X = Activation(\"relu\")(X)\n X = ResBlock(input_tensor=X, filters=filters)\n \n # Top block (bottle-neck)\n X8 = ResBlock(input_tensor=X, filters=filters)\n X = ResBlock(input_tensor=X, filters=filters)\n X = Add()([X, X8])\n \n # \"Second\" UNet\n \n # Down branch\n X9 = ResBlock(input_tensor=X, filters=filters)\n X = Conv2D(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \n X = Activation(\"relu\")(X)\n X = Add()([X7, X]) \n \n X10 = ResBlock(input_tensor=X, filters=filters*2)\n X = Conv2D(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \n X = Activation(\"relu\")(X) \n X = Add()([X6, X])\n \n X11 = ResBlock(input_tensor=X, filters=filters*4)\n X = Conv2D(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \n X = Activation(\"relu\")(X)\n X = Add()([X5, X])\n\n X12 = ResBlock(input_tensor=X, filters=filters*8)\n X = Conv2D(filters=filters*16, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \n X = Activation(\"relu\")(X)\n \n # Bottom block\n X = ResBlock(input_tensor=X, filters=filters*16)\n \n # Up branch\n X = Conv2DTranspose(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\n X = Add()([X, X12]) \n # X = Activation(\"relu\")(X)\n X = ResBlock(input_tensor=X, filters=filters*8)\n \n X = Conv2DTranspose(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\n X = Add()([X, X11])\n # X = Activation(\"relu\")(X)\n X = ResBlock(input_tensor=X, filters=filters*4)\n \n X = Conv2DTranspose(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\n X = Add()([X, X10])\n # X = Activation(\"relu\")(X)\n X = ResBlock(input_tensor=X, filters=filters*2)\n \n X = Conv2DTranspose(filters=filters, kernel_size=3, strides=2, kernel_initializer='he_normal', output_padding=1)(X)\n X = Add()([X, X9])\n # X = Activation(\"relu\")(X)\n X = ResBlock(input_tensor=X, filters=filters)\n \n # Final block\n X = Conv2D(filters=num_classes, kernel_size=1, kernel_initializer='he_normal')(X)\n # X = Activation(\"relu\")(X)\n X = Activation(\"softmax\")(X)\n #X = Conv2D(1, 1)(X)\n \n model = Model(inputs, X)\n \n \n return model","def build_discriminator(self):\n img_shape = (self.img_size[0], self.img_size[1], self.channels)\n\n model = Sequential()\n ###############\n # Conv Stack 1:\n ###############\n model.add(\n Conv2D(128, kernel_size=5, strides=2, input_shape=img_shape, padding=\"same\")\n ) # 128x128 -> 64x64\n\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n # model.add(Dropout(0.2))\n\n ###############\n # Conv Stack 2:\n ###############\n model.add(\n Conv2D(128, kernel_size=5, strides=2, padding=\"same\")\n ) # 64x64 -> 32x32\n # model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))\n\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n # model.add(Dropout(0.25))\n\n ###############\n # Conv Stack 3:\n ###############\n model.add(\n Conv2D(128, kernel_size=4, strides=2, padding=\"same\")\n ) # 32x32 -> 16x16\n\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n # model.add(Dropout(0.25))\n\n ###############\n # Conv Stack 4:\n ###############\n model.add(Conv2D(128, kernel_size=4, strides=1, padding=\"same\")) # 16x16 -> 8x8\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n # model.add(Dropout(0.25))\n\n ###############\n # Conv Stack 5:\n ###############\n model.add(Conv2D(128, kernel_size=3, strides=1, padding=\"same\")) # 8x8 -> 4x4\n model.add(LeakyReLU(alpha=0.2))\n model.add(BatchNormalization(momentum=0.8))\n model.add(Dropout(0.4))\n\n model.add(Flatten())\n model.add(Dense(1, activation=\"sigmoid\")) # important binary classification.\n\n model.summary()\n\n # Model require Pair.\n img = Input(shape=img_shape)\n validity = model(img)\n\n return Model(img, validity)","def predict_age(input_path:str):\r\n #Initialize dlib face detector using the facial landmark recognition\r\n detector, predictor = initialize_dlib(facial_landmark_predictor=FACIAL_LANDMARK_PREDICTOR)\r\n\r\n #Load age prediction model\r\n age_net = load_caffe_models(age_model=AGE_MODEL, age_proto = AGE_PROTO)\r\n\r\n # Initialize frame size\r\n frame_width = 640\r\n frame_height = 360\r\n\r\n # Read Input Image\r\n img = cv2.imread(input_path)\r\n\r\n # Take a copy of the initial image and resize it\r\n frame = img.copy()\r\n frame = imutils.resize(img, width=frame_width, height=frame_height)\r\n\r\n # Convert it to gray scale\r\n gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n\r\n # Detect faces in the gray scale frame\r\n faces = detector(gray_frame, 0)\r\n\r\n # Loop over the faces detected\r\n for idx, face in enumerate(faces):\r\n print(\"Detection Face ID = {} - Position = Left:{} Top:{} Right:{} Botton:{}\".format((idx+1), face.left(), face.top(), face.right(),\r\n face.bottom()))\r\n\r\n #Draw the face bounding box\r\n (x,y,w,h) = face_utils.rect_to_bb(face)\r\n startX , startY , endX , endY = x,y,(x+w),(y+h)\r\n face_img = cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2)\r\n\r\n #Retrieve face\r\n # Determine the facial landmarks for the face region\r\n #shape = predictor(gray_frame, face)\r\n # Convert the facial landmark (x, y) coordinates to a NumPy array\r\n #shape = face_utils.shape_to_np(shape)\r\n # Extract the ROI of the face region as a separate image\r\n #(x, y, w, h) = cv2.boundingRect(np.array([shape]))\r\n #roi = img[y:y + h, x:x + w]\r\n #display_img(\"face\", roi)\r\n\r\n # image --> Input image to preprocess before passing it through our dnn for classification.\r\n blob = cv2.dnn.blobFromImage(image= face_img\r\n , scalefactor=1.0\r\n , size=(227, 227)\r\n , mean=MODEL_MEAN_VALUES\r\n , swapRB=False\r\n , crop=False)\r\n # Predict Age\r\n age_net.setInput(blob)\r\n age_preds = age_net.forward()\r\n i = age_preds[0].argmax()\r\n age = AGE_INTERVALS[i]\r\n age_confidence_score = age_preds[0][i]\r\n\r\n #print('shape' ,img.shape)\r\n\r\n #Draw the box\r\n label = \"Age{}-{:.2f}%\".format(age,age_confidence_score*100)\r\n print(label)\r\n\r\n #yPos = endY + 25\r\n yPos = startY - 15\r\n while yPos < 15:\r\n yPos += 15\r\n #print(yPos)\r\n optimal_font_scale = get_optimal_font_scale(label,((endX-startX)+25))\r\n cv2.rectangle(face_img, (startX, startY), (endX, endY), (0, 255, 0), 2)\r\n cv2.putText(face_img, label, (startX, yPos), cv2.FONT_HERSHEY_SIMPLEX, optimal_font_scale , (0, 255, 0), 2)\r\n #Display processed image\r\n display_img('Age Estimator', face_img)\r\n\r\n # Cleanup\r\n cv2.destroyAllWindows()","def darknet_body():\n return compose(DarknetConv2D_BN_Leaky(32, (3, 3)), MaxPooling2D(), DarknetConv2D_BN_Leaky(64, (3, 3)),\n MaxPooling2D(), bottleneck_block(128, 64), MaxPooling2D(), bottleneck_block(256, 128),\n MaxPooling2D(), bottleneck_x2_block(512, 256), MaxPooling2D(), bottleneck_x2_block(1024, 512))","def build_model(self):\n \n start_time = time.time()\n print(\"build model started\")\n # label\n self.FA = tf.placeholder(dtype=tf.int32, shape=[None])\n self.ges = tf.placeholder(dtype=tf.int32, shape=[None])\n self.obj = tf.placeholder(dtype=tf.int32, shape=[None])\n \n self.images = tf.placeholder(dtype=tf.float32, shape=[None, height, width, 3])\n batch_size = tf.shape(self.images)[0]\n rgb_scaled = self.images * 255.0\n\n # Convert RGB to BGR\n VGG_MEAN = [103.939, 116.779, 123.68]\n red, green, blue = tf.split(axis=3, num_or_size_splits=3, value=rgb_scaled)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n bgr = tf.concat(axis=3, values=[\n blue - VGG_MEAN[0],\n green - VGG_MEAN[1],\n red - VGG_MEAN[2],\n ])\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n \n with tf.variable_scope(\"vgg19\"):\n self.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\n self.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\n self.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\n self.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\n self.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\n self.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\n self.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\n self.conv3_4 = self.conv_layer(self.conv3_3, \"conv3_4\")\n self.pool3 = self.max_pool(self.conv3_4, 'pool3')\n\n self.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\n self.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\n self.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\n self.conv4_4 = self.conv_layer(self.conv4_3, \"conv4_4\")\n self.pool4 = self.max_pool(self.conv4_4, 'pool4')\n\n self.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\n self.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\n self.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\n self.conv5_4 = self.conv_layer(self.conv5_3, \"conv5_4\")\n self.pool5 = self.max_pool(self.conv5_4, 'pool5')\n\n \n shape = self.pool5.get_shape()\n size = 1\n for dim in shape[1:]:\n size *= dim.value\n \n # dense\n with tf.variable_scope('dense') as scope:\n # Move everything into depth so we can perform a single matrix multiply.\n reshape = tf.reshape(self.pool5, [-1, size])\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[size, 192]))\n biases = tf.get_variable('biases', [192], initializer=tf.constant_initializer(0.1))\n dense = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\n\n\n # linear layer(WX + b),\n with tf.variable_scope('softmax_linear_FA') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 2]))\n biases = tf.get_variable('biases', [2], initializer=tf.constant_initializer(0.1))\n softmax_linear_FA = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_FA = tf.nn.softmax(softmax_linear_FA)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.FA, logits=softmax_linear_FA, name='cross_entropy')\n cross_entropy_mean_FA = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n with tf.variable_scope('softmax_linear_ges') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 13]))\n biases = tf.get_variable('biases', [13], initializer=tf.constant_initializer(0.1))\n softmax_linear_ges = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_ges = tf.nn.softmax(softmax_linear_ges)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.ges, logits=softmax_linear_ges, name='cross_entropy')\n cross_entropy_mean_ges = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n with tf.variable_scope('softmax_linear_obj') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 24]))\n biases = tf.get_variable('biases', [24], initializer=tf.constant_initializer(0.1))\n softmax_linear_obj = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_obj = tf.nn.softmax(softmax_linear_obj)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.obj, logits=softmax_linear_obj, name='cross_entropy')\n cross_entropy_mean_obj = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n self.loss = cross_entropy_mean_FA + cross_entropy_mean_ges + cross_entropy_mean_obj\n self.lr = tf.placeholder(tf.float32, [])\n self.global_step = tf.Variable(0, name=\"global_step\", trainable=False)\n optimizer = tf.train.AdamOptimizer(self.lr)\n grads_and_vars = optimizer.compute_gradients(self.loss)\n self.train_op = optimizer.apply_gradients(grads_and_vars, global_step=self.global_step)\n self.data_dict = None\n print((\"build model finished: %ds\" % (time.time() - start_time)))","def model_build(self):\n\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\n X_input = Input(self.inputData[0].shape)\n\n '''\n # CONV -> BN -> RELU Block applied to X\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\n X = BatchNormalization(name='bn0')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\n X = Dropout(0.1, name='dropout0')(X)\n\n X = Conv2D(16, (16, 16), name='conv1')(X)\n X = BatchNormalization(name='bn1')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\n X = Dropout(0.1, name='dropout1')(X)\n\n X = Conv2D(16, (32, 32), name='conv2')(X)\n X = BatchNormalization(name='bn2')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\n X = Dropout(0.1, name='dropout2')(X)\n' '''\n\n X = Dense(500, activation='relu', name='fc0')(X_input)\n X = Dropout(0.1, name='dropout1')(X)\n X = Dense(500, activation='relu', name='fc1')(X)\n X = Dropout(0.1, name='dropout2')(X)\n X = Dense(3, activation='softmax', name='fc2')(X)\n\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')","def build_unet(input_layer = Input((128,128,3)), start_depth=64, activation='relu', initializer='he_normal'):\n\n # 128 -> 64\n conv1 = Conv2D_BN(input_layer, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\n conv1 = Conv2D_BN(conv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\n pool1 = MaxPooling2D((2, 2))(conv1)\n\n # 64 -> 32\n conv2 = Conv2D_BN(pool1, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\n conv2 = Conv2D_BN(conv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\n pool2 = MaxPooling2D((2, 2))(conv2)\n\n # 32 -> 16\n conv3 = Conv2D_BN(pool2, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\n conv3 = Conv2D_BN(conv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\n pool3 = MaxPooling2D((2, 2))(conv3)\n\n # 16 -> 8\n conv4 = Conv2D_BN(pool3, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\n conv4 = Conv2D_BN(conv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\n pool4 = MaxPooling2D((2, 2))(conv4)\n\n # Middle\n convm=cbam_block(pool4)\n\n # 8 -> 16\n deconv4 = Conv2DTranspose(convm, start_depth * 8, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\n uconv4 = concatenate([deconv4, conv4])\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\n\n # 16 -> 32\n deconv3 = Conv2DTranspose(uconv4, start_depth * 4, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\n uconv3 = concatenate([deconv3, conv3])\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\n\n # 32 -> 64\n deconv2 = Conv2DTranspose(uconv3, start_depth * 2, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\n uconv2 = concatenate([deconv2, conv2])\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\n\n # 64 -> 128\n deconv1 = Conv2DTranspose(uconv2, start_depth * 1, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\n uconv1 = concatenate([deconv1, conv1])\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\n\n output_layer = Conv2D(1, (1,1), padding=\"same\", activation=\"sigmoid\")(uconv1)\n\n return output_layer","def Unet4(shape, nb_filters=32, exp=1, kernel_size=3, initialization=\"glorot_uniform\", activation=\"relu\", sigma_noise=0, output_channels=1, drop=0.0, regularization=None):\n \n \n input_layer = Input(shape=shape)\n\n conv1 = ConvBlock(input_layer, nb_filters=nb_filters, kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n if drop > 0.0: pool1 = Dropout(drop)(pool1)\n\n conv2 = ConvBlock(pool1, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\n if drop > 0.0: pool2 = Dropout(drop)(pool2)\n\n conv3 = ConvBlock(pool2, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\n if drop > 0.0: pool3 = Dropout(drop)(pool3)\n\n conv4 = ConvBlock(pool3, nb_filters=nb_filters * 2 **(3 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\n if drop > 0.0: pool4 = Dropout(drop)(pool4)\n\n deconv5 = DeconvBlock(conv4, residual=conv3, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, regularization=regularization)\n if drop > 0.0: deconv5 = Dropout(drop)(deconv5)\n\n deconv6 = DeconvBlock(deconv5, residual=conv2, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, regularization=regularization)\n if drop > 0.0: deconv6 = Dropout(drop)(deconv6)\n\n deconv7 = DeconvBlock(deconv6, residual=conv1, nb_filters=nb_filters, kernel_size=kernel_size, regularization=regularization)\n if drop > 0.0: deconv7 = Dropout(drop)(deconv7)\n\n if sigma_noise > 0:\n deconv7 = GaussianNoise(sigma_noise)(deconv7)\n\n output_layer = Conv2D(filters=output_channels, kernel_size=(1, 1))(deconv7)\n output_layer = BatchNormalization()(output_layer)\n output_layer = Activation('softmax')(output_layer)\n\n model = Model(inputs=input_layer, outputs=output_layer, name='Unet')\n return model","def __conv_block(self, x, stage, branch, nb_filter, dropout_rate=None, weight_decay=1e-4):\n\t\teps = 1.1e-5\n\t\tconv_name_base = \"conv\" + str(stage) + \"_\" + str(branch)\n\t\trelu_name_base = \"relu\" + str(stage) + \"_\" + str(branch)\n\n\t\t# 1x1 Convolution (Bottleneck layer)\n\t\tinter_channel = nb_filter * 4 \n\t\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\"_x1_bn\")(x)\n\t\tx = Scale(axis=self.concat_axis, name=conv_name_base+\"_x1_scale\")(x)\n\t\tx = Activation(\"relu\", name=relu_name_base+\"_x1\")(x)\n\t\tx = Conv2D(inter_channel, (1, 1), name=conv_name_base+\"_x1\", use_bias=False)(x)\n\n\t\tif dropout_rate:\n\t\t\tx = Dropout(dropout_rate)(x)\n\n\t\t# 3x3 Convolution\n\t\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\"_x2_bn\")(x)\n\t\tx = Scale(axis=self.concat_axis, name=conv_name_base+\"_x2_scale\")(x)\n\t\tx = Activation(\"relu\", name=relu_name_base+\"_x2\")(x)\n\t\tx = ZeroPadding2D((1, 1), name=conv_name_base+\"_x2_zeropadding\")(x)\n\t\tx = Conv2D(nb_filter, (3, 3), name=conv_name_base+\"_x2\", use_bias=False)(x)\n\n\t\tif dropout_rate:\n\t\t\tx = Dropout(dropout_rate)(x)\n\n\t\treturn x","def build_vgg(self):\n # Get the vgg network. Extract features from Block 5, last convolution.\n vgg = tf.keras.applications.VGG19(weights=\"imagenet\", input_shape=self.hr_shape, include_top=False)\n vgg.trainable = False\n for layer in vgg.layers:\n layer.trainable = False\n\n # Create model and compile\n model = tf.keras.models.Model(inputs=vgg.input, outputs=vgg.get_layer(\"block5_conv4\").output)\n\n return model","def build(self):\n\n # bgr_ = bgr*255.0\n bgr_= self.X\n start_time = time.time()\n print(\"build model started\")\n\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n bgr = tf.concat(axis=3, values=[\n # blue - VGG_MEAN[0],\n # green - VGG_MEAN[1],\n # red - VGG_MEAN[2],\n\n red - VGG_MEAN[0],\n green - VGG_MEAN[1],\n blue - VGG_MEAN[2],\n ])\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n\n\n\n print(bgr.shape)\n\n self.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\n self.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\n self.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\n self.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\n\n\n\n self.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\n self.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\n self.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\n\n self.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\n self.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\n self.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\n\n\n\n\n\n self.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\n self.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\n self.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\n\n self.fc6 = self.fc_layer(self.pool5, \"fc6\")\n assert self.fc6.get_shape().as_list()[1:] == [4096]\n self.relu6 = tf.nn.relu(self.fc6)\n\n self.fc7 = self.fc_layer(self.relu6, \"fc7\")\n self.relu7 = tf.nn.relu(self.fc7)\n\n self.fc8 = self.fc_layer(self.relu7, \"fc8\")\n\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\n # self.relu9 = tf.nn.relu(self.fc9)\n\n\n\n\n relu8 = tf.nn.relu(self.fc8)\n fc9 = self.fc_layer(relu8, 'fc9')\n print((\"build model finished: %ds\" % (time.time() - start_time)))\n return fc9\n\n # self.prob = tf.nn.softmax(self.fc8, name=\"prob\")","def VGGModel(input_shape):\n \n\n X_input = Input(input_shape)\n \n # Creating a Neural Network (VGG-16)\n\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(X_input)\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(X)\n\n # Block 2\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(X)\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(X)\n\n # Block 3\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(X)\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(X)\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(X)\n\n # Block 4\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(X)\n\n # Block 5\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(X)\n \n X = Flatten()(X)\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc')(X)\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc2')(X)\n X = Dense(2048, activation='relu', kernel_initializer = 'he_normal', name='fc3')(X)\n X = Dense(1024, activation='relu', kernel_initializer = 'he_normal', name='fc4')(X)\n X = Dense(512, activation='relu', kernel_initializer = 'he_normal', name='fc5')(X)\n X = Dense(256, activation='relu', kernel_initializer = 'he_normal', name='fc6')(X)\n X = Dense(2, activation='linear', name='regression')(X)\n model = Model(inputs=X_input, outputs = X, name='HappyModel')\n print(model.summary())\n \n return model","def baseUNet(input_shape,conv_depth,n_classes,init_w,dropout):\n inputs = Input(input_shape)\n\n c1=Conv2D(conv_depth,\n (3,3),\n activation='relu',\n padding='same',\n kernel_initializer=init_w)(inputs)\n\n c1=Conv2D(conv_depth,\n (3,3),\n activation='relu',\n padding=\"same\",\n kernel_initializer=init_w)(c1)\n\n # pool down to next layer\n pool1 = MaxPooling2D((2,2),strides = (2,2))(c1)\n\n conv_depth *= 2\n\n # convolute down again\n conv2 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(pool1)\n\n conv2 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv2)\n \n # pool down again\n pool2 = MaxPooling2D((2,2),strides = (2,2))(conv2)\n\n conv_depth *= 2 \n\n # Convolution\n conv3 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(pool2)\n\n conv3 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv3)\n \n # pool down\n pool3 = MaxPooling2D((2,2),strides = (2,2))(conv3)\n\n conv_depth *= 2 \n # Convolution\n conv4 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(pool3)\n\n conv4 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv4)\n \n # pool down \n pool4 = MaxPooling2D((2,2),strides = (2,2))(conv4)\n\n conv_depth *=2 \n\n # Convolution\n conv5 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(pool4)\n\n conv5 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv5)\n\n drop = Dropout(dropout)(conv5)\n\n conv_depth /= 2\n conv_depth = int(conv_depth) \n # do upsampling\n up1 = UpSampling2D(size = (2,2))(drop)\n conv6 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(up1)\n \n # add in skip info\n cat1 = concatenate([conv4,conv6],axis = 3)\n conv6 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(cat1)\n\n conv6 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv6)\n\n conv_depth /= 2\n conv_depth = int(conv_depth)\n # do upsampling\n up2 = UpSampling2D(size = (2,2))(conv6)\n conv7 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(up2)\n \n # add in skip info\n cat2 = concatenate([conv3,conv7],axis = 3)\n conv7 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(cat2)\n\n conv7 = Conv2D(conv_depth,\n activation = 'relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv7)\n \n conv_depth /= 2\n conv_depth = int(conv_depth)\n # do upsampling\n up3 = UpSampling2D(size = (2,2))(conv7)\n conv8 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size=(3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(up3)\n \n # add in skip info\n cat3 = concatenate([conv2,conv8],axis = 3)\n conv8 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(cat3)\n\n conv8 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv8)\n \n conv_depth /= 2\n conv_depth = int(conv_depth)\n # do upsampling\n up4 = UpSampling2D(size = (2,2))(conv8)\n conv9 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(up4)\n \n # add in skip info\n cat4 = concatenate([c1,conv9],axis = 3)\n conv9 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(cat4)\n\n conv9 = Conv2D(conv_depth,\n activation ='relu',\n kernel_size = (3,3),\n strides = (1,1),\n padding = \"same\",\n kernel_initializer=init_w)(conv9)\n\n outputs = Conv2D(n_classes, 1, activation = 'softmax')(conv9)\n\n return outputs,inputs","def __init__(self, in_channels, BN, bn_eps=1e-5):\n super(InceptionE, self).__init__()\n self.branch1x1 = omth_blocks.conv_block(in_channels, filters=[320], kernel_sizes=[1], stride=[1],\n padding=[0], batch_norm=BN)\n\n self.branch3x3_1 = omth_blocks.conv_block(in_channels, filters=[384], kernel_sizes=[1], stride=[1],\n padding=[0], batch_norm=BN)\n self.branch3x3_2 = self.sub_inception_module(BN)\n\n self.branch3x3dbl_1 = omth_blocks.conv_block(in_channels, filters=[384, 384], kernel_sizes=[1, 3], stride=[1, 1],\n padding=[0, 1], batch_norm=BN)\n self.branch3x3dbl_2 = self.sub_inception_module(BN)\n\n self.branch_pool = omth_blocks.conv_block(in_channels, filters=[192], kernel_sizes=[1], stride=[1],\n padding=[0], batch_norm=BN)","def get_model(summary=False):\n\timage_input=Input(shape=(220,220,5),name='image_input')\n\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\n\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\t\n\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\n\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\n\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\t\n\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\n\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\n\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\t\n\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\n\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\n\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\t\n\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\n\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\n\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\t\n\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\n\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\n\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\t\n\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\n\tbranch1_flat=Flatten()(branch6_pool1)\n\tdrop=Dropout(.3)(branch1_flat)\n\t# FC layers group\n\tdense1=Dense(512, activation='relu', name='fc1')(drop)\n\tdrop1=Dropout(.3)(dense1)\n\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\n\tdrop3=Dropout(.3)(dense2)\n\tout=Dense(2, activation='softmax', name='fc4')(drop3)\n\tmodel=Model(inputs=image_input,outputs=out)\n\treturn model","def __init__(self, dropout_rate, num_classes, include_top, layer):\r\n super(VGG16_Rand, self).__init__()\r\n print(\"CIFAR VGG16_Rand is used\")\r\n self.dropout_rate = dropout_rate\r\n self.num_classes = num_classes\r\n self.include_top = include_top\r\n self.layer = layer\r\n self.bias = True\r\n\r\n # Define the building blocks\r\n if layer <= 11:\r\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 12:\r\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 21:\r\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 22:\r\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 31:\r\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 32:\r\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 33:\r\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 41:\r\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 42:\r\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 43:\r\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 51:\r\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 52:\r\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 53:\r\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n self.avgpool = nn.AdaptiveAvgPool2d(1)\r\n self.fc = nn.Sequential(nn.Linear(512, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, num_classes))\r\n\r\n # Initialize the weights\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\r\n elif isinstance(m, nn.BatchNorm2d):\r\n # raise Exception('You are using a model without BN!!!')\r\n nn.init.constant_(m.weight, 1)\r\n nn.init.constant_(m.bias, 0)","def __init__(self):\n super(AlexNet, self).__init__()\n\n initializer = tf.keras.initializers.RandomNormal(mean=0., stddev=0.01)\n bias = tf.keras.initializers.Ones()\n bias0 = tf.keras.initializers.Zeros()\n self.drop = tf.keras.layers.Dropout(.5)\n\n # Input is 227 and not 224 as stated on the doc.\n # See issue: https://stackoverflow.com/questions/36733636/the-number-of-neurons-in-alexnet\n self.conv1_1 = tf.keras.layers.Conv2D(48, 11, strides=4, activation=\"relu\", input_shape=[227, 227, 3],\n kernel_initializer=initializer, bias_initializer=bias0)\n self.conv1_2 = tf.keras.layers.Conv2D(48, 11, strides=4, activation=\"relu\", input_shape=[227, 227, 3],\n kernel_initializer=initializer, bias_initializer=bias0)\n # Output: 227 - 11 / 4 + 1 = 55\n # Maxpool: 55 / 2 = 27.5 = ~27\n\n self.conv2_1 = tf.keras.layers.Conv2D(128, 5, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n self.conv2_2 = tf.keras.layers.Conv2D(128, 5, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n # Output: 27\n # Maxpool: 27 / 2 = 13.5 = ~13\n\n self.conv3_1 = tf.keras.layers.Conv2D(192, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n self.conv3_2 = tf.keras.layers.Conv2D(192, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n # Output: 13\n\n self.conv4_1 = tf.keras.layers.Conv2D(192, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n self.conv4_2 = tf.keras.layers.Conv2D(192, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n # Output: 13\n\n self.conv5_1 = tf.keras.layers.Conv2D(128, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n self.conv5_2 = tf.keras.layers.Conv2D(128, 3, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias, padding=\"SAME\")\n # Output: 13\n\n self.max_pool = tf.keras.layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))\n # Output: 13 / 2 = 6.5 = ~6\n\n self.flatten = tf.keras.layers.Flatten()\n\n # Input: 6 * 6 * 128 * 2 = 9216\n self.fc1_1 = tf.keras.layers.Dense(2048, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias)\n self.fc1_2 = tf.keras.layers.Dense(2048, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias)\n\n self.fc2_1 = tf.keras.layers.Dense(2048, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias)\n self.fc2_2 = tf.keras.layers.Dense(2048, activation=\"relu\", kernel_initializer=initializer,\n bias_initializer=bias)\n\n self.fc3 = tf.keras.layers.Dense(1000, activation=\"softmax\")","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)","def discriminator_block(in_filters, out_filters, f_size=4, normalize=True,stride=2):\n layers = [nn.Conv2d(in_filters, out_filters, f_size, stride=stride, padding=0)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\n\t\t# We have to match this output size.\n\t\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\n\t\n\t\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\n\t\n\t\t# Convolutional ops will go here.\n\t\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tconv_output = c5\n\t\n\t\t# Transition to FC layers.\n\t\tpre_flat_shape = conv_output.get_shape().as_list()\n\t\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\n\t\n\t\t# Dense connections\n\t\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\n\t\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\n\t\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\n\t\tfc_out = fc2\n\t\n\t\t# Output point and our encoder mix-in.\n\t\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\n\t\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\n\t\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\n\t\n\t\t# More dense connections on the offset.\n\t\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\n\t\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\n\t\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\n\t\n\t\t# Expand for more convolutional operations.\n\t\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\n\t\n\t\t# More convolutions here.\n\t\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\n\t\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\n\t\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\n\t\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tdeconv_output = dc0\n\t\n\t\t# Return result + encoder output\n\t\treturn deconv_output, encoded_output","def discriminator_block(in_filters, out_filters, bn=True):\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Dropout2d(0.25)]\n if bn:\n block.append(nn.BatchNorm2d(out_filters, 0.8))\n return block","def __init__(self, in_channels, out_channels, kernel_size, num_layers=3,\n dropout_rate=0.3):\n super().__init__()\n\n _validate_args(in_channels, out_channels, kernel_size, num_layers)\n\n self.kernel_size = kernel_size\n self.padding = (kernel_size - 1) // 2\n\n conv_list = [\n self._create_single_block(in_channels, out_channels)\n ]\n\n # Create the rest of the blocks\n for _ in range(num_layers - 1):\n conv_list.append(\n self._create_single_block(out_channels, out_channels)\n )\n\n self.convs = nn.Sequential(*conv_list)\n self.drop = nn.Dropout2d(dropout_rate)\n self.pool = nn.MaxPool2d((2, 2), return_indices=True)","def build(width, height, depth, classes, stages, filters, include_top, pooling,\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\n inputShape = (height, width, depth)\n chanDim = -1\n\n if K.image_data_format() == \"channels_first\":\n inputShape = (depth, height, width)\n chanDim = 1\n\n inputs = Input(shape=inputShape)\n\n\n # block 1 (initial conv block)\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\n kernel_initializer=\"he_normal\", kernel_regularizer=l2(reg))(x)\n x = BatchNormalization(axis=chanDim, name=\"bn_conv1\")(x)\n x = Activation(\"relu\")(x)\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\"pool1_pad\")(x)\n x = MaxPooling2D(3, strides=2)(x)\n\n for i in range(0, len(stages)):\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\n\n print(\"Stage {}, Stride={}\".format(i, stride))\n x = SEResNet.residual_module(x, filters[i+1], stride,\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\n chanDim=chanDim, bnEps=bnEps,\n bnMom=bnMom)\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\n momentum=bnMom)(x)\n x = Activation(\"relu\")(x)\n\n if include_top:\n x = GlobalAveragePooling2D()(x)\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\n activation='softmax')(x)\n else:\n if pooling == 'avg':\n print(\"Adding average pool\")\n x = GlobalAveragePooling2D()(x)\n elif pooling == 'max':\n x = GlobalMaxPooling2D()(x)\n\n model = Model(inputs=inputs, outputs=x, name=\"SEResNet\")\n return model","def dir_conv_block(model, nb_layers, nb_filters, rate):\n\n for _ in range(nb_layers):\n model, rate = dir_conv_layer(model, nb_filters, rate)\n model = MaxPooling1D()(model)\n model = Dropout(0.1)(model)\n return model, rate","def discriminator_block(in_filters, out_filters, normalize=True):\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def identity_block(self, input_tensor, kernel_size, filters, stage, block):\r\n\t\tfilters1, filters2, filters3 = filters # this indicates the number of filter (here, assume that all filter number are same)\r\n\r\n\t\tbn_axis = self.channel_last # number of classes being classified\r\n \r\n\t\t# names for the layers\r\n\t\tconv_name_base = 'res' + str(stage) + block + '_branch'\r\n\t\tbn_name_base = 'bn' + str(stage) + block + '_branch'\r\n\r\n\t\t# model definition\r\n\t\tx = Conv2D(filters1, (1, 1),\r\n\t\t\t\t\t\t kernel_initializer='he_normal',\r\n\t\t\t\t\t\t name=conv_name_base + '2a')(input_tensor)\r\n\t\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)\r\n\t\tx = Activation('relu')(x)\r\n\r\n\t\tx = Conv2D(filters2, kernel_size,\r\n\t\t\t\t\t\t padding='same',\r\n\t\t\t\t\t\t kernel_initializer='he_normal',\r\n\t\t\t\t\t\t name=conv_name_base + '2b')(x)\r\n \r\n\t\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)\r\n\t\tx = Activation('relu')(x)\r\n\r\n\t\tx = Conv2D(filters3, (1, 1),\r\n\t\t\t\t\t\t kernel_initializer='he_normal',\r\n\t\t\t\t\t\t name=conv_name_base + '2c')(x)\r\n\t\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)\r\n\r\n\t\t# Here, we add the outcome tensor(layer) x to original input tensor\r\n\t\tx = add([x, input_tensor])\r\n\t\tx = Activation('relu')(x)\r\n \r\n\t\treturn x","def __init__(self, in_channels, out_channels, pool=True, last=False, stride=1):\n super(Vggish, self).__init__()\n # The two convolutional layers\n self.conv_1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(3, 3),\n stride=(stride, stride), padding=(1, 1), bias=False)\n self.conv_2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(3, 3),\n stride=(stride, stride), padding=(1, 1), bias=False)\n\n # Batch normalization\n self.bn_1 = nn.BatchNorm2d(out_channels)\n self.bn_2 = nn.BatchNorm2d(out_channels)\n\n # Flags\n self.last = last\n self.pool = pool\n\n # Setting up the max pooling\n self.max_pool = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), return_indices=True)\n\n # Weights initialization\n def _weights_init(m):\n if isinstance(m, nn.Conv2d or nn.Linear or nn.GRU or nn.LSTM):\n init.xavier_normal_(m.weight)\n # m.bias.data.zero_()\n elif isinstance(m, nn.BatchNorm2d or nn.BatchNorm1d):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n\n self.apply(_weights_init)","def init_encoder(self):\n\n vgg = models.vgg16(pretrained=True)\n\n blocks = [self.layer_1,\n self.layer_2,\n self.layer_3,\n self.layer_4,\n self.layer_5]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data","def __init__(self, kernel_size, filters, stage, block, strides=(2, 2)):\n super().__init__(name='conv_block' + str(stage) + block)\n filters1, filters2, filters3 = filters\n if K.image_data_format() == 'channels_last':\n bn_axis = 3\n else:\n bn_axis = 1\n conv_name_base = 'res' + str(stage) + block + '_branch'\n bn_name_base = 'bn' + str(stage) + block + '_branch'\n\n self.conv1 = layers.Conv2D(\n filters1, (1, 1),\n strides=strides,\n kernel_initializer='he_normal',\n name=conv_name_base + '2a')\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\n self.act1 = layers.Activation('relu')\n\n self.conv2 = layers.Conv2D(\n filters2,\n kernel_size,\n padding='same',\n kernel_initializer='he_normal',\n name=conv_name_base + '2b')\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\n self.act2 = layers.Activation('relu')\n\n self.conv3 = layers.Conv2D(\n filters3, (1, 1),\n kernel_initializer='he_normal',\n name=conv_name_base + '2c')\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\n\n self.shortcut_conv = layers.Conv2D(\n filters3, (1, 1),\n strides=strides,\n kernel_initializer='he_normal',\n name=conv_name_base + '1')\n self.shortcut_bn = layers.BatchNormalization(\n axis=bn_axis, name=bn_name_base + '1')\n\n self.add = layers.Add()\n self.act = layers.Activation('relu')","def build(self, unused_input_shapes):\n self.layers = []\n for i in range(self.num_hidden_layers):\n self.layers.append(\n TransformerDecoderBlock(\n hidden_size=self.hidden_size,\n num_attention_heads=self.num_attention_heads,\n intermediate_size=self.intermediate_size,\n intermediate_activation=self.intermediate_activation,\n hidden_dropout_prob=self.hidden_dropout_prob,\n attention_probs_dropout_prob=self.attention_probs_dropout_prob,\n initializer_range=self.initializer_range,\n multi_channel_cross_attention=self.multi_channel_cross_attention,\n name=(\"layer_%d\" % i)))\n super(TransformerDecoder, self).build(unused_input_shapes)","def build_gender_branch(self, inputs, num_genders=2):\n x = Lambda(lambda c: tf.image.rgb_to_grayscale(c))(inputs)\n\n x = self.make_default_hidden_layers(inputs)\n\n x = Flatten()(x)\n x = Dense(128)(x)\n x = Activation(\"relu\")(x)\n x = BatchNormalization()(x)\n x = Dropout(0.5)(x)\n x = Dense(num_genders)(x)\n x = Activation(\"sigmoid\", name=\"gender_output\")(x)\n\n return x","def __init__(self, in_channels, num_classes):\n super(InceptionAux, self).__init__()\n self.relu = nn.LeakyReLU()\n self.dropout1 = nn.Dropout(p=0.5)\n self.pool = nn.AvgPool2d(kernel_size=5, stride=3)\n self.conv = conv_block(in_channels, 128, kernel_size=1)\n self.fc1 = nn.Linear(12800, 1024)\n self.fc2 = nn.Linear(1024, 420)\n self.dropout2 = nn.Dropout(p=0.4)\n self.fc3 = nn.Linear(420,128)\n self.dropout3 = nn.Dropout(p=0.4)\n self.fc4 = nn.Linear(128,num_classes)","def __init__(self):\n super(Backbone, self).__init__()\n\n # input size: (128, 282, 282)\n # Block 1:\n # relu + 4 conv + bn\n self.conv1 = torch.nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=0)\n self.conv2 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\n self.conv3 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\n self.conv4 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\n\n self.bn1 = torch.nn.BatchNorm2d(64)\n self.bn2 = torch.nn.BatchNorm2d(64)\n self.bn3 = torch.nn.BatchNorm2d(64)\n self.bn4 = torch.nn.BatchNorm2d(64)\n\n # Block 2:\n # relu + 6 conv + stride 2 + bn\n self.conv5 = torch.nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=0)\n self.conv6 = torch.nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=0)\n self.conv7 = torch.nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=0)\n self.conv8 = torch.nn.Conv2d(64, 32, kernel_size=3, stride=1, padding=0)\n self.conv9 = torch.nn.Conv2d(32, 16, kernel_size=3, stride=1, padding=0)\n self.conv10 = torch.nn.Conv2d(16, 8, kernel_size=3, stride=1, padding=0)\n\n self.bn5 = torch.nn.BatchNorm2d(128)\n self.bn6 = torch.nn.BatchNorm2d(128)\n self.bn7 = torch.nn.BatchNorm2d(64)\n self.bn8 = torch.nn.BatchNorm2d(32)\n self.bn9 = torch.nn.BatchNorm2d(16)\n self.bn10 = torch.nn.BatchNorm2d(8)\n\n # Block 3:\n # 2 fully connected with drop out.\n\n self.fc1 = torch.nn.Linear( 8 * 59 * 59, 32)\n self.fc1_bn = torch.nn.BatchNorm1d(32)\n self.fc_out = torch.nn.Linear(32, 3)","def init_encoder(self):\n\n vgg = models.vgg16(pretrained=True)\n\n blocks = [self.layer_1,\n self.layer_2,\n self.layer_3,\n self.layer_4,\n self.layer_5]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data\n\n blocks = [self.layer_11,\n self.layer_12,\n self.layer_13,\n self.layer_14,\n self.layer_15]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data","def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\r\n\r\n super().__init__()\r\n\r\n self.input_size = input_dim\r\n self.input_dim =input_dim\r\n\r\n if type(hidden_dim) != list:\r\n self.hidden_sizes = [hidden_dim]*num_layers\r\n else:\r\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\r\n self.hidden_sizes = hidden_dim\r\n if type(kernel_sizes) != list:\r\n self.kernel_sizes = [kernel_sizes]*num_layers\r\n else:\r\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\r\n self.kernel_sizes = kernel_sizes\r\n\r\n self.n_layers = num_layers\r\n\r\n cells = nn.ModuleList()\r\n squenceCells=nn.ModuleList()\r\n\r\n for i in range(self.n_layers):\r\n\r\n if i == 0:\r\n input_dim = self.input_size\r\n else:\r\n input_dim = self.hidden_sizes[i-1]\r\n\r\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\r\n\r\n cells.append(cell)\r\n\r\n self.cells = cells\r\n\r\n\r\n for i in range(self.n_layers):\r\n\r\n squenceCell = SequenceGRU(gb_hidden_size[i])\r\n\r\n squenceCells.append(squenceCell)\r\n\r\n self.squenceCells = squenceCells","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_discriminator():\n leakyrelu_alpha = 0.2\n momentum = 0.8\n input_shape = (256, 256, 3)\n\n input_layer = Input(shape=input_shape)\n\n # Add the first convolution block\n dis1 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(input_layer)\n dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)\n\n # Add the 2nd convolution block\n dis2 = Conv2D(filters=64, kernel_size=3, strides=2, padding='same')(dis1)\n dis2 = LeakyReLU(alpha=leakyrelu_alpha)(dis2)\n dis2 = BatchNormalization(momentum=momentum)(dis2)\n\n # Add the third convolution block\n dis3 = Conv2D(filters=128, kernel_size=3, strides=1, padding='same')(dis2)\n dis3 = LeakyReLU(alpha=leakyrelu_alpha)(dis3)\n dis3 = BatchNormalization(momentum=momentum)(dis3)\n\n # Add the fourth convolution block\n dis4 = Conv2D(filters=128, kernel_size=3, strides=2, padding='same')(dis3)\n dis4 = LeakyReLU(alpha=leakyrelu_alpha)(dis4)\n dis4 = BatchNormalization(momentum=0.8)(dis4)\n\n # Add the fifth convolution block\n dis5 = Conv2D(256, kernel_size=3, strides=1, padding='same')(dis4)\n dis5 = LeakyReLU(alpha=leakyrelu_alpha)(dis5)\n dis5 = BatchNormalization(momentum=momentum)(dis5)\n\n # Add the sixth convolution block\n dis6 = Conv2D(filters=256, kernel_size=3, strides=2, padding='same')(dis5)\n dis6 = LeakyReLU(alpha=leakyrelu_alpha)(dis6)\n dis6 = BatchNormalization(momentum=momentum)(dis6)\n\n # Add the seventh convolution block\n dis7 = Conv2D(filters=512, kernel_size=3, strides=1, padding='same')(dis6)\n dis7 = LeakyReLU(alpha=leakyrelu_alpha)(dis7)\n dis7 = BatchNormalization(momentum=momentum)(dis7)\n\n # Add the eight convolution block\n dis8 = Conv2D(filters=512, kernel_size=3, strides=2, padding='same')(dis7)\n dis8 = LeakyReLU(alpha=leakyrelu_alpha)(dis8)\n dis8 = BatchNormalization(momentum=momentum)(dis8)\n\n # Add a dense layer\n #avgd = keras.layers.AveragePooling2D(pool_size=(4,4) , strides = (4,4))(dis8)\n\n #flat = keras.layers.Flatten()(dis8)\n dis9 = Dense(units=1024)(dis8)\n dis9 = LeakyReLU(alpha=0.2)(dis9)\n\n # Last dense layer - for classification\n output = Dense(units=1, activation='sigmoid')(dis9)\n\n model = Model(inputs=[input_layer], outputs=[output], name='discriminator')\n return model","def build_graph(self):\n n_classes = self.n_classes\n\n (self.feed('data')\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\n .conv(3, 3, 256, 1, 1, name='conv3_1')\n .conv(3, 3, 256, 1, 1, name='conv3_2')\n .conv(3, 3, 256, 1, 1, name='conv3_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\n .conv(3, 3, 512, 1, 1, name='conv4_1')\n .conv(3, 3, 512, 1, 1, name='conv4_2')\n .conv(3, 3, 512, 1, 1, name='conv4_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\n .conv(3, 3, 512, 1, 1, name='conv5_1')\n .conv(3, 3, 512, 1, 1, name='conv5_2')\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\n\n self.compute_rDeRF() # dummy\n\n # Classification\n (self.feed('conv5_3')\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\n .fc(4096, name='fc6')\n .dropout(0.5, name='drop6')\n .fc(4096, name='fc7')\n .dropout(0.5, name='drop7')\n # .make_time(name='drop7_reduced')\n .fc(n_classes, relu=False, name='cls_score')\n .softmax(name='cls_prob'))\n pass","def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation, dropout):\n super().__init__()\n # Padding on the left side\n pad = torch.nn.ZeroPad2d((padding, 0, 0, 0))\n # Convolutional network (we didnt include weight norms)\n conv2d1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(1, kernel_size),\n stride=stride, dilation=dilation)\n elu = nn.ELU()\n dropout = nn.Dropout(dropout)\n conv2d2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(1, kernel_size),\n stride=stride, dilation=dilation)\n self.net = nn.Sequential(pad, conv2d1, elu, dropout, pad, conv2d2, elu, dropout)","def densenet121(growth_rate=32, compression=1.0):\n\n init = K.initializers.he_normal(seed=None)\n X = K.Input(shape=(224, 224, 3))\n\n batch_1 = K.layers.BatchNormalization()(X)\n activation_1 = K.layers.Activation('relu')(batch_1)\n\n conv_1 = K.layers.Conv2D(filters=64,\n kernel_size=7,\n strides=2,\n padding='same',\n kernel_initializer=init)(activation_1)\n max_pool = K.layers.MaxPooling2D(pool_size=[3, 3],\n strides=2,\n padding='same')(conv_1)\n\n ly_1, nb_filters1 = dense_block(max_pool, 64, growth_rate, 6)\n\n ly_2, nb_filters2 = transition_layer(ly_1, nb_filters1, compression)\n ly_3, nb_filters3 = dense_block(ly_2, nb_filters2, growth_rate, 12)\n\n ly_4, nb_filters4 = transition_layer(ly_3, nb_filters3, compression)\n ly_5, nb_filters5 = dense_block(ly_4, nb_filters4, growth_rate, 24)\n\n ly_6, nb_filters6 = transition_layer(ly_5, nb_filters5, compression)\n ly_7, nb_filters7 = dense_block(ly_6, nb_filters6, growth_rate, 16)\n\n avg_pool = K.layers.AveragePooling2D(pool_size=[7, 7],\n strides=7,\n padding='same')(ly_7)\n\n dense = K.layers.Dense(1000, activation='softmax',\n kernel_initializer=init)(avg_pool)\n\n model = K.models.Model(inputs=X, outputs=dense)\n return model","def detection_head_graph(self, feature_map, filters):\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_1\", use_bias=True, padding=\"same\")(feature_map)\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_2\", use_bias=True, padding=\"same\")(x)\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"final_stage\", use_bias=True, padding=\"same\")(x)\n return x","def define(self, optimizer = Adam(lr=1e-5)): \n \n self.optimizer = optimizer\n\n model = Sequential()\n\n #Layer 1\n model.add(Conv2D( filters = 96, \n kernel_size = (11,11), \n strides = 4, \n padding = 'same', \n activation = 'relu', \n input_shape = (224, 224, 3), \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) # overlapping pooling\n #Layer 2\n model.add(Conv2D( filters = 256, \n kernel_size = (5,5), \n strides = 1, \n padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) \n #Layer 3\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', kernel_initializer = 'he_normal'))\n #Layer 4\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 5\n model.add(Conv2D( filters = 256, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 6\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None))\n \n #Layer 7\n model.add(Flatten())\n \n #Layer 8\n model.add(Dense( units = 4096, activation = 'relu'))\n model.add(Dense( units = 1024, activation = 'relu'))\n model.add(Dense( units = 512, activation = 'relu'))\n model.add(Dense( units = 256, activation = 'relu'))\n model.add(Dense( units = 128, activation = 'relu'))\n \n #Layer end\n model.add(Dense( units = 3, activation = 'softmax'))\n model.summary()\n \n self.model = model","def discriminator_block(in_filters, out_filters, normalize=True):\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def discriminator_block(in_filters, out_filters, normalize=True):\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\n super(ConvGRUCell, self).__init__()\n self.height, self.width = input_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.hidden_dim = hidden_dim\n self.bias = bias\n self.dtype = dtype\n\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)\n\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\n out_channels=self.hidden_dim, # for candidate neural memory\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)","def build_network(self):\n\n input_placeholder = Input(shape = self.input_shape)\n\n # Stage 1\n x = self.main_path_block(\n input_placeholder,\n 64, (7, 7), 'same',\n 'conv1', 'bn_conv1',\n activation = 'relu',\n strides = (2, 2)\n )\n x = MaxPooling2D((3, 3), strides = (2, 2), padding = 'same')(x)\n\n # Stage 2\n x = self.identity_block(x, 64, 'relu', 2, 'a', False)\n x = self.identity_block(x, 64, 'relu', 2, 'b')\n\n # Stage 3\n x = self.convolutional_block(x, [128, 128, 128], 'relu', 3, 'a')\n x = self.identity_block(x, 128, 'relu', 3, 'b')\n\n # Stage 4\n x = self.convolutional_block(x, [256, 256, 256], 'relu', 4, 'a')\n x = self.identity_block(x, 256, 'relu', 4, 'b')\n\n # Stage 5\n x = self.convolutional_block(x, [512, 512, 512], 'relu', 5, 'a')\n x = self.identity_block(x, 512, 'relu', 4, 'b')\n\n # Fully Connected Layers\n x = BatchNormalization(axis = 3)(x)\n x = Activation('relu')(x)\n x = AveragePooling2D((2, 1), padding = 'valid', strides = (2, 2))(x)\n x = Flatten()(x)\n x = Dense(512)\n x = Dense(\n self.classes, activation = 'softmax',\n name = 'fc_' + str(self.classes),\n kernel_initializer = glorot_uniform(seed = 0)\n )(x)\n\n self.model = Model(input_placeholder, x, name = 'Resnet18')","def faceRecoModel(input_shape):\n\n # Define the input as a tensor with shape input_shape\n X_input = Input(input_shape)\n\n # Zero-Padding\n X = ZeroPadding2D((3, 3))(X_input)\n\n # First Block\n X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X)\n X = BatchNormalization(axis=1, name='bn1')(X)\n X = Activation('relu')(X)\n\n # Zero-Padding + MAXPOOL\n X = ZeroPadding2D((1, 1))(X)\n X = MaxPooling2D((3, 3), strides=2)(X)\n\n # Second Block\n X = Conv2D(64, (1, 1), strides=(1, 1), name='conv2')(X)\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn2')(X)\n X = Activation('relu')(X)\n\n # Zero-Padding + MAXPOOL\n X = ZeroPadding2D((1, 1))(X)\n\n # Second Block\n X = Conv2D(192, (3, 3), strides=(1, 1), name='conv3')(X)\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn3')(X)\n X = Activation('relu')(X)\n\n # Zero-Padding + MAXPOOL\n X = ZeroPadding2D((1, 1))(X)\n X = MaxPooling2D(pool_size=3, strides=2)(X)\n\n # Inception 1: a/b/c\n X = inception_block_1a(X)\n X = inception_block_1b(X)\n X = inception_block_1c(X)\n\n # Inception 2: a/b\n X = inception_block_2a(X)\n X = inception_block_2b(X)\n\n # Inception 3: a/b\n X = inception_block_3a(X)\n X = inception_block_3b(X)\n\n # Top layer\n X = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\n X = Flatten()(X)\n X = Dense(128, name='dense_layer')(X)\n\n # L2 normalization\n X = Lambda(lambda x: tf.nn.l2_normalize(x, dim=1))(X)\n\n # Create model instance\n model = Model(inputs=X_input, outputs=X, name='FaceRecoModel')\n\n return model","def build_dc_classifier():\n # return nn.Sequential(\n # Unflatten(Batch_size, 1, 28, 28),\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(2, stride=2),\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(kernel_size=2, stride=2),\n # Flatten(),\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.Linear(4 * 4 * 64, 1)\n # )\n\n return nn.Sequential(\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\n Flatten(),\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\n nn.LeakyReLU(negative_slope=0.01),\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\n )","def __init__(self, nfeat, nhid, nclass, dropout, alpha):\n super(GCN, self).__init__()\n self.dropout = dropout\n\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\n \n self.add_module('conv1', self.conv1)\n\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)","def create_vgg_down_block(filters, in_features, activation, kernel_size=3, strategy='stride', batch_norm=False):\n layers = []\n if isinstance(filters, int):\n filters = [filters]\n\n if not isinstance(filters, list):\n raise ValueError(\"Filters has to be a list\")\n\n in_feat = in_features\n for n in range(len(filters))[:-1]:\n out_feat = filters[n]\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\n layers.append(conv)\n in_feat = out_feat\n\n layers.append(Conv2d_Down(in_features=in_feat, out_features=filters[-1], activation=activation, kernel_size=kernel_size, strategy=strategy, batch_norm=batch_norm))\n out_feat = filters[-1]\n return layers, out_feat","def __init__(self, ):\n super().__init__()\n channels = 3\n\n # Initial convolution block\n out_features = 64\n # encoder\n self.input = nn.Sequential(\n nn.ReflectionPad2d(channels),\n nn.Conv2d(3, out_features, (7, 7)),\n nn.InstanceNorm2d(out_features),\n nn.MaxPool2d(2),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Conv2d(out_features, out_features * 2, (3, 3), stride=(1, 1), padding=(1, 1)),\n nn.LeakyReLU(0.2, inplace=True),\n nn.MaxPool2d(2),\n nn.Conv2d(out_features * 2, out_features * 4, (3, 3), stride=(1, 1), padding=(1, 1)),\n nn.LeakyReLU(0.2, inplace=True),\n )\n\n self.in0 = nn.InstanceNorm2d(256)\n self.block0 = blocks()\n self.block1 = blocks()\n self.block2 = blocks()\n self.block3 = blocks()\n self.block4 = blocks()\n self.block5 = blocks()\n self.block6 = blocks()\n self.block7 = blocks()\n\n self.out = nn.Sequential(\n\n nn.Upsample(scale_factor=2),\n nn.Conv2d(out_features * 4, out_features * 2, 3, stride=1, padding=1),\n nn.InstanceNorm2d(out_features * 2),\n nn.LeakyReLU(0.2, inplace=True),\n\n nn.Upsample(scale_factor=2),\n nn.Conv2d(out_features * 2, out_features, 3, stride=1, padding=1),\n nn.InstanceNorm2d(out_features),\n nn.LeakyReLU(0.2, inplace=True),\n\n nn.ReflectionPad2d(channels),\n nn.Conv2d(out_features, channels, 7),\n nn.Tanh(),\n )","def __init__(self, dropout_rate=0.0, in_channels=3):\n\n super(MaskNet, self).__init__()\n\n self.prep_block_1 = nn.Sequential(\n nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(32),\n nn.Dropout(dropout_rate),\n )\n self.prep_block_2 = nn.Sequential(\n nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(32),\n nn.Dropout(dropout_rate),\n )\n\n self.convblock1 = nn.Sequential(\n nn.Conv2d(in_channels=64, out_channels=32, kernel_size=1, padding=0),\n nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(64),\n nn.Dropout(dropout_rate),\n )\n\n self.convblock2 = nn.Sequential(\n nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.BatchNorm2d(64),\n nn.Dropout(dropout_rate),\n )\n\n self.convblock3 = nn.Sequential(\n nn.Conv2d(in_channels=64, out_channels=1, kernel_size=1, padding=0),\n )","def BasicBlock(cin, cout, n):\n layers = [\n nn.Conv2d(cin, cout, 3, padding=1),\n nn.BatchNorm2d(cout),\n nn.ReLU()\n ]\n for _ in range(n - 1):\n layers.append(nn.Conv2d(cout, cout, 3, padding=1))\n layers.append(nn.BatchNorm2d(cout))\n layers.append(nn.ReLU())\n layers.append(nn.MaxPool2d(2))\n return nn.Sequential(*layers)","def _init_layers(self):\n self.relu = nn.ReLU(inplace=True)\n self.rpn_convs = nn.ModuleList()\n for i in range(self.stacked_convs):\n chn = self.in_channels if i == 0 else self.feat_channels\n self.rpn_convs.append(\n ConvModule(\n chn,\n self.feat_channels,\n 3,\n stride=1,\n padding=1,\n conv_cfg=self.conv_cfg,\n norm_cfg=self.norm_cfg))\n self.rpn_cls = nn.Conv2d(\n self.feat_channels, self.num_anchors * 1, 3, padding=1)\n self.rpn_reg = nn.Conv2d(\n self.feat_channels, self.num_anchors * 4 * (self.reg_max + 1), 3, padding=1)\n self.rpn_iou = nn.Conv2d(\n self.feat_channels, self.num_anchors * 1, 3, padding=1)\n self.scales = nn.ModuleList(\n [Scale(1.0) for _ in self.anchor_generator.strides])\n\n ##############V2################\n conf_vector = [nn.Conv2d(self.num_anchors * 4 * self.total_dim, self.num_anchors * self.reg_channels, 1)]\n conf_vector += [self.relu]\n conf_vector += [nn.Conv2d(self.num_anchors * self.reg_channels, self.num_anchors, 1), nn.Sigmoid()]\n\n self.reg_conf = nn.Sequential(*conf_vector)\n ##############V2################","def discriminator_block(in_filters, out_filters, normalization=True):\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalization:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def build_model(self):\n\n input_placeholder = Input(shape = self.input_shape)\n x = ZeroPadding2D((3, 3))(input_placeholder)\n\n # Stage 1\n x = self.main_path_block(x, 64, (7, 7), 'valid', 'conv1', 'bn_conv1', 'relu', (2, 2))\n x = MaxPooling2D((3, 3), strides = (2, 2))(x)\n\n # Stage 2\n x = self.convolutional_block(x, 3, [64, 64, 256], 2, 'a', 1)\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'b')\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'c')\n\n # Stage 3\n x = self.convolutional_block(x, 3, [128, 128, 512], 3, 'a', 2)\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'b')\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'c')\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'd')\n\n # Stage 4\n x = self.convolutional_block(x, 3, [256, 256, 1024], 4, 'a', 2)\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'b')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'c')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'd')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'e')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'f')\n\n # Stage 5\n x = self.convolutional_block(x, 3, [512, 512, 2048], 5, 'a', 2)\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'b')\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'c')\n \n # Average Pooling Layer\n x = AveragePooling2D((2, 2), name = 'avg_pool')(x)\n \n # Fully Connected Layer\n x = Flatten()(x)\n x = Dense(\n self.classes,\n activation = 'softmax',\n name = 'fc_' + str(self.classes),\n kernel_initializer = glorot_uniform(seed = 0)\n )(x)\n\n self.model = Model(input_placeholder, x, name = 'Resnet50')","def dense_block(X, nb_filters, growth_rate, layers):\n init = K.initializers.he_normal()\n\n for i in range(layers):\n batch = K.layers.BatchNormalization()(X)\n act = K.layers.Activation(K.activations.relu)(batch)\n conv = K.layers.Conv2D(growth_rate * 4, (1, 1), padding='same',\n strides=1,\n kernel_initializer=init)(act)\n batch = K.layers.BatchNormalization()(conv)\n act = K.layers.Activation(K.activations.relu)(batch)\n conv = K.layers.Conv2D(growth_rate, (3, 3), padding='same',\n strides=1,\n kernel_initializer=init)(act)\n X = K.layers.concatenate([X, conv], axis=3)\n nb_filters += growth_rate\n return X, nb_filters","def default_branch_layers(\n inputs, \n kernel_initializer=None,\n **kwargs\n):\n return sequential(\n inputs=inputs, \n layers=[\n (k.layers.Conv2D,\n {'filters':32, 'kernel_size':8, 'strides':4, 'activation':'relu', \n 'padding':'same'}),\n (k.layers.Conv2D,\n {'filters':64, 'kernel_size':4, 'dilation_rate':2, \n 'activation':'relu', 'padding':'same'}),\n (k.layers.Conv2D,\n {'filters':64, 'kernel_size':3, 'activation':'relu', \n 'padding':'same'}),\n (k.layers.UpSampling2D, {'size':4, 'interpolation':'bilinear'})\n ],\n kernel_initializer=kernel_initializer,\n **kwargs,\n )","def discriminator_block(in_filters, out_filters, stride, normalize):\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers\n\n layers = []\n in_filters = channels\n for out_filters, stride, normalize in [ (64, 2, False),\n (128, 2, True),\n (256, 2, True),\n (512, 1, True)]:\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\n in_filters = out_filters\n\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\n\n self.model = nn.Sequential(*layers)\n\n \"\"\"CycleGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, normalize=True):\n \"\"\"Returns downsampling layers of each discriminator block\"\"\"\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers\n\n self.model = nn.Sequential(\n *discriminator_block(in_channels, 64, normalize=False),\n *discriminator_block(64, 128),\n *discriminator_block(128, 256),\n *discriminator_block(256, 512),\n nn.ZeroPad2d((1, 0, 1, 0)),\n nn.Conv2d(512, 1, 4, padding=1)\n )\n\n \"\"\"DCGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, bn=True):\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Dropout2d(0.25)]\n if bn:\n block.append(nn.BatchNorm2d(out_filters, 0.8))\n return block\n\n self.model = nn.Sequential(\n *discriminator_block(opt.channels, 16, bn=False),\n *discriminator_block(16, 32),\n *discriminator_block(32, 64),\n *discriminator_block(64, 128),\n )\n\n # The height and width of downsampled image\n ds_size = opt.img_size // 2**4\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\n nn.Sigmoid())\n\n\n \"\"\"DiscoGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, normalization=True):\n \"\"\"Returns downsampling layers of each discriminator block\"\"\"\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalization:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers\n\n self.model = nn.Sequential(\n *discriminator_block(in_channels, 64, normalization=False),\n *discriminator_block(64, 128),\n *discriminator_block(128, 256),\n nn.ZeroPad2d((1, 0, 1, 0)),\n nn.Conv2d(256, 1, 4, padding=1)\n )\n\n \"\"\"DraGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, bn=True):\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Dropout2d(0.25)]\n if bn:\n block.append(nn.BatchNorm2d(out_filters, 0.8))\n return block\n\n self.model = nn.Sequential(\n *discriminator_block(opt.channels, 16, bn=False),\n *discriminator_block(16, 32),\n *discriminator_block(32, 64),\n *discriminator_block(64, 128),\n )\n\n # The height and width of downsampled image\n ds_size = opt.img_size // 2**4\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\n nn.Sigmoid())\n\n \"\"\"EBGAN\n \"\"\"\n # Upsampling\n self.down = nn.Sequential(\n nn.Conv2d(opt.channels, 64, 3, 2, 1),\n nn.ReLU(),\n )\n # Fully-connected layers\n self.down_size = (opt.img_size // 2)\n down_dim = 64 * (opt.img_size // 2)**2\n\n self.embedding = nn.Linear(down_dim, 32)\n\n self.fc = nn.Sequential(\n nn.BatchNorm1d(32, 0.8),\n nn.ReLU(inplace=True),\n nn.Linear(32, down_dim),\n nn.BatchNorm1d(down_dim),\n nn.ReLU(inplace=True)\n )\n # Upsampling\n self.up = nn.Sequential(\n nn.Upsample(scale_factor=2),\n nn.Conv2d(64, opt.channels, 3, 1, 1)\n )\n\n \"\"\"InfoGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, bn=True):\n \"\"\"Returns layers of each discriminator block\"\"\"\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Dropout2d(0.25)]\n if bn:\n block.append(nn.BatchNorm2d(out_filters, 0.8))\n return block\n\n self.conv_blocks = nn.Sequential(\n *discriminator_block(opt.channels, 16, bn=False),\n *discriminator_block(16, 32),\n *discriminator_block(32, 64),\n *discriminator_block(64, 128),\n )\n\n # The height and width of downsampled image\n ds_size = opt.img_size // 2**4\n\n # Output layers\n self.adv_layer = nn.Sequential(nn.Linear(128*ds_size**2, 1))\n self.aux_layer = nn.Sequential(\n nn.Linear(128*ds_size**2, opt.n_classes),\n nn.Softmax()\n )\n self.latent_layer = nn.Sequential(nn.Linear(128*ds_size**2, opt.code_dim))\n\n \"\"\"LSGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, bn=True):\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Dropout2d(0.25)]\n if bn:\n block.append(nn.BatchNorm2d(out_filters, 0.8))\n return block\n\n self.model = nn.Sequential(\n *discriminator_block(opt.channels, 16, bn=False),\n *discriminator_block(16, 32),\n *discriminator_block(32, 64),\n *discriminator_block(64, 128),\n )\n\n # The height and width of downsampled image\n ds_size = opt.img_size // 2**4\n self.adv_layer = nn.Linear(128*ds_size**2, 1)\n\n \"\"\"Pix2Pix\n \"\"\"\n def discriminator_block(in_filters, out_filters, normalization=True):\n \"\"\"Returns downsampling layers of each discriminator block\"\"\"\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\n if normalization:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers\n\n self.model = nn.Sequential(\n *discriminator_block(in_channels*2, 64, normalization=False),\n *discriminator_block(64, 128),\n *discriminator_block(128, 256),\n *discriminator_block(256, 512),\n nn.ZeroPad2d((1, 0, 1, 0)),\n nn.Conv2d(512, 1, 4, padding=1, bias=False)\n )\n\n \"\"\"Pixelda\n \"\"\"\n def block(in_features, out_features, normalization=True):\n \"\"\"Discriminator block\"\"\"\n layers = [ nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),\n nn.LeakyReLU(0.2, inplace=True) ]\n if normalization:\n layers.append(nn.InstanceNorm2d(out_features))\n return layers\n\n self.model = nn.Sequential(\n *block(opt.channels, 64, normalization=False),\n *block(64, 128),\n *block(128, 256),\n *block(256, 512),\n nn.Conv2d(512, 1, 3, 1, 1))\n\n \"\"\"SRGAN\n \"\"\"\n def discriminator_block(in_filters, out_filters, stride, normalize):\n \"\"\"Returns layers of each discriminator block\"\"\"\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\n if normalize:\n layers.append(nn.BatchNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers\n\n layers = []\n in_filters = in_channels\n for out_filters, stride, normalize in [ (64, 1, False),\n (64, 2, True),\n (128, 1, True),\n (128, 2, True),\n (256, 1, True),\n (256, 2, True),\n (512, 1, True),\n (512, 2, True),]:\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\n in_filters = out_filters\n\n # Output layer\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\n\n self.model = nn.Sequential(*layers)\n\n \"\"\"StarGAN\n \"\"\"\n channels, img_size, _ = img_shape\n\n def discriminator_block(in_filters, out_filters):\n \"\"\"Returns downsampling layers of each discriminator block\"\"\"\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\n nn.LeakyReLU(0.01)]\n return layers\n\n layers = discriminator_block(channels, 64)\n curr_dim = 64\n for _ in range(n_strided - 1):\n layers.extend(discriminator_block(curr_dim, curr_dim*2))\n curr_dim *= 2\n\n self.model = nn.Sequential(*layers)\n\n # Output 1: PatchGAN\n self.out1 = nn.Conv2d(curr_dim, 1, 3, padding=1, bias=False)\n # Output 2: Class prediction\n kernel_size = img_size // 2**n_strided\n self.out2 = nn.Conv2d(curr_dim, c_dim, kernel_size, bias=False)\n\n \"\"\"WGAN\n \"\"\"\n nn.Linear(int(np.prod(img_shape)), 512),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Linear(512, 256),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Linear(256, 1)\n\n \n\n\n# import torch.nn as nn\n# import torch\n# from torch.nn.modules import conv, Linear\n# import torch.nn.functional as F\n# from src.snlayers.snconv2d import SNConv2d\n\n# class _netG(nn.Module):\n# def __init__(self, nz, nc, ngf):\n# super(_netG, self).__init__()\n# self.main = nn.Sequential(\n# # input is Z, going into a convolution\n# nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=True),\n# nn.BatchNorm2d(ngf * 8),\n# nn.ReLU(True),\n# # state size. (ngf*8) x 4 x 4\n# nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=True),\n# nn.BatchNorm2d(ngf * 4),\n# nn.ReLU(True),\n# # state size. (ngf*4) x 8 x 8\n# nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=True),\n# nn.BatchNorm2d(ngf * 2),\n# nn.ReLU(True),\n# # state size. (ngf*2) x 16 x 16\n# nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=True),\n# nn.BatchNorm2d(ngf),\n# nn.ReLU(True),\n# # state size. (ngf) x 32 x 32\n# nn.ConvTranspose2d(ngf, nc, 3, 1, 1, bias=True),\n# nn.Tanh()\n# # state size. (nc) x 32 x 32\n# )\n\n# def forward(self, input):\n# output = self.main(input)\n# return output\n\n# # Actor\n# class _netE(nn.Module):\n# def __init__(self, nc, ndf):\n# super(_netE, self).__init__()\n\n# self.main = nn.Sequential(\n# SNConv2d(nc, ndf, 7, 4, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf, 3, 7, 4, 1, bias=False),\n# nn.Sigmoid()\n# )\n# def forward(self, input):\n# output = self.main(input) \n# return output.view(-1, 3).squeeze(1)\n\n# class _netD1(nn.Module):\n# def __init__(self, nc, ndf):\n# super(_netD1, self).__init__()\n\n self.main = nn.Sequential(\n SNConv2d(nc, ndf, 5, 2, 2), \n nn.LeakyReLU(0.2, inplace=True),\n SNConv2d(ndf, ndf * 2, 5, 2, 2),\n nn.LeakyReLU(0.2, inplace=True),\n SNConv2d(ndf * 2, ndf * 4, 5, 2, 2),\n nn.LeakyReLU(0.2, inplace=True),\n SNConv2d(ndf * 4, ndf * 8, 5, 2, 2),\n nn.LeakyReLU(0.2, inplace=True),\n SNConv2d(ndf * 8, 1, 4),\n nn.Sigmoid()\n\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf) x 32 x 32\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 2),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*2) x 16 x 16\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 4),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*4) x 8 x 8\n nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 8),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*8) x 4 x 4\n nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n nn.Sigmoid()\n\n # input is (nc) x 64 x 64\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf) x 32 x 32\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 2),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*2) x 16 x 16\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 4),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Conv2d(ndf * 4, ndf * 16, 4, 2, 1, bias=False),\n nn.BatchNorm2d(ndf * 16),\n nn.LeakyReLU(0.2, inplace=True),\n # state size. (ndf*16) x 4 x 4\n nn.Conv2d(ndf * 16, 1, 4, 1, 0, bias=False),\n nn.Sigmoid()\n # )\n # def forward(self, input):\n # output = self.main(input)\n # output = output.view(-1, 1).squeeze(1)\n # return output\n\n# class _netD2(nn.Module):\n# def __init__(self, nc, ndf):\n# super(_netD2, self).__init__()\n\n# self.main = nn.Sequential(\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf, ndf, 16, 2, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# # ndf x 30 x 30\n\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf * 2, ndf * 2, 16, 2, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# # (ndf * 2) x 9 x 9\n\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf * 4, 1, 9, 1, 0, bias=False),\n# nn.Sigmoid()\n# # 1 x 1 x 1\n# )\n# def forward(self, input):\n# output = self.main(input)\n# return output.view(-1, 1).squeeze(1)\n\n# class _netD3(nn.Module):\n# def __init__(self, nc, ndf):\n# super(_netD3, self).__init__()\n\n# self.main = nn.Sequential(\n# # input is (nc) x 32 x 32\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf, ndf, 4, 2, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# # state size. (ndf) x 1 x 32\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf*2, ndf * 2, 4, 2, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# # state size. (ndf*2) x 16 x 16\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n\n# SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf * 8, ndf * 8, 4, 2, 1, bias=True),\n\n# # state size. (ndf*8) x 4 x 4\n# SNConv2d(ndf * 8, ndf * 16, 3, 1, 1, bias=True),\n# nn.LeakyReLU(0.1, inplace=True),\n# SNConv2d(ndf * 16, 1, 4, 1, 0, bias=False),\n# nn.Sigmoid()\n# )\n# def forward(self, input):\n# output = self.main(input)\n# output = output.view(-1, 1).squeeze(1)\n# return output\n\n\n# _netD_list = [_netD1]","def _make_conv_layers(self):\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def detect_function(frame, faceNet, ageNet, minConf=0.5):\n # Define the list of age range \n AGE_RAN = [\"(0-2)\", \"(4-6)\", \"(8-12)\", \"(15-20)\", \"(25-32)\", \"(38-43)\", \"(48-53)\", \"(60-100)\"]\n \n # Initialize the results list\n results = []\n (h, w) = frame.shape[:2] # extacting the image coordinates\n # To preprocess the image\n blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300), (104.0, 177.0, 123.0))\n \n # Passing the transformed image through the network and obtain the face detections\n faceNet.setInput(blob)\n detections = faceNet.forward()\n \n # Loop for the prediction on each image\n for i in range(0, detections.shape[2]):\n \n # Extract the confidence for all predictions\n confidence = detections[0, 0, i, 2]\n \n # Condition to eliminate the low confidences\n if confidence > minConf:\n \n # grabbing the coordinates of the detected faces\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n (X, Y, dX, dY) = box.astype(\"int\")\n \n # Defining the region of interest to each detected face and applying the blob to them\n face = frame[Y:dY, X:dX]\n # Ensure that the ROI is sufficiently large\n \n if face.shape[0] < 20 or face.shape[1] < 20:\n continue\n faceBlob = cv2.dnn.blobFromImage(face, 1.0, (227, 227), (78.4263377603, 87.7689143744, 114.895847746),\n swapRB=False)\n \n # Making the age prediction\n ageNet.setInput(faceBlob)\n preds = ageNet.forward() # age predictions\n i = preds[0].argmax() # grab the great confidence\n age = AGE_RAN[i] # grab the age range\n ageConfidence = preds[0][i] # putting the confidence\n \n # Dictionary with ROI and predictions\n d = {\"loc\": (X, Y, dX, dY),\n \"age\": (age, ageConfidence)}\n results.append(d) # appending the results into the the results list\n \n return results","def vanilla_unet(input_shape=(512, 512, 3), base_depth=32, drop_rate=0,\n seed=1337):\n input = Input(input_shape)\n\n conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(input)\n bn1 = BatchNormalization()(conv1)\n drop1 = Dropout(drop_rate, seed=seed)(bn1)\n conv2 = Conv2D(base_depth, 3, activation='relu', padding='same')(drop1)\n bn2 = BatchNormalization()(conv2)\n mp1 = MaxPooling2D(pool_size=(2, 2))(bn2)\n\n conv3 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(mp1)\n bn3 = BatchNormalization()(conv3)\n drop2 = Dropout(drop_rate, seed=seed+1)(bn3)\n conv4 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(drop2)\n bn4 = BatchNormalization()(conv4)\n mp2 = MaxPooling2D(pool_size=(2, 2))(bn4)\n\n conv5 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(mp2)\n bn5 = BatchNormalization()(conv5)\n drop3 = Dropout(drop_rate, seed=seed+2)(bn5)\n conv6 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(drop3)\n bn6 = BatchNormalization()(conv6)\n mp3 = MaxPooling2D(pool_size=(2, 2))(bn6)\n\n conv7 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(mp3)\n bn7 = BatchNormalization()(conv7)\n drop4 = Dropout(drop_rate, seed=seed+3)(bn7)\n conv8 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(drop4)\n bn8 = BatchNormalization()(conv8)\n mp4 = MaxPooling2D(pool_size=(2, 2))(bn8)\n\n conv9 = Conv2D(base_depth*16, 3, activation='relu', padding='same')(mp4)\n bn9 = BatchNormalization()(conv9)\n drop5 = Dropout(drop_rate, seed=seed+4)(bn9)\n deconv0 = Conv2DTranspose(base_depth*16, 3, activation='relu',\n padding='same')(drop5)\n bn10 = BatchNormalization()(deconv0)\n up1 = UpSampling2D(interpolation='bilinear')(bn10)\n\n deconv1 = Conv2DTranspose(base_depth*8, 3, activation='relu',\n padding='same')(up1)\n bn11 = BatchNormalization()(deconv1)\n cat1 = concatenate([bn11, bn8])\n drop6 = Dropout(drop_rate, seed=seed+5)(cat1)\n deconv2 = Conv2DTranspose(base_depth*8, 3, activation='relu',\n padding='same')(drop6)\n bn12 = BatchNormalization()(deconv2)\n up2 = UpSampling2D(interpolation='bilinear')(bn12)\n\n deconv3 = Conv2DTranspose(base_depth*4, 3, activation='relu',\n padding='same')(up2)\n bn13 = BatchNormalization()(deconv3)\n cat2 = concatenate([bn13, bn6])\n drop7 = Dropout(drop_rate, seed=seed+6)(cat2)\n deconv4 = Conv2DTranspose(base_depth*4, 3, activation='relu',\n padding='same')(drop7)\n bn14 = BatchNormalization()(deconv4)\n up3 = UpSampling2D(interpolation='bilinear')(bn14)\n\n deconv5 = Conv2DTranspose(base_depth*2, 3, activation='relu',\n padding='same')(up3)\n bn15 = BatchNormalization()(deconv5)\n cat3 = concatenate([bn15, bn4])\n drop8 = Dropout(drop_rate, seed=seed+7)(cat3)\n deconv6 = Conv2DTranspose(base_depth*2, 3, activation='relu',\n padding='same')(drop8)\n bn16 = BatchNormalization()(deconv6)\n up4 = UpSampling2D(interpolation='bilinear')(bn16)\n\n deconv7 = Conv2DTranspose(base_depth, 3, activation='relu',\n padding='same')(up4)\n bn17 = BatchNormalization()(deconv7)\n cat4 = concatenate([bn17, bn2])\n drop7 = Dropout(drop_rate, seed=seed+8)(cat4)\n deconv8 = Conv2DTranspose(base_depth, 3, activation='relu',\n padding='same')(drop7)\n bn18 = BatchNormalization()(deconv8)\n\n out = Conv2DTranspose(1, 1, activation='sigmoid', padding='same')(bn18)\n\n return Model(input, out)","def __init__(\n self, \n dim_feat_raw, \n dim_feat_smooth, \n dim_label_raw, \n dim_label_smooth, \n arch_gnn, \n aug_feat,\n num_ensemble, \n train_params\n ):\n super().__init__()\n self.mulhead = 1\n self.num_layers = arch_gnn[\"num_layers\"]\n self.dropout, self.dropedge = train_params[\"dropout\"], train_params['dropedge']\n self.mulhead = int(arch_gnn[\"heads\"]) # only useful for GAT\n\n self.branch_sharing = arch_gnn['branch_sharing'] # only for ensemble\n\n self.type_feature_augment = aug_feat\n assert dim_feat_raw <= dim_feat_smooth, \"smoothened feature cannot have smaller shape than the original one\"\n # NOTE: dim_label_raw may be larger than dim_label_smooth ==> label is not used as input\n self.num_classes = dim_label_raw\n self.dim_label_in = dim_label_smooth\n self.dim_feat_in = dim_feat_smooth\n self.dim_hidden = arch_gnn['dim']\n # build the model below\n dim, act = arch_gnn['dim'], arch_gnn['act']\n self.aug_layers, self.conv_layers, self.res_pool_layers = [], [], []\n for i in range(num_ensemble):\n # feat aug\n if len(self.type_feature_augment) > 0:\n self.aug_layers.append(nn.ModuleList(\n nn.Linear(_dim, self.dim_feat_in) for _, _dim in self.type_feature_augment\n ))\n # graph convs\n convs = []\n if i == 0 or not self.branch_sharing:\n for j in range(arch_gnn['num_layers']):\n cls_gconv = DeepGNN.NAME2CLS[arch_gnn['aggr']]\n dim_in = (self.dim_feat_in + self.dim_label_in) if j == 0 else dim\n convs.append(cls_gconv(dim_in, dim, dropout=self.dropout, act=act, mulhead=self.mulhead))\n self.conv_layers.append(nn.Sequential(*convs))\n else: # i > 0 and branch_sharing\n self.conv_layers.append(self.conv_layers[-1])\n # skip-pooling layer\n type_res = arch_gnn['residue'].lower()\n type_pool = arch_gnn['pooling'].split('-')[0].lower()\n cls_res_pool = layers.ResPool\n args_pool = {}\n if type_pool == 'sort':\n args_pool['k'] = int(arch_gnn['pooling'].split('-')[1])\n self.res_pool_layers.append(\n cls_res_pool(dim, dim, arch_gnn['num_layers'], type_res, type_pool,\n dropout=self.dropout, act=act, args_pool=args_pool\n ))\n if len(self.aug_layers) > 0:\n self.aug_layers = nn.ModuleList(self.aug_layers)\n self.conv_layers = nn.ModuleList(self.conv_layers)\n self.res_pool_layers = nn.ModuleList(self.res_pool_layers)\n # ------- ensembler + classifier -------\n if num_ensemble == 1:\n self.ensembler = layers.EnsembleDummy()\n else:\n self.ensembler = layers.EnsembleAggregator(dim, dim, num_ensemble, dropout=self.dropout, \n type_dropout=train_params[\"ensemble_dropout\"], act=arch_gnn[\"ensemble_act\"])\n self.classifier = DeepGNN.NAME2CLS['mlp'](dim, self.num_classes, act='I', dropout=0.)\n # ---- optimizer, etc. ----\n self.lr = train_params[\"lr\"]\n self.sigmoid_loss = arch_gnn[\"loss\"] == \"sigmoid\"\n self.loss, self.opt_op = 0, None\n self.optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\n\n self.num_ensemble = num_ensemble","def generator():\n\n model = Sequential()\n\n in_shape = 100\n\n depth = 256\n\n model.add(Dense(depth * 7 * 7, input_shape=(in_shape,)))\n model.add(BatchNormalization(momentum=0.9)) # add the momentum\n # model.add(Activation('relu')) # pass the vector through a relu\n model.add(LeakyReLU(alpha=0.2))\n\n model.add(Reshape((7, 7, depth))) # reshape to depth number of 7x7 images\n model.add(Dropout(0.4))\n\n model.add(UpSampling2D())\n model.add(Conv2DTranspose(int(depth / 2), 5, padding='same'))\n model.add(BatchNormalization(momentum=0.9))\n # model.add(Activation('relu'))\n model.add(LeakyReLU(alpha=0.2))\n\n model.add(UpSampling2D())\n model.add(Conv2DTranspose(int(depth / 4), 5, padding='same'))\n model.add(BatchNormalization(momentum=0.9))\n # model.add(Activation('relu'))\n model.add(LeakyReLU(alpha=0.2))\n\n model.add(Conv2DTranspose(int(depth / 8), 5, padding='same'))\n model.add(BatchNormalization(momentum=0.9))\n # model.add(Activation('relu'))\n model.add(LeakyReLU(alpha=0.2))\n\n model.add(Conv2DTranspose(1, 5, padding='same'))\n model.add(Activation('sigmoid'))\n\n # model.summary()\n\n noise = Input(shape=(in_shape,))\n img = model(noise)\n\n return Model(noise, img)\n\n # return model","def create_model(input_shape=None):\n\n model = Sequential()\n #n,height,width,chennel = input_shape\n height = 146\n width = 243\n chennel = 3\n\n model.add(Conv2D(filters=4, input_shape=(width, height, chennel), kernel_size=(3, 3), padding='same'))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Conv2D(filters=4,kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Conv2D(filters=4, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=16, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\n model.add(Activation('relu'))\n model.add(Conv2D(filters=16, kernel_size=(5, 5)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Flatten())\n model.add(Dense(64))\n model.add(Activation('relu'))\n model.add(Dropout(0.25))\n model.add(Dense(32))\n model.add(Activation('relu'))\n model.add(Dropout(0.25))\n model.add(Dense(8))\n model.add(Activation('softmax'))\n\n sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.87, nesterov=True)\n model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=[\"accuracy\"])\n return model","def _build(self, generation):\n with tf.variable_scope ('discriminator') as scope:\n \n image_unflatten = unflatten_layer ( self.images )\n gen_unflatten = unflatten_layer ( generation )\n\n # Conv Layer 1 - image\n conv1_out_image, params = conv_2d_layer (\n input = image_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'conv_1_img',\n visualize = True ) \n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \n \n # Conv Layer 1 - gen\n conv1_out_gen, params = conv_2d_layer (\n input = gen_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n params = params,\n name = 'conv_1_gen',\n visualize = False )\n\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \n process_params(params, name = self.name)\n c1_params = params\n\n\n\n\n\n # Conv Layer 2 - image\n conv2_out_image, params = conv_2d_layer (\n input = lrn1_out_img,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'conv_2_img' )\n\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \n\n\n # Conv Layer 2 - gen\n conv2_out_gen, params = conv_2d_layer (\n input = lrn1_out_gen,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n params = params,\n name = 'conv_2_gen' )\n\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \n process_params(params, name = self.name)\n c2_params = params\n\n # Dropout Layer\n flat_gen = flatten_layer(lrn2_out_gen)\n flat_img = flatten_layer(lrn2_out_img)\n\n flat_gen_dropout = dropout_layer ( input = flat_gen,\n prob = self.dropout_prob,\n name = 'dropout_1_gen') \n\n flat_img_dropout = dropout_layer ( input = flat_img,\n prob = self.dropout_prob,\n name = 'dropout_1_img') \n\n\n\n # Dot Product Layer 1 -img\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\n neurons = HIDDEN_1,\n name = 'image_disc_dot_1')\n # Dot Product Layer 1 - gen\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_1')\n\n process_params(params, name = self.name)\n d1_params = params\n \n ##\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_2_gen') \n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\n prob = self.dropout_prob,\n name = 'dropout_2_img')\n\n # Dot Product Layer 2 -img\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\n neurons = HIDDEN_2,\n name = 'image_disc_dot_2')\n # Dot Product Layer 2 - gen\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_2')\n process_params(params, name = self.name)\n d2_params = params\n\n ##\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_3_gen') \n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\n prob = self.dropout_prob,\n name = 'dropout_3_img')\n\n # Dot Product Layer 1 -img\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\n neurons = 1,\n activation = 'sigmoid',\n name = 'real')\n # Dot Product Layer 1 -gen\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\n params = params,\n neurons = 1,\n activation = 'sigmoid',\n name = 'fake')\n\n process_params(params, name = self.name)\n d3_params = params\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \n\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\n 0.5 * tf.reduce_mean ((self.fake)**2)\n tf.summary.scalar('discriminator_obj', discriminator_obj)\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \n\n with tf.variable_scope (self.name + '_probabilites') as scope: \n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\n \n self._cook_optimizer( \n lr = DIS_GAN_LR, \n optimizer = DIS_GAN_OPTIMIZER,\n l1_coeff = DIS_GAN_L1_COEFF,\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)","def unet_network(input_tensor, nb_classes):\n # contraction 1\n conv1 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv1')(\n input_tensor) # (batch_size, ?, ?, 64)\n conv2 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv2')(\n conv1) # (batch_size, ?, ?, 64)\n crop2 = Cropping2D(\n cropping=((88, 88), (88, 88)),\n name=\"crop2\")(\n conv2) # (batch_size, ?, ?, 64)\n maxpool2 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool2\")(\n conv2) # (batch_size, ?, ?, 64)\n\n # contraction 2\n conv3 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv3')(\n maxpool2) # (batch_size, ?, ?, 128)\n conv4 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv4')(\n conv3) # (batch_size, ?, ?, 128)\n crop4 = Cropping2D(\n cropping=((40, 40), (40, 40)),\n name=\"crop4\")(\n conv4) # (batch_size, ?, ?, 128)\n maxpool4 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool4\")(\n conv4) # ((batch_size, ?, ?, 128)\n\n # contraction 3\n conv5 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv5')(\n maxpool4) # (batch_size, ?, ?, 256)\n conv6 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv6')(\n conv5) # (batch_size, ?, ?, 256)\n crop6 = Cropping2D(\n cropping=((16, 16), (16, 16)),\n name=\"crop6\")(\n conv6) # (batch_size, ?, ?, 256)\n maxpool6 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool6\")(\n conv6) # (batch_size, ?, ?, 256)\n\n # contraction 4\n conv7 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv7')(\n maxpool6) # (batch_size, ?, ?, 512)\n conv8 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv8')(\n conv7) # (batch_size, ?, ?, 512)\n crop8 = Cropping2D(\n cropping=((4, 4), (4, 4)),\n name=\"crop8\")(\n conv8) # (batch_size, ?, ?, 512)\n maxpool8 = MaxPooling2D(\n pool_size=(3, 3),\n strides=(2, 2),\n name=\"maxpool8\")(\n conv8) # (batch_size, ?, ?, 512)\n\n # bottom\n conv9 = Conv2D(\n filters=1024,\n kernel_size=(3, 3),\n activation='relu',\n name='conv9')(\n maxpool8) # (batch_size, ?, ?, 1024)\n conv10 = Conv2D(\n filters=1024,\n kernel_size=(3, 3),\n activation='relu',\n name='conv10')(\n conv9) # (batch_size, ?, ?, 1024)\n\n # expansion 1\n upconv11 = up_conv_2d(\n input_tensor=conv10,\n nb_filters=512,\n name='upconv11') # (batch_size, ?, ?, 512)\n concat11 = tf.concat(\n values=[crop8, upconv11],\n axis=-1,\n name='concat11') # (batch_size, ?, ?, 1024)\n conv12 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv12')(\n concat11) # (batch_size, ?, ?, 512)\n conv13 = Conv2D(\n filters=512,\n kernel_size=(3, 3),\n activation='relu',\n name='conv13')(\n conv12) # (batch_size, ?, ?, 512)\n\n # expansion 2\n upconv14 = up_conv_2d(\n input_tensor=conv13,\n nb_filters=256,\n name='upconv14') # (batch_size, ?, ?, 256)\n concat14 = tf.concat(\n values=[crop6, upconv14],\n axis=-1,\n name='concat14') # (batch_size, ?, ?, 512)\n conv15 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv15')(\n concat14) # (batch_size, ?, ?, 256)\n conv16 = Conv2D(\n filters=256,\n kernel_size=(3, 3),\n activation='relu',\n name='conv16')(\n conv15) # (batch_size, ?, ?, 256)\n\n # expansion 3\n upconv17 = up_conv_2d(\n input_tensor=conv16,\n nb_filters=128,\n name='upconv17') # (batch_size, ?, ?, 128)\n concat17 = tf.concat(\n values=[crop4, upconv17],\n axis=-1,\n name='concat17') # (batch_size, ?, ?, 256)\n conv18 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv18')(\n concat17) # (batch_size, ?, ?, 128)\n conv19 = Conv2D(\n filters=128,\n kernel_size=(3, 3),\n activation='relu',\n name='conv19')(\n conv18) # (batch_size, ?, ?, 128)\n\n # expansion 4\n upconv20 = up_conv_2d(\n input_tensor=conv19,\n nb_filters=64,\n name='upconv20') # (batch_size, ?, ?, 64)\n concat20 = tf.concat(\n values=[crop2, upconv20],\n axis=-1,\n name='concat20') # (batch_size, ?, ?, 128)\n conv21 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv21')(\n concat20) # (batch_size, ?, ?, 64)\n conv22 = Conv2D(\n filters=64,\n kernel_size=(3, 3),\n activation='relu',\n name='conv22')(\n conv21) # (batch_size, ?, ?, 64)\n conv23 = Conv2D(\n filters=nb_classes,\n kernel_size=(1, 1),\n activation='sigmoid',\n name='conv23')(\n conv22) # (batch_size, ?, ?, nb_classes)\n\n return conv23","def discriminator_block(in_filters, out_filters, normalize=True):\r\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\r\n if normalize:\r\n layers.append(nn.InstanceNorm2d(out_filters))\r\n layers.append(nn.LeakyReLU(0.2, inplace=True))\r\n return layers","def __init__(self):\n #conv1\n n = inp_width*inp_height\n #poczatkowe wagi sieci sa ustalane losowo z rozkladu normalnego. Umieszczane sa one na liscie matryc wag\n self.Weights = [np.random.randn(layers[0][1],inp_channels,layers[0][2],layers[0][2])/np.sqrt(n)]\n out_Size = inp_width - layers[0][2] + 1 #zmienna zawiera rozmiar wyjscia danej warstwy\n #inicjalizacja progow \n self.Biases = [initBias*np.ones( layers[0][1] )]\n #przypisanie parametrow warstwie poolingu\n self.poolParams = [(layers[1][1], layers[1][2])]\n out_Size = out_Size/2 \n #conv 2\n n = out_Size*out_Size*layers[0][1]\n self.Weights.append(np.random.randn(layers[2][1],layers[0][1],layers[2][2],layers[2][2])/np.sqrt(n))\n out_Size = out_Size - layers[2][2]+1\n self.Biases.append(initBias*np.ones(layers[2][1]))\n #pool 2\n self.poolParams.append((layers[3][1],layers[3][2]))\n out_Size = out_Size/2 \n #conv 3\n n = out_Size*out_Size*layers[2][1]\n self.Weights.append(np.random.randn(layers[4][1],layers[2][1],out_Size,out_Size)/np.sqrt(n))\n out_Size = 1\n self.Biases.append(initBias*np.ones(layers[4][1]))\n #fully connected 1\n n = layers[4][1]\n self.Weights.append(np.random.randn(layers[5][1],layers[4][1])/np.sqrt(n))\n self.Biases.append(initBias*np.ones(layers[5][1]))\n #fully connected 2\n n = layers[5][1]\n self.Weights.append(np.random.randn(layers[6][1],layers[5][1])/np.sqrt(n))\n self.Biases.append(initBias*np.ones(layers[6][1]))\n\n self.Weights = np.asarray(self.Weights)\n self.Biases = np.asarray(self.Biases)\n \n delta_W = []\n delta_B = []\n for i in range(5):\n delta_W.append(np.zeros(self.Weights[i].shape))\n delta_B.append(np.zeros(self.Biases[i].shape))\n self.delta_W = np.asarray(delta_W)\n self.delta_B = np.asarray(delta_B)","def __init__(\n self,\n include_top=True,\n weights='imagenet',\n input_tensor=None,\n input_shape=None,\n pooling=None,\n classes=1000,\n **kwargs):\n backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)\n self.include_top = include_top\n self.pooling = pooling\n self.weights = weights\n self.backend = backend\n self.layers = layers\n self.classes = classes\n\n if not (weights in {'imagenet', None} or os.path.exists(weights)):\n raise ValueError('The `weights` argument should be either '\n '`None` (random initialization), `imagenet` '\n '(pre-training on ImageNet), '\n 'or the path to the weights file to be loaded.')\n\n if weights == 'imagenet' and include_top and classes != 1000:\n raise ValueError('If using `weights` as `\"imagenet\"` with `include_top`'\n ' as true, `classes` should be 1000')\n self.block1_conv1 = []\n self.block1_conv2 = []\n self.block1_pool = []\n\n self.block2_conv1 = []\n self.block2_conv2 = []\n self.block2_pool = []\n\n self.block3_conv1 = []\n self.block3_conv2 = []\n self.block3_conv3 = []\n self.block3_conv4 = []\n self.block3_pool = []\n\n self.block4_conv1 = []\n self.block4_conv2 = []\n self.block4_conv3 = []\n self.block4_conv4 = []\n self.block4_pool = []\n\n self.block5_conv1 = []\n self.block5_conv2 = []\n self.block5_conv3 = []\n self.block5_conv4 = []\n self.block5_pool = []\n\n for i in xrange(FLAGS.num_replica):\n # Block 1\n self.block1_conv1.append(layers.Conv2D(64, (3, 3),\n activation='relu',\n padding='same',\n name='block1_conv1'))\n self.block1_conv2.append(layers.Conv2D(64, (3, 3),\n activation='relu',\n padding='same',\n name='block1_conv2'))\n self.block1_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool'))\n\n # Block 2\n self.block2_conv1.append(layers.Conv2D(128, (3, 3),\n activation='relu',\n padding='same',\n name='block2_conv1'))\n self.block2_conv2.append(layers.Conv2D(128, (3, 3),\n activation='relu',\n padding='same',\n name='block2_conv2'))\n self.block2_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool'))\n\n # Block 3\n self.block3_conv1.append(layers.Conv2D(256, (3, 3),\n activation='relu',\n padding='same',\n name='block3_conv1'))\n self.block3_conv2.append(layers.Conv2D(256, (3, 3),\n activation='relu',\n padding='same',\n name='block3_conv2'))\n self.block3_conv3.append(layers.Conv2D(256, (3, 3),\n activation='relu',\n padding='same',\n name='block3_conv3'))\n self.block3_conv4.append(layers.Conv2D(256, (3, 3),\n activation='relu',\n padding='same',\n name='block3_conv4'))\n self.block3_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool'))\n\n # Block 4\n self.block4_conv1.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block4_conv1'))\n self.block4_conv2.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block4_conv2'))\n self.block4_conv3.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block4_conv3'))\n self.block4_conv4.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block4_conv4'))\n self.block4_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool'))\n\n # Block 5\n self.block5_conv1.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block5_conv1'))\n self.block5_conv2.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block5_conv2'))\n self.block5_conv3.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block5_conv3'))\n self.block5_conv4.append(layers.Conv2D(512, (3, 3),\n activation='relu',\n padding='same',\n name='block5_conv4'))\n self.block5_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool'))\n\n if include_top:\n # Classification block\n self.flatten = layers.Flatten(name='flatten')\n self.fc1 = layers.Dense(4096, activation='relu', name='fc1')\n self.fc2 = layers.Dense(4096, activation='relu', name='fc2')\n self.predict = layers.Dense(classes, activation='softmax', name='predictions')\n else:\n if pooling == 'avg':\n self.pool = layers.GlobalAveragePooling2D()\n elif pooling == 'max':\n self.pool = layers.GlobalMaxPooling2D()","def inference(image, keep_prob):\r\n '''\r\n print(\"setting up vgg initialized conv layers ...\")\r\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\r\n\r\n mean = model_data['normalization'][0][0][0]\r\n mean_pixel = np.mean(mean, axis=(0, 1))\r\n\r\n weights = np.squeeze(model_data['layers'])\r\n print(\"weights.shape\",weights.shape)\r\n\r\n processed_image = utils.process_image(image, mean_pixel)'''\r\n\r\n with tf.variable_scope(\"inference\"):\r\n pooling_net,conv_final_layer = inference_op(image)\r\n #conv_final_layer = image_net[\"conv5_3\"]\r\n\r\n pool5 = utils.max_pool_2x2(conv_final_layer)\r\n\r\n W6 = utils.weight_variable([7, 7, 512, 4096], name=\"W6\")\r\n b6 = utils.bias_variable([4096], name=\"b6\")\r\n conv6 = utils.conv2d_basic(pool5, W6, b6)\r\n relu6 = tf.nn.relu(conv6, name=\"relu6\")\r\n if FLAGS.debug:\r\n utils.add_activation_summary(relu6)\r\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\r\n\r\n W7 = utils.weight_variable([1, 1, 4096, 4096], name=\"W7\")\r\n b7 = utils.bias_variable([4096], name=\"b7\")\r\n conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)\r\n relu7 = tf.nn.relu(conv7, name=\"relu7\")\r\n if FLAGS.debug:\r\n utils.add_activation_summary(relu7)\r\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\r\n\r\n W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\"W8\")\r\n b8 = utils.bias_variable([NUM_OF_CLASSESS], name=\"b8\")\r\n conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)\r\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\"prediction1\")\r\n\r\n # now to upscale to actual image size\r\n deconv_shape1 = pooling_net[\"pool4\"].get_shape()\r\n W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\"W_t1\")\r\n b_t1 = utils.bias_variable([deconv_shape1[3].value], name=\"b_t1\")\r\n # 对第8层的结果进行反卷积(上采样),通道数也由NUM_OF_CLASSESS变为第4层的通道数\r\n conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(pooling_net[\"pool4\"]))\r\n fuse_1 = tf.add(conv_t1, pooling_net[\"pool4\"], name=\"fuse_1\")\r\n\r\n deconv_shape2 = pooling_net[\"pool3\"].get_shape()\r\n W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\"W_t2\")\r\n b_t2 = utils.bias_variable([deconv_shape2[3].value], name=\"b_t2\")\r\n conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(pooling_net[\"pool3\"]))\r\n fuse_2 = tf.add(conv_t2, pooling_net[\"pool3\"], name=\"fuse_2\")\r\n\r\n shape = tf.shape(image)\r\n deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\r\n W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\"W_t3\")\r\n b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name=\"b_t3\")\r\n conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\r\n\r\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\"prediction\")\r\n print(\"annotation_pred.shape\",annotation_pred.shape)\r\n print(\"conv_t3\",conv_t3)\r\n print(\"tf.expand_dims(annotation_pred, dim=3)\",tf.expand_dims(annotation_pred, dim=3))\r\n return tf.expand_dims(annotation_pred, dim=3), conv_t3","def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\"sigmoid\"):\n\n # inizializzo il modello come sequenziale\n model = Sequential()\n inputShape = (imageHeight, imageWidth, imageDepth)\n chanDim = -1\n\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\n # Utilizzo 32 filtri 3*3\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", input_shape=inputShape))\n # con attivazione Rectified Linear Unit\n model.add(Activation(\"relu\"))\n # applico una batch normalization\n model.add(BatchNormalization(axis=chanDim))\n # un MaxPooling 3*3\n model.add(MaxPooling2D(pool_size=(3, 3)))\n # ed un 25% di dropout per ridurre overfitting\n model.add(Dropout(0.25))\n\n # Secondo blocco\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Terzo blocco\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Passo ai Fully Connected Layers\n # Trasformo il modello in un vettore\n model.add(Flatten())\n model.add(Dense(1024))\n model.add(Activation(\"sigmoid\"))\n model.add(BatchNormalization())\n model.add(Dropout(0.5))\n\n # Infine utilizzo l'attivazione per la rete\n model.add(Dense(classesNumber))\n model.add(Activation(finalAct))\n\n return model","def _init_predictor(self):\n self.conv_cls_prev = self._init_branch(\n conv_channels=self.cls_branch,\n conv_strides=(1, ) * len(self.cls_branch))\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\n 1)\n # init regression head\n self.conv_reg_prevs = nn.ModuleList()\n # init output head\n self.conv_regs = nn.ModuleList()\n # group_reg_dims:\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\n for i in range(len(self.group_reg_dims)):\n reg_dims = self.group_reg_dims[i]\n reg_branch_channels = self.reg_branch[i]\n out_channel = self.out_channels[i]\n reg_list = nn.ModuleList()\n if len(reg_branch_channels) > 0:\n self.conv_reg_prevs.append(\n self._init_branch(\n conv_channels=reg_branch_channels,\n conv_strides=(1, ) * len(reg_branch_channels)))\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\n self.conv_regs.append(reg_list)\n else:\n self.conv_reg_prevs.append(None)\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\n self.conv_regs.append(reg_list)","def __init__(self):\n super(PackageNet, self).__init__()\n \n # remove last layers of vgg19 model, save first fc layer and maxpool layer\n self.vgg = models.vgg19(pretrained=True)\n del self.vgg.classifier[2:]\n\n # get size of some layers\n start_num = self.vgg.classifier[0].out_features\n mid_num0 = int(np.sqrt(start_num))\n mid_num1 = int(start_num**0.667)\n mid_num2 = int(start_num**0.333)\n \n cls_out_num = 9 \n reg_out_num = 16 # 8 3D bounding box coords\n \n # define classifier\n self.classifier = nn.Sequential(\n nn.Linear(start_num,mid_num0,bias=True),\n nn.ReLU(),\n nn.Linear(mid_num0,cls_out_num,bias = True),\n nn.Softmax(dim = 1)\n )\n \n # define regressor\n # try relu and tanh, also try without bias\n self.regressor = nn.Sequential(\n nn.Linear(start_num,mid_num1,bias=True),\n nn.ReLU(),\n nn.Linear(mid_num1,mid_num2,bias = True),\n nn.ReLU(),\n nn.Linear(mid_num2,reg_out_num,bias = True),\n nn.Sigmoid()\n \n )","def _make_conv_layers_bn_padding(self): ## 20 Convs, used for pretrained by IMAGE Net 1000 class\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=3, bias=False), # padding=3 so, output is 224.\n nn.BatchNorm2d(64),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1, bias=False),\n nn.BatchNorm2d(192),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, bias=False), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.BatchNorm2d(128),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1, bias=False), \n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, bias=False),\n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1, bias=False), \n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, bias=False),\n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, bias=False),\n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, bias=False),\n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, bias=False),\n nn.BatchNorm2d(256),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\n nn.BatchNorm2d(512), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\n nn.BatchNorm2d(1024),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\n nn.BatchNorm2d(1024),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, bias=False),\n nn.BatchNorm2d(512),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\n nn.BatchNorm2d(1024),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def discriminator_block(in_filters, out_filters, stride, normalize):\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\n if normalize:\n layers.append(nn.BatchNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def VGG19(include_top=True, weights='imagenet',\n input_tensor=None, input_shape=None,\n pooling=None,\n classes=1000):\n if weights not in {'imagenet', None}:\n raise ValueError('The `weights` argument should be either '\n '`None` (random initialization) or `imagenet` '\n '(pre-training on ImageNet).')\n\n if weights == 'imagenet' and include_top and classes != 1000:\n raise ValueError('If using `weights` as imagenet with `include_top`'\n ' as true, `classes` should be 1000')\n # Determine proper input shape\n\n\n img_input = input_tensor\n # Block 1\n x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)\n x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)\n\n # Block 2\n x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)\n x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)\n\n # Block 3\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv4')(x)\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)\n\n # Block 4\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv4')(x)\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)\n\n # Block 5\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv4')(x)\n\n model = Model(img_input, x, name='vgg19')\n\n if weights == 'imagenet':\n if include_top:\n weights_path = get_file('vgg19_weights_tf_dim_ordering_tf_kernels.h5',\n WEIGHTS_PATH,\n cache_subdir='models',\n file_hash='cbe5617147190e668d6c5d5026f83318')\n else:\n weights_path = get_file('vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5',\n WEIGHTS_PATH_NO_TOP,\n cache_subdir='models',\n file_hash='253f8cb515780f3b799900260a226db6')\n model.load_weights(weights_path)\n\n return model","def densenet121(growth_rate=32, compression=1.0):\n\n kernel_init = K.initializers.he_normal(seed=None)\n\n X = K.Input(shape=(224, 224, 3))\n batchNorm0 = K.layers.BatchNormalization(axis=3)(X)\n activation0 = K.layers.Activation('relu')(batchNorm0)\n\n layer1 = K.layers.Conv2D(filters=2*growth_rate, kernel_size=(7, 7),\n strides=(2, 2), padding='same',\n kernel_initializer=kernel_init)(activation0)\n l1pool = K.layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2),\n padding='same')(layer1)\n\n layer2, n_f2 = dense_block(l1pool, 2*growth_rate, growth_rate, 6)\n layer3, n_f3 = transition_layer(layer2, n_f2, compression)\n layer4, n_f4 = dense_block(layer3, n_f3, growth_rate, 12)\n layer5, n_f5 = transition_layer(layer4, n_f4, compression)\n layer6, n_f6 = dense_block(layer5, n_f5, growth_rate, 24)\n layer7, n_f7 = transition_layer(layer6, n_f6, compression)\n layer8, n_f8 = dense_block(layer7, n_f7, growth_rate, 16)\n\n avg_pool = K.layers.AveragePooling2D(pool_size=(7, 7), strides=7,\n padding='same')(layer8)\n\n Y = K.layers.Dense(1000, activation='softmax',\n kernel_initializer=kernel_init)(avg_pool)\n\n model = K.models.Model(inputs=X, outputs=Y)\n\n return model","def discriminator_block(in_filters, out_filters, stride, normalize):\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\n if normalize:\n layers.append(nn.InstanceNorm2d(out_filters))\n layers.append(nn.LeakyReLU(0.2, inplace=True))\n return layers","def faceRecoModel(input_shape):\n\t# Define the input as a tensor with shape input_shape\n\tX_input = Input(input_shape)\n\t# Zero-Padding\n\tX = ZeroPadding2D((3, 3))(X_input)\n\t# First Block\n\tX = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1')(X)\n\tX = BatchNormalization(axis = 1, name = 'bn1')(X)\n\tX = Activation('relu')(X)\n\t# Zero-Padding + MAXPOOL\n\tX = ZeroPadding2D((1, 1))(X)\n\tX = MaxPooling2D((3, 3), strides = 2)(X)\n\t# Second Block\n\tX = Conv2D(64, (1, 1), strides = (1, 1), name = 'conv2')(X)\n\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn2')(X)\n\tX = Activation('relu')(X)\n\t# Zero-Padding + MAXPOOL\n\tX = ZeroPadding2D((1, 1))(X)\n\t# Second Block\n\tX = Conv2D(192, (3, 3), strides = (1, 1), name = 'conv3')(X)\n\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn3')(X)\n\tX = Activation('relu')(X)\n\t# Zero-Padding + MAXPOOL\n\tX = ZeroPadding2D((1, 1))(X)\n\tX = MaxPooling2D(pool_size = 3, strides = 2)(X)\n\t# Inception 1: a/b/c\n\t# X = inception_block_1a(X)\n\t# X = inception_block_1b(X)\n\t# X = inception_block_1c(X)\n\t# # Inception 2: a/b\n\t# X = inception_block_2a(X)\n\t# X = inception_block_2b(X)\n\t# # Inception 3: a/b\n\t# X = inception_block_3a(X)\n\t# X = inception_block_3b(X)\n\t# Top layer\n\tX = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\n\tX = Flatten()(X)\n\tX = Dense(10, name='dense_layer')(X)\n\t# L2 normalization\n\tX = Lambda(lambda x: K.l2_normalize(x,axis=1))(X)\n\t# Create model instance\n\tmodel = Model(inputs = X_input, outputs = X, name='FaceRecoModel')\n\treturn model","def inception_network():\n X = K.Input(shape=(224, 224, 3))\n initializer = K.initializers.he_normal(seed=None)\n conv_1 = K.layers.Conv2D(filters=64, kernel_size=7,\n padding='same', strides=2,\n kernel_initializer=initializer,\n activation='relu')(X)\n max_pool_1 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(conv_1)\n\n conv_2 = K.layers.Conv2D(filters=64, padding='same',\n kernel_size=1, activation='relu',\n kernel_initializer=initializer)(max_pool_1)\n conv2_1 = K.layers.Conv2D(filters=192, padding='same',\n kernel_size=3, activation='relu',\n kernel_initializer=initializer)(conv_2)\n max_pool_2 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(conv2_1)\n\n incep_3a = inception_block(max_pool_2, [64, 96, 128, 16, 32, 32])\n incep_3b = inception_block(incep_3a, [128, 128, 192, 32, 96, 64])\n max_pool_3 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(incep_3b)\n\n incep_4a = inception_block(max_pool_3, [192, 96, 208, 16, 48, 64])\n incep_4b = inception_block(incep_4a, [160, 112, 224, 24, 64, 64])\n incep_4c = inception_block(incep_4b, [128, 128, 256, 24, 64, 64])\n incep_4d = inception_block(incep_4c, [112, 144, 288, 32, 64, 64])\n incep_4e = inception_block(incep_4d, [256, 160, 320, 32, 128, 128])\n max_pool_4 = K.layers.MaxPooling2D(pool_size=3, strides=2,\n padding='same')(incep_4e)\n\n incep_5a = inception_block(max_pool_4, [256, 160, 320, 32, 128, 128])\n incep_5b = inception_block(incep_5a, [384, 192, 384, 48, 128, 128])\n avg_pool = K.layers.AveragePooling2D(pool_size=7, strides=None)(incep_5b)\n\n drop_out = K.layers.Dropout(0.4)(avg_pool)\n dense = K.layers.Dense(units=1000, activation='softmax',\n kernel_initializer=initializer)(drop_out)\n return K.models.Model(inputs=X, outputs=dense)","def __init__(self):\n torch.nn.Module.__init__(self)\n ######################### Convolution and pooling layers of VGG-16.\n self.features = torchvision.models.vgg16(pretrained=True).features # fine tune?\n self.features = torch.nn.Sequential(*list(self.features.children())\n [:-22]) # Remove pool2 and rest, lack of computational resource\n # No grad for convVGG\n # for param in self.features.parameters():\n # param.requires_grad = False\n\n #################### Channel Grouping Net\n # self.fc1_ = torch.nn.Linear(128, 128*16)#lack of resource\n # self.fc2_ = torch.nn.Linear(128, 128*16)\n # self.fc3_ = torch.nn.Linear(128, 128*16)\n #\n # torch.nn.init.kaiming_normal_(self.fc1_.weight.data, nonlinearity='relu')\n # if self.fc1_.bias is not None:\n # torch.nn.init.constant_(self.fc1_.bias.data, val=0) # fc层的bias进行constant初始化\n # torch.nn.init.kaiming_normal_(self.fc2_.weight.data, nonlinearity='relu')\n # if self.fc2_.bias is not None:\n # torch.nn.init.constant_(self.fc2_.bias.data, val=0) # fc层的bias进行constant初始化\n # torch.nn.init.kaiming_normal_(self.fc3_.weight.data, nonlinearity='relu')\n # if self.fc3_.bias is not None:\n # torch.nn.init.constant_(self.fc3_.bias.data, val=0) # fc层的bias进行constant初始化\n\n self.fc1 = torch.nn.Linear(128*28*28, 128)\n self.fc2 = torch.nn.Linear(128*28*28, 128)\n self.fc3 = torch.nn.Linear(128*28*28, 128)\n\n\n torch.nn.init.kaiming_normal_(self.fc1.weight.data, nonlinearity='relu')\n if self.fc1.bias is not None:\n torch.nn.init.constant_(self.fc1.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.fc2.weight.data, nonlinearity='relu')\n if self.fc2.bias is not None:\n torch.nn.init.constant_(self.fc2.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.fc3.weight.data, nonlinearity='relu')\n if self.fc3.bias is not None:\n torch.nn.init.constant_(self.fc3.bias.data, val=0) # fc层的bias进行constant初始化\n\n self.layerNorm=nn.LayerNorm([224,224])\n\n # global grad for hook\n self.image_reconstruction = None\n self.register_hooks()\n self.GradWeight=1e-1\n\n # ################### STN input N*3*448*448\n # self.localization = [\n # nn.Sequential(\n # nn.MaxPool2d(4,stride=4),#112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5,stride=1,padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3,stride=1,padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) #output 64*14*14\n # ).cuda(),\n # nn.Sequential(\n # nn.MaxPool2d(4, stride=4), # 112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) # output 64*14*14\n # ).cuda(),\n # nn.Sequential(\n # nn.MaxPool2d(4, stride=4), # 112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) # output 64*14*14\n # ).cuda()\n # ]\n # # Regressor for the 3 * 2 affine matrix\n # self.fc_loc = [\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda(),\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda(),\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda()\n # ]\n # # Initialize the weights/bias with identity transformation\n # for fc_locx in self.fc_loc:\n # fc_locx[2].weight.data.zero_()\n # fc_locx[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\n\n ########################Bilinear CNN output 256 channels\n self.bcnnConv_1=torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n self.bcnnConv_2 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n self.bcnnConv_3 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n #BCNN Linear classifier.\n self.bfc1 = torch.nn.Linear(512*512, 200)\n self.bfc2 = torch.nn.Linear(512*512, 200)\n self.bfc3 = torch.nn.Linear(512*512, 200)\n torch.nn.init.kaiming_normal_(self.bfc1.weight.data) # 何凯明初始化\n if self.bfc1.bias is not None:\n torch.nn.init.constant_(self.bfc1.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.bfc2.weight.data) # 何凯明初始化\n if self.bfc2.bias is not None:\n torch.nn.init.constant_(self.bfc2.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.bfc3.weight.data) # 何凯明初始化\n if self.bfc3.bias is not None:\n torch.nn.init.constant_(self.bfc3.bias.data, val=0) # fc层的bias进行constant初始化\n\n # self.CBP1 = CompactBilinearPooling(512, 512, 50000)\n # self.CBP2 = CompactBilinearPooling(512, 512, 50000)\n # self.CBP3 = CompactBilinearPooling(512, 512, 50000)","def __init__(self, in_channels, out_channels, kernel_size,\n stride=1, padding=0, dilation=1, groups=1, bias=True):\n super(BatchConv2D_5D, self).__init__()\n self.out_channels = out_channels\n self.conv = nn.Conv2d(in_channels*groups, out_channels*groups,\n kernel_size, stride=stride,\n padding=padding, dilation=dilation,\n groups=groups, bias=bias)","def inference_deep_pyramid_cnn(self):\n #1.region embedding\n embedding_documents=self.region_embedding() #shape:[batch_size,total_sequence_length,embedding_size]\n\n #2.two layers of convs\n embedding_documents = tf.expand_dims(embedding_documents ,-1) # [batch_size,total_sequence_length,embed_size,1). expand dimension so meet input requirement of 2d-conv\n conv=self.dpcnn_two_layers_conv(embedding_documents,double_num_filters=False) #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\n #skip connection: add and activation\n conv=conv+embedding_documents #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\n b = tf.get_variable(\"b-inference\", [self.hpcnn_number_filters])\n print(\"conv:\",conv,\";b:\",b)\n conv = tf.nn.relu(tf.nn.bias_add(conv, b),\"relu-inference\") #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\n\n #3. repeat of building blocks\n for i in range(self.num_repeat):\n conv=self.dpcnn_pooling_two_conv(conv,i) #shape:[batch_size,total_sequence_length/np.power(2,i),hpcnn_number_filters]\n\n #4. max pooling\n seq_length1=conv.get_shape().as_list()[1] #sequence length after multiple layers of conv and pooling\n seq_length2=conv.get_shape().as_list()[2] #sequence length after multiple layers of conv and pooling\n print(\"before.final.pooling:\",conv)\n pooling=tf.nn.max_pool(conv, ksize=[1,seq_length1,seq_length2,1], strides=[1,1,1,1], padding='VALID',name=\"pool\") #[batch_size,hpcnn_number_filters]\n pooling=tf.squeeze(pooling)\n print(\"pooling.final:\",pooling)\n\n #5. classifier\n\n return pooling","def densenet121(growth_rate=32, compression=1.0):\n inputs = K.Input(shape=(224, 224, 3))\n out_l = K.layers.BatchNormalization(axis=3)(inputs)\n out_l = K.layers.Activation('relu')(out_l)\n out_l = K.layers.Conv2D(64, kernel_size=(7, 7), padding='same',\n kernel_initializer='he_normal',\n strides=(2, 2))(out_l)\n out_l = K.layers.MaxPool2D((3, 3), (2, 2), padding=\"same\")(out_l)\n out_l, filters = dense_block(out_l, 64, growth_rate, 6)\n out_l, filters = transition_layer(out_l, filters, compression)\n out_l, filters = dense_block(out_l, filters, growth_rate, 12)\n out_l, filters = transition_layer(out_l, filters, compression)\n out_l, filters = dense_block(out_l, filters, growth_rate, 24)\n out_l, filters = transition_layer(out_l, filters, compression)\n out_l, filters = dense_block(out_l, filters, growth_rate, 16)\n out_l = K.layers.AvgPool2D((7, 7), padding='same')(out_l)\n out_l = K.layers.Dense(1000, activation='softmax')(out_l)\n model = K.Model(inputs, out_l)\n return model","def densenet121(growth_rate=32, compression=1.0):\n X_input = K.Input(shape=(224, 224, 3))\n initializer = K.initializers.he_normal(seed=None)\n\n batch1 = K.layers.BatchNormalization()(X_input)\n activation1 = K.layers.Activation('relu')(batch1)\n conv1 = K.layers.Conv2D(64, kernel_size=(7, 7), strides=2,\n padding='same',\n kernel_initializer=initializer)(activation1)\n max_pool = K.layers.MaxPooling2D(pool_size=(3, 3),\n strides=2, padding='same')(conv1)\n X, nb_filters = dense_block(max_pool, 64, growth_rate, 6)\n X, nb_filters = transition_layer(X, nb_filters, compression)\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 12)\n X, nb_filters = transition_layer(X, nb_filters, compression)\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 24)\n X, nb_filters = transition_layer(X, nb_filters, compression)\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 16)\n\n avg_pool = K.layers.AveragePooling2D(pool_size=(7, 7), strides=None,\n padding='same')(X)\n\n dense = K.layers.Dense(1000, activation='softmax',\n kernel_initializer=initializer)(avg_pool)\n model = K.models.Model(inputs=X_input, outputs=dense)\n\n return model","def build_discriminator2D(self, model_shape, filters=32, k_size=4, drop=False, rate=0.5, extra_conv=False, summary=False, ln=False, model_file=None, name='gan_d_'):\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 Create a Discriminator Model using hyperparameters values defined as follows\n \"\"\"\n n_rows = model_shape[0]\n n_cols = model_shape[1]\n c_dims = model_shape[2]\n\n input_shape = (n_rows, n_cols, c_dims) \n input_layer = Input(shape=input_shape, name=name+'input')\n\n d = self.Conv2D_Block(input_layer, filters, k_size=k_size, name=name+'1', bn=False) # 30x30x32\n d = self.Conv2D_Block(d, 2*filters, k_size=k_size, ln=ln, name=name+'2') # 15x15x64\n d = self.Conv2D_Block(d, 4*filters, k_size=k_size, ln=ln, name=name+'3') # 8x8x128\n if extra_conv:\n d = self.Conv2D_Block(d, 8*filters, strides=2, k_size=k_size, ln=ln, name=name+'4') # 8x8x256 \n d = self.Conv2D_Block(d, 16*filters, strides=1, k_size=k_size, ln=ln, name=name+'5') # 8x8x256\n else:\n d = self.Conv2D_Block(d, 8*filters, strides=1, k_size=k_size, ln=ln, name=name+'4')\n\n d = Flatten(name=name+'flatten')(d)\n if drop:\n d = Dropout(rate=rate, name=name+'dropout')(d, training=True)\n logits = Dense(1, activation='linear', kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(d)\n out = Activation('sigmoid', name=name+'sigmoid')(logits)\n\n model = Model(inputs=[input_layer], outputs=[out, logits], name='Discriminator')\n if (summary):\n model.summary()\n return model","def __init__(self, img_rows=400, img_cols=400, vgg_weights=\"imagenet\", inference_only=False, net_name='default', gpus=1, vgg_device=None):\n \n # Settings\n self.img_rows = img_rows\n self.img_cols = img_cols\n self.img_overlap = 30\n self.inference_only = inference_only\n self.net_name = net_name\n self.gpus = gpus\n self.vgg_device = vgg_device\n\n # Scaling for VGG input\n self.mean = [0.485, 0.456, 0.406]\n self.std = [0.229, 0.224, 0.225]\n \n #get PowerSpect_CMB\n reader = np.zeros((2507,))\n fp = open('./data/COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt')\n \n for i,line in enumerate(fp):\n if i >= 1:\n reader[i-1] = line.split()[1]\n \n fp.close() \n readers = np.log(reader)\n self.cl = K.constant(readers)\n # Assertions\n assert self.img_rows >= 256, 'Height must be >256 pixels'\n assert self.img_cols >= 256, 'Width must be >256 pixels'\n\n # Set current epoch\n self.current_epoch = 0\n \n # VGG layers to extract features from (first maxpooling layers, see pp. 7 of paper)\n self.vgg_layers = [3, 6, 10]\n\n # Instantiate the vgg network\n if self.vgg_device:\n with tf.device(self.vgg_device):\n self.vgg = self.build_vgg(vgg_weights)\n else:\n self.vgg = self.build_vgg(vgg_weights)\n \n # Create UNet-like model\n if self.gpus <= 1:\n self.model, inputs_mask= self.build_pconv_unet()\n self.compile_pconv_unet(self.model, inputs_mask) \n else:\n with tf.device(\"/cpu:0\"):\n self.model, inputs_mask = self.build_pconv_unet()\n self.model = multi_gpu_model(self.model, gpus=self.gpus)\n self.compile_pconv_unet(self.model, inputs_mask)","def count_model(input_shape):\n kernel_size = (3, 3)\n pool_size = (2, 2)\n first_filters = 32\n second_filters = 64\n third_filters = 128\n dropout_conv = 0.3\n\n model = Sequential()\n\n model.add(Conv2D(first_filters, kernel_size, activation='relu',\n input_shape=input_shape))\n\n model.add(ZeroPadding2D(padding=(3, 3), data_format=None))\n\n model.add(Conv2D(first_filters, kernel_size, activation='relu'))\n model.add(Conv2D(first_filters, kernel_size, activation='relu'))\n model.add(MaxPooling2D(pool_size=pool_size))\n model.add(Dropout(dropout_conv))\n\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\n model.add(MaxPooling2D(pool_size=pool_size))\n model.add(Dropout(dropout_conv))\n\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(MaxPooling2D(pool_size=pool_size))\n model.add(Dropout(dropout_conv))\n\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\n model.add(MaxPooling2D(pool_size=pool_size))\n model.add(Dropout(dropout_conv))\n\n model.add(Flatten())\n\n model.add(Dense(1024))\n model.add(LeakyReLU())\n model.add(BatchNormalization())\n\n model.add(Dense(512))\n model.add(LeakyReLU())\n model.add(BatchNormalization())\n\n # set activation='relu' to keep all values positive\n model.add(Dense(1, activation='relu'))\n\n return model","def __init__(self, in_channels, out_channels, group=1):\n super(Block, self).__init__()\n if group == 1:\n self.b1 = RB(in_channels, out_channels, activation='relu')\n self.b2 = RB(out_channels, out_channels, activation='relu')\n self.b3 = RB(out_channels, out_channels, activation='relu')\n elif group > 1:\n self.b1 = EResidualBlock(64, 64, group=group)\n self.b2 = self.b3 = self.b1\n self.c1 = EasyConv2d(in_channels + out_channels, out_channels, 1, activation='relu')\n self.c2 = EasyConv2d(in_channels + out_channels * 2, out_channels, 1, activation='relu')\n self.c3 = EasyConv2d(in_channels + out_channels * 3, out_channels, 1, activation='relu')","def target(total_epoch, filter_num, filter_len, num_dense_nodes):\n \n start = time.time()\n total_epoch = int(round(total_epoch))\n filter_num = int(round(filter_num))\n filter_len = int(round(filter_len))\n num_dense_nodes = int(round(num_dense_nodes))\n print(\"Epochs =\", total_epoch, \"| # Conv filters =\", filter_num, \"| Filter length =\", filter_len, \"| # Dense nodes =\", num_dense_nodes)\n\n # model specification\n model = Sequential()\n model.add(Convolution1D(input_dim=4, input_length=dna_bp_length, nb_filter=filter_num, filter_length=filter_len, activation=\"relu\", border_mode =\"same\"))\n model.add(MaxPooling1D(pool_length=dna_bp_length))\n model.add(Flatten())\n model.add(BatchNormalization())\n model.add(Dense(input_dim=filter_num,output_dim=num_dense_nodes))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization())\n model.add(Dense(output_dim=num_classes))\n model.add(Activation(\"softmax\"))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[\"accuracy\"])\n print(model.summary())\n \n max_val_acc = 0.0\n max_acc_pair = 0.0\n num_chunks = 6 \n \n epoch_train_acc = np.zeros((total_epoch,num_chunks))\n epoch_val_acc = np.zeros((total_epoch,1))\n\n # train the model\n for e in range(total_epoch):\n print(\"Epoch =\", e+1, \"out of\", total_epoch)\n for f in range(num_chunks-1):\n X_train = np.load(\"/mnt/data\"+str(f)+\".npy\")\n y_train = np.load(\"/mnt/labels\"+str(f)+\".npy\")\n history = model.fit(X_train, y_train, batch_size = 8, \\\n validation_split=0.0, nb_epoch=1, verbose=1, class_weight=cl_weight)\n epoch_train_acc[e,f] = history.history['acc'][0]\n \n # train final chunk and do validation\n X_train = np.load(\"/mnt/data\"+str(num_chunks-1)+\".npy\")\n y_train = np.load(\"/mnt/labels\"+str(num_chunks-1)+\".npy\")\n history = model.fit(X_train, y_train, batch_size = 8, \\\n validation_data=(val_dna_seqs_onehot, val_pi_labels_onehot), nb_epoch=1, verbose=1, class_weight=cl_weight)\n epoch_train_acc[e,num_chunks-1] = history.history['acc'][0]\n epoch_val_acc[e,0] = history.history['val_acc'][0]\n\n # record max validation accuracy\n if history.history['val_acc'][0] > max_val_acc:\n max_val_acc = history.history['val_acc'][0]\n max_acc_pair = history.history['acc'][0]\n \n # save network stats\n print(\"Epoch training accuracy\")\n print(epoch_train_acc)\n print(\"Mean epoch training accuracy\")\n print(np.transpose(np.mean(epoch_train_acc, axis=1)))\n end = time.time()\n np.save(str(int(end))+'conv'+str(filter_num)+'x'+str(filter_len)+'dense'+str(num_dense_nodes)+'time'+str(int(end-start))+'_mean_train_acc.out', np.transpose(np.mean(epoch_train_acc, axis=1)))\n print(\"Epoch validation accuracy\" )\n print(epoch_val_acc)\n np.save(str(int(end))+'conv'+str(filter_num)+'x'+str(filter_len)+'dense'+str(num_dense_nodes)+'time'+str(int(end-start))+'_epoch_val_acc.out', epoch_val_acc, end-start)\n \n return max_val_acc/(end-start)","def dense_block(x, nb_layers, nb_filter, growth_rate, dropout_rate=None, weight_decay=1E-4):\n\n concat_axis = 1 if K.image_dim_ordering() == \"th\" else -1\n\n feature_list = [x]\n\n for i in range(nb_layers):\n x = conv_block(x, growth_rate, dropout_rate, weight_decay)\n feature_list.append(x)\n x = Concatenate(axis=concat_axis)(feature_list)\n nb_filter += growth_rate\n\n return x, nb_filter","def __init__(self, input_dim, hidden_dim_1, hidden_dim_2):\n super(BinaryGraphClassifier, self).__init__()\n\n # Define the graph convolutional layers\n self.conv_1 = DenseSAGEConv(in_feats=input_dim, out_feats=hidden_dim_1)\n self.conv_2 = DenseSAGEConv(in_feats=hidden_dim_1, out_feats=hidden_dim_2)\n\n # Define the fully connected layers\n self.fc_1 = nn.Linear(hidden_dim_2, hidden_dim_2)\n self.fc_2 = nn.Linear(hidden_dim_2, 1)\n\n # Drop out layers\n self.conv_dropout_1 = nn.Dropout(p=0.4)\n self.conv_dropout_2 = nn.Dropout(p=0.4)\n self.fc_dropout = nn.Dropout(p=0.4)\n\n # The output activation function\n self.output_func = nn.Sigmoid()","def __init__(self, input_dim=(3,32,32), num_filters=[32], hidden_layers=[100], \r\n num_classes=10 ,filter_size=7, weight_scale=1e-3, reg=0, dropout=0, \r\n use_batch_norm=False, dtype=np.float32):\r\n self.params={}\r\n self.use_dropout = dropout > 0\r\n self.use_batch_norm = use_batch_norm\r\n self.conv_params = {'stride': 1, 'pad': (filter_size - 1) // 2}\r\n self.pool_params = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\r\n self.num_conv_layers = len(num_filters)\r\n self.num_hidden_layers = len(hidden_layers)\r\n self.bn_params = []\r\n self.dropout_params = []\r\n self.reg = reg\r\n\r\n # Initialize batch normalization parameters if necessary.\r\n num_layers = self.num_conv_layers + self.num_hidden_layers\r\n if self.use_batch_norm:\r\n for i in range(num_layers):\r\n self.bn_params.append({'mode':'train'})\r\n # Initialize dropout parameters if necessary\r\n if self.use_dropout:\r\n self.dropout_params = {'mode':'trian', 'p':dropout}\r\n\r\n C, H, W = input_dim\r\n channels, HH, WW = C, H, W\r\n # Initialize the parameters for the Convolutional network.\r\n for i in range(1, self.num_conv_layers+1):\r\n self.params['W{}'.format(i)] = np.random.randn(num_filters[i-1], \r\n channels, filter_size, \r\n filter_size) * weight_scale\r\n self.params['b{}'.format(i)] = np.zeros(num_filters[i-1])\r\n # Keeping track of the Height and Width of the image as we convolve\r\n # it through multiple layers. After pooling make sure the dimensions\r\n # make sense\r\n if (HH <= self.pool_params['pool_height']):\r\n raise Exception('The pool height and input height are equal'.\\\r\n format(self.pool_params['pool_height'], HH))\r\n else:\r\n HH = (HH - self.pool_params['pool_height']) / self.pool_params['stride'] + 1\r\n if (WW <= self.pool_params['pool_width']):\r\n raise Exception('The pool width and input width are equal'.\\\r\n format(self.params['pool_width'], WW))\r\n else:\r\n WW = (WW - self.pool_params['pool_width']) / self.pool_params['stride'] + 1\r\n\r\n\r\n # Updating the number of channels for the new input.\r\n channels = num_filters[i-1]\r\n # Initialize the parameters for the batch normalization if necessary.\r\n if self.use_batch_norm:\r\n self.params['gamma{}'.format(i)] = np.ones(channels)\r\n self.params['beta{}'.format(i)] = np.zeros(channels)\r\n\r\n # Initialize the parameters for the fully connected network.\r\n fc_input_dim = np.prod((HH, WW, channels))\r\n for i in range(1, self.num_hidden_layers+1):\r\n self.params['W{}'.format(i+self.num_conv_layers)] = np.random.randn(fc_input_dim, \r\n hidden_layers[i-1]) * weight_scale\r\n self.params['b{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\r\n # Initialize the parameters for batch normalization if necessary.\r\n if self.use_batch_norm:\r\n self.params['gamma{}'.format(i+self.num_conv_layers)] = np.ones(hidden_layers[i-1])\r\n self.params['beta{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\r\n fc_input_dim = hidden_layers[i-1]\r\n\r\n # Initialize the parameters for the last layer of the fully connected network.\r\n self.params['W{}'.format(i+self.num_conv_layers+1)] = np.random.randn(hidden_layers[i-1],\r\n num_classes) * weight_scale\r\n self.params['b{}'.format(i+self.num_conv_layers+1)] = np.zeros(num_classes)\r\n\r\n # Convert the dtype for the parameters of the model.\r\n for k, v in self.params.items():\r\n self.params[k] = v.astype(dtype)","def get_unet2(patch_height, patch_width, channels, n_classes):\n axis = 3\n k = 3 # kernel size 卷积核大小\n s = 2 # stride 步长\n n_filters = 32 # number of filters 通道数\n\n #初始化keras张量\n inputs = Input((patch_height, patch_width, channels))\n\n # n_filters：输出的维度 （k，k）：卷积核尺寸 padding：边缘填充\n # 400,400,3 ==> 400,400,32\n conv1 = Conv2D(n_filters, (k,k), padding='same')(inputs)\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\n conv1 = Activation('relu')(conv1)\n conv1 = Conv2D(n_filters, (k, k), padding='same')(conv1)\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\n conv1 = Activation('relu')(conv1)\n # 400,400,32 ==> 200,200,32\n pool1 = MaxPooling2D(pool_size=(s,s))(conv1)\n\n # DenseBlock模块 200,200,32 ==> 200,200,32\n conv2 = Conv2D(n_filters, (1,1), padding='same')(pool1)\n # battleneck层 第一层Dense\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\n conv2 = Activation('relu')(conv2)\n conv2 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv2)\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\n conv2 = Activation('relu')(conv2)\n conv2 = Conv2D(n_filters,(k,k),padding='same')(conv2)\n # 200,200,32 ==> 200,200,64\n x1 = Concatenate(axis=axis)([conv2,pool1])\n\n # Transition层\n ts = Conv2D(n_filters * 4, (1, 1), padding='same')(x1)\n # 200,200,64 ==> 100,100,64 #将pool2 看成 x1\n pool2 = AveragePooling2D(pool_size=(s, s), strides=2)(ts)\n\n conv3 = Conv2D(n_filters,(1,1),padding='same')(pool2)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = Activation('relu')(conv3)\n conv3 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv3)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = Activation('relu')(conv3)\n conv3 = Conv2D(n_filters, (k, k), padding='same')(conv3)\n # 100,100,32 ==> 100,100,96\n tmp2 = Concatenate(axis=axis)([conv3,pool2])\n\n conv3 = Conv2D(n_filters, (1, 1), padding='same')(tmp2)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = Activation('relu')(conv3)\n conv3 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv3)\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\n conv3 = Activation('relu')(conv3)\n conv3 = Conv2D(n_filters, (k, k), padding='same')(conv3)\n # 100,100,32 ==> 100,100,128\n x2 = Concatenate(axis=axis)([conv3, tmp2])\n\n # Transition层\n ts1 = Conv2D(n_filters * 4,(1,1),padding='same')(x2)\n # 100,100,128 ==> 50,50,128\n pool2 = AveragePooling2D(pool_size=(s,s),strides=2)(ts1)\n\n # 50,50,128 ==> 50,50,32\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(pool2)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\n # 50,50,32 ==> 50,50,160\n tmp3 = Concatenate(axis=axis)([conv4,pool2])\n\n # 50,50,160 ==> 50,50,32\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp3)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\n # 50,50,32 ==> 50,50,192\n tmp4 = Concatenate(axis=axis)([conv4, tmp3])\n\n # 50,50,192 ==> 50,50,32\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\n # 50,50,32 ==> 50,50,224\n tmp5 = Concatenate(axis=axis)([conv4, tmp4])\n\n # 50,50,224 ==> 50,50,32\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp5)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\n conv4 = Activation('relu')(conv4)\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\n # 50,50,32 ==> 50,50,256\n x3 = Concatenate(axis=axis)([conv4, tmp5])\n\n ts2 = Conv2D(n_filters * 8, (1, 1), padding='same')(x3)\n # 50,50,256 ==> 25,25,256\n pool3 = AveragePooling2D(pool_size=(s, s), strides=2)(ts2)\n\n # 25,25,256 ==> 25,25,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(pool3)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 25,25,32 ==> 25,25,288\n tmp6 = Concatenate(axis=axis)([conv5, pool3])\n\n # 50,50,288 ==> 50,50,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp6)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,320\n tmp7 = Concatenate(axis=axis)([conv5, tmp6])\n\n # 50,50,288 ==> 50,50,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp7)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,352\n tmp8 = Concatenate(axis=axis)([conv5, tmp7])\n\n # 50,50,352 ==> 50,50,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp8)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,384\n tmp9 = Concatenate(axis=axis)([conv5, tmp8])\n\n # 50,50,352 ==> 50,50,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp9)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,416\n tmp10 = Concatenate(axis=axis)([conv5, tmp9])\n\n # 50,50,352 ==> 50,50,32\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp10)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,448\n tmp11 = Concatenate(axis=axis)([conv5, tmp10])\n\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp11)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 50,50,32 ==> 50,50,480\n tmp12 = Concatenate(axis=axis)([conv5, tmp11])\n\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp12)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\n conv5 = Activation('relu')(conv5)\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\n # 25,25,32 ==> 25,25,512\n conv5 = Concatenate(axis=axis)([conv5, tmp12])\n\n #先上采样放大 在进行卷积操作 相当于转置卷积 并进行拼接\n # 25,25,512 ==> 50,50,768\n up1 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv5), x3])\n conv6 = Conv2D(8 * n_filters, (k,k), padding='same')(up1)\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\n conv6 = Activation('relu')(conv6)\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(conv6)\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\n conv6 = Activation('relu')(conv6)\n\n #50,50,768 ==> 100,100,896\n up2 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv6), x2])\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(up2)\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\n conv7 = Activation('relu')(conv7)\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(conv7)\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\n conv7 = Activation('relu')(conv7)\n\n # 100,100,896 ==> 200,200,960\n up3 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv7), x1])\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(up3)\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\n conv8 = Activation('relu')(conv8)\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(conv8)\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\n conv8 = Activation('relu')(conv8)\n\n # 200,200,960 ==> 400,400,992\n up4 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv8), conv1])\n conv9 = Conv2D(n_filters, (k, k), padding='same')(up4)\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\n conv9 = Activation('relu')(conv9)\n conv9 = Conv2D(n_filters, (k, k), padding='same')(conv9)\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\n conv9 = Activation('relu')(conv9)\n\n # 全连接层 400,400,992 ==> 400,400,5\n outputs = Conv2D(n_classes, (1,1), padding='same', activation='softmax')(conv9)\n\n unet = Model(inputs=inputs, outputs=outputs)\n\n return unet"],"string":"[\n \"def discriminator_block(in_filters, out_filters):\\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\\n nn.LeakyReLU(0.01)]\\n return layers\",\n \"def build_bisenet(inputs, num_classes):\\n\\n ### The spatial path\\n ### The number of feature maps for each convolution is not specified in the paper\\n ### It was chosen here to be equal to the number of feature maps of a classification\\n ### model at each corresponding stage\\n # spatial_net = fluid.layers.resize_bilinear(inputs, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_1',spatial_net)\\n\\n ## spatial path\\n spatial_net = ConvBlock(inputs, num_filters=64, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=128, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=256, kernel_size=3, stride=2)\\n # print(\\\"spatial_net:\\\", spatial_net)\\n\\n # spatial_net = fluid.layers.resize_bilinear(spatial_net, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_2',spatial_net)\\n ### Context path\\n model = ResNet(is_test=False)\\n # spatial_net = model.bottleneck_block1(inputs)\\n end_points_16, end_points_32 = model.net(inputs)\\n net_4 = AttentionRefinementModule(end_points_16, num_filters=512)\\n net_5 = AttentionRefinementModule(end_points_32, num_filters=1024)\\n global_channels = fluid.layers.reduce_mean(net_5, [2, 3], keep_dim=True)\\n net_5_scaled = fluid.layers.elementwise_mul(net_5, global_channels, axis=0)\\n\\n ### Combining the paths\\n net_4 = Upsample(net_4, scale=2)\\n net_5_scaled = Upsample(net_5_scaled, scale=4)\\n # print('net_4, net_5:', [net_4, net_5_scaled])\\n # layers_concat = list()\\n # layers_concat.append(spatial_net)\\n ## layers_concat.append(net_4)\\n # layers_concat.append(net_5_scaled)\\n context_net = fluid.layers.concat([spatial_net, net_4, net_5_scaled], axis=1) #\\n # context_net = fluid.layers.concat(input=layers_concat,axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([net_4, net_5_scaled], axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([spatial_net,context_net], axis=1)\\n # print('context_net2',context_net)\\n\\n ### FFM\\n # net = FeatureFusionModule(input_1=spatial_net, input_2=context_net, num_filters=num_classes)\\n net = FeatureFusionModule(inputs=context_net, num_filters=num_classes)\\n\\n # print('net', net)\\n\\n ## [batch_zize, num_filters, 128, 64]\\n\\n ### Final upscaling and finish\\n # net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 128])\\n # print('conv2d_transpose', net)\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn1')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[128, 256])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn2')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 512])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn3')\\n #net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[512, 1024])\\n #net = batch_normalization(net, relu=True, name='conv2d_transpose_bn4')\\n # print('net',net)\\n net = fluid.layers.image_resize(net, out_shape=[512, 1024], resample='BILINEAR')\\n\\n net = fluid.layers.conv2d(net, num_classes, 1)\\n return net\",\n \"def __init__(self, kernel_size, filters, stage, block):\\n super().__init__(name='identity' + str(stage) + block)\\n filters1, filters2, filters3 = filters\\n if K.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n self.conv1 = layers.Conv2D(\\n filters1, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2a')\\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\\n self.act1 = layers.Activation('relu')\\n\\n self.conv2 = layers.Conv2D(\\n filters2,\\n kernel_size,\\n padding='same',\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2b')\\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\\n self.act2 = layers.Activation('relu')\\n\\n self.conv3 = layers.Conv2D(\\n filters3, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2c')\\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\\n\\n self.add = layers.Add()\\n self.act = layers.Activation('relu')\",\n \"def construct_gumbel_selector(X_ph, num_words, embedding_dims, maxlen):\\n emb_layer = Embedding(num_words, embedding_dims, input_length = maxlen, name = 'emb_gumbel')\\n emb = emb_layer(X_ph) #(400, 50) \\n net = Dropout(0.2, name = 'dropout_gumbel')(emb)\\n net = emb\\n first_layer = Conv1D(100, kernel_size, padding='same', activation='relu', strides=1, name = 'conv1_gumbel')(net) # bs, 400, 100\\n\\n # global info\\n net_new = GlobalMaxPooling1D(name = 'new_global_max_pooling1d_1')(first_layer) # bs, 100\\n global_info = Dense(100, name = 'new_dense_1', activation='relu')(net_new) # bs, 100\\n\\n # local info\\n net = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv2_gumbel')(first_layer) # bs, 400, 100\\n local_info = Conv1D(100, 3, padding='same', activation='relu', strides=1, name = 'conv3_gumbel')(net) # bs, 400, 100\\n combined = Concatenate()([global_info,local_info]) \\n net = Dropout(0.2, name = 'new_dropout_2')(combined)\\n net = Conv1D(100, 1, padding='same', activation='relu', strides=1, name = 'conv_last_gumbel')(net) \\n\\n logits_T = Conv1D(1, 1, padding='same', activation=None, strides=1, name = 'conv4_gumbel')(net) # bs, 400, 1\\n # wanna make it bs, maxlen*num_groups\\n squeeze_layer = Lambda(lambda x:tf.squeeze(x), output_shape=lambda x:x[:-1])\\n\\n logits_T_grp = Dense(maxlen*num_groups)(squeeze_layer(logits_T))\\n #print(logits_T_grp.shape)\\n return logits_T_grp # bs, 400* num_groups\",\n \"def VGGFace(input_shape=(224, 224, 3), n_classes=10, include_top=True):\\n # Create the Tensor\\n input = Input(shape=input_shape)\\n\\n # Block 1\\n # 1st Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv1')(input)\\n x = Activation('relu', name='block1_relu1')(x)\\n\\n # 2nd Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv2')(x)\\n x = Activation('relu', name='block1_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block1_pool')(x)\\n\\n # Block 2\\n # 3rd Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv1')(x)\\n x = Activation('relu', name='block2_relu1')(x)\\n\\n # 4th Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv2')(x)\\n x = Activation('relu', name='block2_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block2_pool')(x)\\n\\n # Block 3\\n # 5th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv1')(x)\\n x = Activation('relu', name='block3_relu1')(x)\\n\\n # 6th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv2')(x)\\n x = Activation('relu', name='block3_relu2')(x)\\n\\n # 7th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv3')(x)\\n x = Activation('relu', name='block3_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block3_pool')(x)\\n\\n # Block 4\\n # 8th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv1')(x)\\n x = Activation('relu', name='block4_relu1')(x)\\n\\n # 9th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv2')(x)\\n x = Activation('relu', name='block4_relu2')(x)\\n\\n # 10th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv3')(x)\\n x = Activation('relu', name='block4_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block4_pool')(x)\\n\\n # Block 5\\n # 11th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv1')(x)\\n x = Activation('relu', name='block5_relu1')(x)\\n\\n # 12th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv2')(x)\\n x = Activation('relu', name='block5_relu2')(x)\\n\\n # 13th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv3')(x)\\n x = Activation('relu', name='block5_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block5_pool')(x)\\n\\n # Block 6\\n # 14th Convulation Layer\\n x = Conv2D(4096, (7, 7), strides=(1, 1), name='fc1_conv1')(x)\\n x = Activation('relu', name='fc1_relu1')(x)\\n x = Dropout(0.5)(x)\\n\\n # 15th Convulation Layer\\n x = Conv2D(4096, (1, 1), strides=(1, 1), name='fc2_conv1')(x)\\n x = Activation('relu', name='fc2_relu2')(x)\\n x = Dropout(0.5, name='fc2_dropout')(x)\\n\\n # 16th Convulation Layer\\n x = Conv2D(2622, (1, 1), strides=(1, 1), name='fc3_conv1')(x)\\n x = Flatten(name='fc3_flatten')(x)\\n\\n if include_top:\\n # Output Layer\\n x = Activation('softmax', name='predictions_softmax')(x)\\n\\n # Create model\\n model = keras.models.Model(input, x, name='vggface')\\n return model\",\n \"def LadderNet(input_size = (256, 256, 1), num_classes=2, filters=30): \\n \\n # X's denote standard flow\\n # XNUM denote ResBlock outputs\\n \\n # \\\"First\\\" UNet\\n \\n # Input branch\\n inputs = Input(input_size)\\n X = Conv2D(filters=filters, kernel_size=3, activation=\\\"relu\\\", padding = 'same', kernel_initializer = 'he_normal')(inputs)\\n\\n # Down branch\\n X1 = ResBlock(input_tensor=X, filters=filters) # ResBlock located in the first layer of the paper scheme\\n X = Conv2D(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X1) \\n X = Activation(\\\"relu\\\")(X) # This ReLU is not shown in the paper scheme\\n \\n X2 = ResBlock(input_tensor=X, filters=filters*2)\\n X = Conv2D(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X2)\\n X = Activation(\\\"relu\\\")(X)\\n \\n X3 = ResBlock(input_tensor=X, filters=filters*4)\\n X = Conv2D(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X3)\\n X = Activation(\\\"relu\\\")(X)\\n \\n X4 = ResBlock(input_tensor=X, filters=filters*8)\\n X = Conv2D(filters=filters*16, kernel_size=3, strides=2, kernel_initializer='he_normal')(X4)\\n X = Activation(\\\"relu\\\")(X)\\n \\n # Bottom block \\n X = ResBlock(input_tensor=X, filters=filters*16)\\n \\n # Up branch\\n X = Conv2DTranspose(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\\n X = Add()([X, X4])\\n # X = Activation(\\\"relu\\\")(X) # This ReLU is commented in the paper code\\n X5 = ResBlock(input_tensor=X, filters=filters*8)\\n \\n X = Conv2DTranspose(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X5)\\n X = Add()([X, X3])\\n # X = Activation(\\\"relu\\\")(X)\\n X6 = ResBlock(input_tensor=X, filters=filters*4)\\n \\n X = Conv2DTranspose(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X6)\\n X = Add()([X, X2])\\n # X = Activation(\\\"relu\\\")(X)\\n X7 = ResBlock(input_tensor=X, filters=filters*2)\\n \\n X = Conv2DTranspose(filters=filters, kernel_size=3, strides=2, output_padding=1, kernel_initializer='he_normal')(X7)\\n X = Add()([X, X1])\\n # X = Activation(\\\"relu\\\")(X)\\n X = ResBlock(input_tensor=X, filters=filters)\\n \\n # Top block (bottle-neck)\\n X8 = ResBlock(input_tensor=X, filters=filters)\\n X = ResBlock(input_tensor=X, filters=filters)\\n X = Add()([X, X8])\\n \\n # \\\"Second\\\" UNet\\n \\n # Down branch\\n X9 = ResBlock(input_tensor=X, filters=filters)\\n X = Conv2D(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \\n X = Activation(\\\"relu\\\")(X)\\n X = Add()([X7, X]) \\n \\n X10 = ResBlock(input_tensor=X, filters=filters*2)\\n X = Conv2D(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \\n X = Activation(\\\"relu\\\")(X) \\n X = Add()([X6, X])\\n \\n X11 = ResBlock(input_tensor=X, filters=filters*4)\\n X = Conv2D(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \\n X = Activation(\\\"relu\\\")(X)\\n X = Add()([X5, X])\\n\\n X12 = ResBlock(input_tensor=X, filters=filters*8)\\n X = Conv2D(filters=filters*16, kernel_size=3, strides=2, kernel_initializer='he_normal')(X) \\n X = Activation(\\\"relu\\\")(X)\\n \\n # Bottom block\\n X = ResBlock(input_tensor=X, filters=filters*16)\\n \\n # Up branch\\n X = Conv2DTranspose(filters=filters*8, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\\n X = Add()([X, X12]) \\n # X = Activation(\\\"relu\\\")(X)\\n X = ResBlock(input_tensor=X, filters=filters*8)\\n \\n X = Conv2DTranspose(filters=filters*4, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\\n X = Add()([X, X11])\\n # X = Activation(\\\"relu\\\")(X)\\n X = ResBlock(input_tensor=X, filters=filters*4)\\n \\n X = Conv2DTranspose(filters=filters*2, kernel_size=3, strides=2, kernel_initializer='he_normal')(X)\\n X = Add()([X, X10])\\n # X = Activation(\\\"relu\\\")(X)\\n X = ResBlock(input_tensor=X, filters=filters*2)\\n \\n X = Conv2DTranspose(filters=filters, kernel_size=3, strides=2, kernel_initializer='he_normal', output_padding=1)(X)\\n X = Add()([X, X9])\\n # X = Activation(\\\"relu\\\")(X)\\n X = ResBlock(input_tensor=X, filters=filters)\\n \\n # Final block\\n X = Conv2D(filters=num_classes, kernel_size=1, kernel_initializer='he_normal')(X)\\n # X = Activation(\\\"relu\\\")(X)\\n X = Activation(\\\"softmax\\\")(X)\\n #X = Conv2D(1, 1)(X)\\n \\n model = Model(inputs, X)\\n \\n \\n return model\",\n \"def build_discriminator(self):\\n img_shape = (self.img_size[0], self.img_size[1], self.channels)\\n\\n model = Sequential()\\n ###############\\n # Conv Stack 1:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=5, strides=2, input_shape=img_shape, padding=\\\"same\\\")\\n ) # 128x128 -> 64x64\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.2))\\n\\n ###############\\n # Conv Stack 2:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=5, strides=2, padding=\\\"same\\\")\\n ) # 64x64 -> 32x32\\n # model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 3:\\n ###############\\n model.add(\\n Conv2D(128, kernel_size=4, strides=2, padding=\\\"same\\\")\\n ) # 32x32 -> 16x16\\n\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 4:\\n ###############\\n model.add(Conv2D(128, kernel_size=4, strides=1, padding=\\\"same\\\")) # 16x16 -> 8x8\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n # model.add(Dropout(0.25))\\n\\n ###############\\n # Conv Stack 5:\\n ###############\\n model.add(Conv2D(128, kernel_size=3, strides=1, padding=\\\"same\\\")) # 8x8 -> 4x4\\n model.add(LeakyReLU(alpha=0.2))\\n model.add(BatchNormalization(momentum=0.8))\\n model.add(Dropout(0.4))\\n\\n model.add(Flatten())\\n model.add(Dense(1, activation=\\\"sigmoid\\\")) # important binary classification.\\n\\n model.summary()\\n\\n # Model require Pair.\\n img = Input(shape=img_shape)\\n validity = model(img)\\n\\n return Model(img, validity)\",\n \"def predict_age(input_path:str):\\r\\n #Initialize dlib face detector using the facial landmark recognition\\r\\n detector, predictor = initialize_dlib(facial_landmark_predictor=FACIAL_LANDMARK_PREDICTOR)\\r\\n\\r\\n #Load age prediction model\\r\\n age_net = load_caffe_models(age_model=AGE_MODEL, age_proto = AGE_PROTO)\\r\\n\\r\\n # Initialize frame size\\r\\n frame_width = 640\\r\\n frame_height = 360\\r\\n\\r\\n # Read Input Image\\r\\n img = cv2.imread(input_path)\\r\\n\\r\\n # Take a copy of the initial image and resize it\\r\\n frame = img.copy()\\r\\n frame = imutils.resize(img, width=frame_width, height=frame_height)\\r\\n\\r\\n # Convert it to gray scale\\r\\n gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Detect faces in the gray scale frame\\r\\n faces = detector(gray_frame, 0)\\r\\n\\r\\n # Loop over the faces detected\\r\\n for idx, face in enumerate(faces):\\r\\n print(\\\"Detection Face ID = {} - Position = Left:{} Top:{} Right:{} Botton:{}\\\".format((idx+1), face.left(), face.top(), face.right(),\\r\\n face.bottom()))\\r\\n\\r\\n #Draw the face bounding box\\r\\n (x,y,w,h) = face_utils.rect_to_bb(face)\\r\\n startX , startY , endX , endY = x,y,(x+w),(y+h)\\r\\n face_img = cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2)\\r\\n\\r\\n #Retrieve face\\r\\n # Determine the facial landmarks for the face region\\r\\n #shape = predictor(gray_frame, face)\\r\\n # Convert the facial landmark (x, y) coordinates to a NumPy array\\r\\n #shape = face_utils.shape_to_np(shape)\\r\\n # Extract the ROI of the face region as a separate image\\r\\n #(x, y, w, h) = cv2.boundingRect(np.array([shape]))\\r\\n #roi = img[y:y + h, x:x + w]\\r\\n #display_img(\\\"face\\\", roi)\\r\\n\\r\\n # image --> Input image to preprocess before passing it through our dnn for classification.\\r\\n blob = cv2.dnn.blobFromImage(image= face_img\\r\\n , scalefactor=1.0\\r\\n , size=(227, 227)\\r\\n , mean=MODEL_MEAN_VALUES\\r\\n , swapRB=False\\r\\n , crop=False)\\r\\n # Predict Age\\r\\n age_net.setInput(blob)\\r\\n age_preds = age_net.forward()\\r\\n i = age_preds[0].argmax()\\r\\n age = AGE_INTERVALS[i]\\r\\n age_confidence_score = age_preds[0][i]\\r\\n\\r\\n #print('shape' ,img.shape)\\r\\n\\r\\n #Draw the box\\r\\n label = \\\"Age{}-{:.2f}%\\\".format(age,age_confidence_score*100)\\r\\n print(label)\\r\\n\\r\\n #yPos = endY + 25\\r\\n yPos = startY - 15\\r\\n while yPos < 15:\\r\\n yPos += 15\\r\\n #print(yPos)\\r\\n optimal_font_scale = get_optimal_font_scale(label,((endX-startX)+25))\\r\\n cv2.rectangle(face_img, (startX, startY), (endX, endY), (0, 255, 0), 2)\\r\\n cv2.putText(face_img, label, (startX, yPos), cv2.FONT_HERSHEY_SIMPLEX, optimal_font_scale , (0, 255, 0), 2)\\r\\n #Display processed image\\r\\n display_img('Age Estimator', face_img)\\r\\n\\r\\n # Cleanup\\r\\n cv2.destroyAllWindows()\",\n \"def darknet_body():\\n return compose(DarknetConv2D_BN_Leaky(32, (3, 3)), MaxPooling2D(), DarknetConv2D_BN_Leaky(64, (3, 3)),\\n MaxPooling2D(), bottleneck_block(128, 64), MaxPooling2D(), bottleneck_block(256, 128),\\n MaxPooling2D(), bottleneck_x2_block(512, 256), MaxPooling2D(), bottleneck_x2_block(1024, 512))\",\n \"def build_model(self):\\n \\n start_time = time.time()\\n print(\\\"build model started\\\")\\n # label\\n self.FA = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.ges = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.obj = tf.placeholder(dtype=tf.int32, shape=[None])\\n \\n self.images = tf.placeholder(dtype=tf.float32, shape=[None, height, width, 3])\\n batch_size = tf.shape(self.images)[0]\\n rgb_scaled = self.images * 255.0\\n\\n # Convert RGB to BGR\\n VGG_MEAN = [103.939, 116.779, 123.68]\\n red, green, blue = tf.split(axis=3, num_or_size_splits=3, value=rgb_scaled)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n blue - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n red - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n \\n with tf.variable_scope(\\\"vgg19\\\"):\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.conv3_4 = self.conv_layer(self.conv3_3, \\\"conv3_4\\\")\\n self.pool3 = self.max_pool(self.conv3_4, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.conv4_4 = self.conv_layer(self.conv4_3, \\\"conv4_4\\\")\\n self.pool4 = self.max_pool(self.conv4_4, 'pool4')\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.conv5_4 = self.conv_layer(self.conv5_3, \\\"conv5_4\\\")\\n self.pool5 = self.max_pool(self.conv5_4, 'pool5')\\n\\n \\n shape = self.pool5.get_shape()\\n size = 1\\n for dim in shape[1:]:\\n size *= dim.value\\n \\n # dense\\n with tf.variable_scope('dense') as scope:\\n # Move everything into depth so we can perform a single matrix multiply.\\n reshape = tf.reshape(self.pool5, [-1, size])\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[size, 192]))\\n biases = tf.get_variable('biases', [192], initializer=tf.constant_initializer(0.1))\\n dense = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\\n\\n\\n # linear layer(WX + b),\\n with tf.variable_scope('softmax_linear_FA') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 2]))\\n biases = tf.get_variable('biases', [2], initializer=tf.constant_initializer(0.1))\\n softmax_linear_FA = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_FA = tf.nn.softmax(softmax_linear_FA)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.FA, logits=softmax_linear_FA, name='cross_entropy')\\n cross_entropy_mean_FA = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_ges') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 13]))\\n biases = tf.get_variable('biases', [13], initializer=tf.constant_initializer(0.1))\\n softmax_linear_ges = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_ges = tf.nn.softmax(softmax_linear_ges)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.ges, logits=softmax_linear_ges, name='cross_entropy')\\n cross_entropy_mean_ges = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_obj') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 24]))\\n biases = tf.get_variable('biases', [24], initializer=tf.constant_initializer(0.1))\\n softmax_linear_obj = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_obj = tf.nn.softmax(softmax_linear_obj)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.obj, logits=softmax_linear_obj, name='cross_entropy')\\n cross_entropy_mean_obj = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n self.loss = cross_entropy_mean_FA + cross_entropy_mean_ges + cross_entropy_mean_obj\\n self.lr = tf.placeholder(tf.float32, [])\\n self.global_step = tf.Variable(0, name=\\\"global_step\\\", trainable=False)\\n optimizer = tf.train.AdamOptimizer(self.lr)\\n grads_and_vars = optimizer.compute_gradients(self.loss)\\n self.train_op = optimizer.apply_gradients(grads_and_vars, global_step=self.global_step)\\n self.data_dict = None\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\",\n \"def model_build(self):\\n\\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\\n X_input = Input(self.inputData[0].shape)\\n\\n '''\\n # CONV -> BN -> RELU Block applied to X\\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\\n X = BatchNormalization(name='bn0')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\\n X = Dropout(0.1, name='dropout0')(X)\\n\\n X = Conv2D(16, (16, 16), name='conv1')(X)\\n X = BatchNormalization(name='bn1')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\\n X = Dropout(0.1, name='dropout1')(X)\\n\\n X = Conv2D(16, (32, 32), name='conv2')(X)\\n X = BatchNormalization(name='bn2')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n' '''\\n\\n X = Dense(500, activation='relu', name='fc0')(X_input)\\n X = Dropout(0.1, name='dropout1')(X)\\n X = Dense(500, activation='relu', name='fc1')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n X = Dense(3, activation='softmax', name='fc2')(X)\\n\\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')\",\n \"def build_unet(input_layer = Input((128,128,3)), start_depth=64, activation='relu', initializer='he_normal'):\\n\\n # 128 -> 64\\n conv1 = Conv2D_BN(input_layer, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv1 = Conv2D_BN(conv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool1 = MaxPooling2D((2, 2))(conv1)\\n\\n # 64 -> 32\\n conv2 = Conv2D_BN(pool1, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv2 = Conv2D_BN(conv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool2 = MaxPooling2D((2, 2))(conv2)\\n\\n # 32 -> 16\\n conv3 = Conv2D_BN(pool2, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv3 = Conv2D_BN(conv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool3 = MaxPooling2D((2, 2))(conv3)\\n\\n # 16 -> 8\\n conv4 = Conv2D_BN(pool3, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n conv4 = Conv2D_BN(conv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n pool4 = MaxPooling2D((2, 2))(conv4)\\n\\n # Middle\\n convm=cbam_block(pool4)\\n\\n # 8 -> 16\\n deconv4 = Conv2DTranspose(convm, start_depth * 8, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv4 = concatenate([deconv4, conv4])\\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv4 = Conv2D_BN(uconv4, start_depth * 8, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 16 -> 32\\n deconv3 = Conv2DTranspose(uconv4, start_depth * 4, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv3 = concatenate([deconv3, conv3])\\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv3 = Conv2D_BN(uconv3, start_depth * 4, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 32 -> 64\\n deconv2 = Conv2DTranspose(uconv3, start_depth * 2, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv2 = concatenate([deconv2, conv2])\\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv2 = Conv2D_BN(uconv2, start_depth * 2, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n # 64 -> 128\\n deconv1 = Conv2DTranspose(uconv2, start_depth * 1, (3, 3), strides=(2, 2), activation=activation, kernel_initializer=initializer)\\n uconv1 = concatenate([deconv1, conv1])\\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n uconv1 = Conv2D_BN(uconv1, start_depth * 1, (3, 3), activation=activation, kernel_initializer=initializer)\\n\\n output_layer = Conv2D(1, (1,1), padding=\\\"same\\\", activation=\\\"sigmoid\\\")(uconv1)\\n\\n return output_layer\",\n \"def Unet4(shape, nb_filters=32, exp=1, kernel_size=3, initialization=\\\"glorot_uniform\\\", activation=\\\"relu\\\", sigma_noise=0, output_channels=1, drop=0.0, regularization=None):\\n \\n \\n input_layer = Input(shape=shape)\\n\\n conv1 = ConvBlock(input_layer, nb_filters=nb_filters, kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\\n if drop > 0.0: pool1 = Dropout(drop)(pool1)\\n\\n conv2 = ConvBlock(pool1, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\\n if drop > 0.0: pool2 = Dropout(drop)(pool2)\\n\\n conv3 = ConvBlock(pool2, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\\n if drop > 0.0: pool3 = Dropout(drop)(pool3)\\n\\n conv4 = ConvBlock(pool3, nb_filters=nb_filters * 2 **(3 * exp), kernel_size=kernel_size, initializer=initialization, activation=activation, regularization=regularization)\\n pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)\\n if drop > 0.0: pool4 = Dropout(drop)(pool4)\\n\\n deconv5 = DeconvBlock(conv4, residual=conv3, nb_filters=nb_filters * 2 **(2 * exp), kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv5 = Dropout(drop)(deconv5)\\n\\n deconv6 = DeconvBlock(deconv5, residual=conv2, nb_filters=nb_filters * 2 **(1 * exp), kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv6 = Dropout(drop)(deconv6)\\n\\n deconv7 = DeconvBlock(deconv6, residual=conv1, nb_filters=nb_filters, kernel_size=kernel_size, regularization=regularization)\\n if drop > 0.0: deconv7 = Dropout(drop)(deconv7)\\n\\n if sigma_noise > 0:\\n deconv7 = GaussianNoise(sigma_noise)(deconv7)\\n\\n output_layer = Conv2D(filters=output_channels, kernel_size=(1, 1))(deconv7)\\n output_layer = BatchNormalization()(output_layer)\\n output_layer = Activation('softmax')(output_layer)\\n\\n model = Model(inputs=input_layer, outputs=output_layer, name='Unet')\\n return model\",\n \"def __conv_block(self, x, stage, branch, nb_filter, dropout_rate=None, weight_decay=1e-4):\\n\\t\\teps = 1.1e-5\\n\\t\\tconv_name_base = \\\"conv\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\t\\trelu_name_base = \\\"relu\\\" + str(stage) + \\\"_\\\" + str(branch)\\n\\n\\t\\t# 1x1 Convolution (Bottleneck layer)\\n\\t\\tinter_channel = nb_filter * 4 \\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x1_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x1_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x1\\\")(x)\\n\\t\\tx = Conv2D(inter_channel, (1, 1), name=conv_name_base+\\\"_x1\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\t# 3x3 Convolution\\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=conv_name_base+\\\"_x2_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=conv_name_base+\\\"_x2_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=relu_name_base+\\\"_x2\\\")(x)\\n\\t\\tx = ZeroPadding2D((1, 1), name=conv_name_base+\\\"_x2_zeropadding\\\")(x)\\n\\t\\tx = Conv2D(nb_filter, (3, 3), name=conv_name_base+\\\"_x2\\\", use_bias=False)(x)\\n\\n\\t\\tif dropout_rate:\\n\\t\\t\\tx = Dropout(dropout_rate)(x)\\n\\n\\t\\treturn x\",\n \"def build_vgg(self):\\n # Get the vgg network. Extract features from Block 5, last convolution.\\n vgg = tf.keras.applications.VGG19(weights=\\\"imagenet\\\", input_shape=self.hr_shape, include_top=False)\\n vgg.trainable = False\\n for layer in vgg.layers:\\n layer.trainable = False\\n\\n # Create model and compile\\n model = tf.keras.models.Model(inputs=vgg.input, outputs=vgg.get_layer(\\\"block5_conv4\\\").output)\\n\\n return model\",\n \"def build(self):\\n\\n # bgr_ = bgr*255.0\\n bgr_= self.X\\n start_time = time.time()\\n print(\\\"build model started\\\")\\n\\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n # blue - VGG_MEAN[0],\\n # green - VGG_MEAN[1],\\n # red - VGG_MEAN[2],\\n\\n red - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n blue - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n\\n\\n\\n print(bgr.shape)\\n\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n\\n\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\\n\\n\\n\\n\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\\n\\n self.fc6 = self.fc_layer(self.pool5, \\\"fc6\\\")\\n assert self.fc6.get_shape().as_list()[1:] == [4096]\\n self.relu6 = tf.nn.relu(self.fc6)\\n\\n self.fc7 = self.fc_layer(self.relu6, \\\"fc7\\\")\\n self.relu7 = tf.nn.relu(self.fc7)\\n\\n self.fc8 = self.fc_layer(self.relu7, \\\"fc8\\\")\\n\\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\\n # self.relu9 = tf.nn.relu(self.fc9)\\n\\n\\n\\n\\n relu8 = tf.nn.relu(self.fc8)\\n fc9 = self.fc_layer(relu8, 'fc9')\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\\n return fc9\\n\\n # self.prob = tf.nn.softmax(self.fc8, name=\\\"prob\\\")\",\n \"def VGGModel(input_shape):\\n \\n\\n X_input = Input(input_shape)\\n \\n # Creating a Neural Network (VGG-16)\\n\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(X_input)\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(X)\\n\\n # Block 2\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(X)\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(X)\\n\\n # Block 3\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(X)\\n\\n # Block 4\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(X)\\n\\n # Block 5\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(X)\\n \\n X = Flatten()(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc')(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc2')(X)\\n X = Dense(2048, activation='relu', kernel_initializer = 'he_normal', name='fc3')(X)\\n X = Dense(1024, activation='relu', kernel_initializer = 'he_normal', name='fc4')(X)\\n X = Dense(512, activation='relu', kernel_initializer = 'he_normal', name='fc5')(X)\\n X = Dense(256, activation='relu', kernel_initializer = 'he_normal', name='fc6')(X)\\n X = Dense(2, activation='linear', name='regression')(X)\\n model = Model(inputs=X_input, outputs = X, name='HappyModel')\\n print(model.summary())\\n \\n return model\",\n \"def baseUNet(input_shape,conv_depth,n_classes,init_w,dropout):\\n inputs = Input(input_shape)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding='same',\\n kernel_initializer=init_w)(inputs)\\n\\n c1=Conv2D(conv_depth,\\n (3,3),\\n activation='relu',\\n padding=\\\"same\\\",\\n kernel_initializer=init_w)(c1)\\n\\n # pool down to next layer\\n pool1 = MaxPooling2D((2,2),strides = (2,2))(c1)\\n\\n conv_depth *= 2\\n\\n # convolute down again\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool1)\\n\\n conv2 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv2)\\n \\n # pool down again\\n pool2 = MaxPooling2D((2,2),strides = (2,2))(conv2)\\n\\n conv_depth *= 2 \\n\\n # Convolution\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool2)\\n\\n conv3 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv3)\\n \\n # pool down\\n pool3 = MaxPooling2D((2,2),strides = (2,2))(conv3)\\n\\n conv_depth *= 2 \\n # Convolution\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool3)\\n\\n conv4 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv4)\\n \\n # pool down \\n pool4 = MaxPooling2D((2,2),strides = (2,2))(conv4)\\n\\n conv_depth *=2 \\n\\n # Convolution\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(pool4)\\n\\n conv5 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv5)\\n\\n drop = Dropout(dropout)(conv5)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth) \\n # do upsampling\\n up1 = UpSampling2D(size = (2,2))(drop)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up1)\\n \\n # add in skip info\\n cat1 = concatenate([conv4,conv6],axis = 3)\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat1)\\n\\n conv6 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv6)\\n\\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up2 = UpSampling2D(size = (2,2))(conv6)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up2)\\n \\n # add in skip info\\n cat2 = concatenate([conv3,conv7],axis = 3)\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat2)\\n\\n conv7 = Conv2D(conv_depth,\\n activation = 'relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv7)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up3 = UpSampling2D(size = (2,2))(conv7)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size=(3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up3)\\n \\n # add in skip info\\n cat3 = concatenate([conv2,conv8],axis = 3)\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat3)\\n\\n conv8 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv8)\\n \\n conv_depth /= 2\\n conv_depth = int(conv_depth)\\n # do upsampling\\n up4 = UpSampling2D(size = (2,2))(conv8)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(up4)\\n \\n # add in skip info\\n cat4 = concatenate([c1,conv9],axis = 3)\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(cat4)\\n\\n conv9 = Conv2D(conv_depth,\\n activation ='relu',\\n kernel_size = (3,3),\\n strides = (1,1),\\n padding = \\\"same\\\",\\n kernel_initializer=init_w)(conv9)\\n\\n outputs = Conv2D(n_classes, 1, activation = 'softmax')(conv9)\\n\\n return outputs,inputs\",\n \"def __init__(self, in_channels, BN, bn_eps=1e-5):\\n super(InceptionE, self).__init__()\\n self.branch1x1 = omth_blocks.conv_block(in_channels, filters=[320], kernel_sizes=[1], stride=[1],\\n padding=[0], batch_norm=BN)\\n\\n self.branch3x3_1 = omth_blocks.conv_block(in_channels, filters=[384], kernel_sizes=[1], stride=[1],\\n padding=[0], batch_norm=BN)\\n self.branch3x3_2 = self.sub_inception_module(BN)\\n\\n self.branch3x3dbl_1 = omth_blocks.conv_block(in_channels, filters=[384, 384], kernel_sizes=[1, 3], stride=[1, 1],\\n padding=[0, 1], batch_norm=BN)\\n self.branch3x3dbl_2 = self.sub_inception_module(BN)\\n\\n self.branch_pool = omth_blocks.conv_block(in_channels, filters=[192], kernel_sizes=[1], stride=[1],\\n padding=[0], batch_norm=BN)\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def __init__(self, dropout_rate, num_classes, include_top, layer):\\r\\n super(VGG16_Rand, self).__init__()\\r\\n print(\\\"CIFAR VGG16_Rand is used\\\")\\r\\n self.dropout_rate = dropout_rate\\r\\n self.num_classes = num_classes\\r\\n self.include_top = include_top\\r\\n self.layer = layer\\r\\n self.bias = True\\r\\n\\r\\n # Define the building blocks\\r\\n if layer <= 11:\\r\\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 12:\\r\\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 21:\\r\\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 22:\\r\\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 31:\\r\\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 32:\\r\\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 33:\\r\\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 41:\\r\\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 42:\\r\\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 43:\\r\\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 51:\\r\\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 52:\\r\\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 53:\\r\\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n self.avgpool = nn.AdaptiveAvgPool2d(1)\\r\\n self.fc = nn.Sequential(nn.Linear(512, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, num_classes))\\r\\n\\r\\n # Initialize the weights\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\r\\n elif isinstance(m, nn.BatchNorm2d):\\r\\n # raise Exception('You are using a model without BN!!!')\\r\\n nn.init.constant_(m.weight, 1)\\r\\n nn.init.constant_(m.bias, 0)\",\n \"def __init__(self):\\n super(AlexNet, self).__init__()\\n\\n initializer = tf.keras.initializers.RandomNormal(mean=0., stddev=0.01)\\n bias = tf.keras.initializers.Ones()\\n bias0 = tf.keras.initializers.Zeros()\\n self.drop = tf.keras.layers.Dropout(.5)\\n\\n # Input is 227 and not 224 as stated on the doc.\\n # See issue: https://stackoverflow.com/questions/36733636/the-number-of-neurons-in-alexnet\\n self.conv1_1 = tf.keras.layers.Conv2D(48, 11, strides=4, activation=\\\"relu\\\", input_shape=[227, 227, 3],\\n kernel_initializer=initializer, bias_initializer=bias0)\\n self.conv1_2 = tf.keras.layers.Conv2D(48, 11, strides=4, activation=\\\"relu\\\", input_shape=[227, 227, 3],\\n kernel_initializer=initializer, bias_initializer=bias0)\\n # Output: 227 - 11 / 4 + 1 = 55\\n # Maxpool: 55 / 2 = 27.5 = ~27\\n\\n self.conv2_1 = tf.keras.layers.Conv2D(128, 5, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n self.conv2_2 = tf.keras.layers.Conv2D(128, 5, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n # Output: 27\\n # Maxpool: 27 / 2 = 13.5 = ~13\\n\\n self.conv3_1 = tf.keras.layers.Conv2D(192, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n self.conv3_2 = tf.keras.layers.Conv2D(192, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n # Output: 13\\n\\n self.conv4_1 = tf.keras.layers.Conv2D(192, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n self.conv4_2 = tf.keras.layers.Conv2D(192, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n # Output: 13\\n\\n self.conv5_1 = tf.keras.layers.Conv2D(128, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n self.conv5_2 = tf.keras.layers.Conv2D(128, 3, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias, padding=\\\"SAME\\\")\\n # Output: 13\\n\\n self.max_pool = tf.keras.layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2))\\n # Output: 13 / 2 = 6.5 = ~6\\n\\n self.flatten = tf.keras.layers.Flatten()\\n\\n # Input: 6 * 6 * 128 * 2 = 9216\\n self.fc1_1 = tf.keras.layers.Dense(2048, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias)\\n self.fc1_2 = tf.keras.layers.Dense(2048, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias)\\n\\n self.fc2_1 = tf.keras.layers.Dense(2048, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias)\\n self.fc2_2 = tf.keras.layers.Dense(2048, activation=\\\"relu\\\", kernel_initializer=initializer,\\n bias_initializer=bias)\\n\\n self.fc3 = tf.keras.layers.Dense(1000, activation=\\\"softmax\\\")\",\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 discriminator_block(in_filters, out_filters, f_size=4, normalize=True,stride=2):\\n layers = [nn.Conv2d(in_filters, out_filters, f_size, stride=stride, padding=0)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\\n\\t\\t# We have to match this output size.\\n\\t\\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\\n\\t\\n\\t\\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\\n\\t\\n\\t\\t# Convolutional ops will go here.\\n\\t\\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tconv_output = c5\\n\\t\\n\\t\\t# Transition to FC layers.\\n\\t\\tpre_flat_shape = conv_output.get_shape().as_list()\\n\\t\\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\\n\\t\\n\\t\\t# Dense connections\\n\\t\\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\\n\\t\\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\\n\\t\\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\\n\\t\\tfc_out = fc2\\n\\t\\n\\t\\t# Output point and our encoder mix-in.\\n\\t\\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\\n\\t\\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\\n\\t\\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\\n\\t\\n\\t\\t# More dense connections on the offset.\\n\\t\\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\\n\\t\\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\\n\\t\\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\\n\\t\\n\\t\\t# Expand for more convolutional operations.\\n\\t\\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\\n\\t\\n\\t\\t# More convolutions here.\\n\\t\\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\\n\\t\\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\\n\\t\\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\\n\\t\\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tdeconv_output = dc0\\n\\t\\n\\t\\t# Return result + encoder output\\n\\t\\treturn deconv_output, encoded_output\",\n \"def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\",\n \"def __init__(self, in_channels, out_channels, kernel_size, num_layers=3,\\n dropout_rate=0.3):\\n super().__init__()\\n\\n _validate_args(in_channels, out_channels, kernel_size, num_layers)\\n\\n self.kernel_size = kernel_size\\n self.padding = (kernel_size - 1) // 2\\n\\n conv_list = [\\n self._create_single_block(in_channels, out_channels)\\n ]\\n\\n # Create the rest of the blocks\\n for _ in range(num_layers - 1):\\n conv_list.append(\\n self._create_single_block(out_channels, out_channels)\\n )\\n\\n self.convs = nn.Sequential(*conv_list)\\n self.drop = nn.Dropout2d(dropout_rate)\\n self.pool = nn.MaxPool2d((2, 2), return_indices=True)\",\n \"def build(width, height, depth, classes, stages, filters, include_top, pooling,\\n reg=1e-3, bnEps=2e-5, bnMom=0.0):\\n inputShape = (height, width, depth)\\n chanDim = -1\\n\\n if K.image_data_format() == \\\"channels_first\\\":\\n inputShape = (depth, height, width)\\n chanDim = 1\\n\\n inputs = Input(shape=inputShape)\\n\\n\\n # block 1 (initial conv block)\\n x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(inputs)\\n x = Conv2D(64, (7,7), use_bias=False, strides=(2,2),\\n kernel_initializer=\\\"he_normal\\\", kernel_regularizer=l2(reg))(x)\\n x = BatchNormalization(axis=chanDim, name=\\\"bn_conv1\\\")(x)\\n x = Activation(\\\"relu\\\")(x)\\n x = ZeroPadding2D(padding=((1,1), (1,1)), name=\\\"pool1_pad\\\")(x)\\n x = MaxPooling2D(3, strides=2)(x)\\n\\n for i in range(0, len(stages)):\\n stride = (1,1) if i == 0 else (2,2) # block 2 (projection block) w stride(1,1)\\n\\n print(\\\"Stage {}, Stride={}\\\".format(i, stride))\\n x = SEResNet.residual_module(x, filters[i+1], stride,\\n chanDim=chanDim, red=True, bnEps=bnEps, bnMom=bnMom)\\n for j in range(0, stages[i] + 1): #stacking res block to each depth layer\\n x = SEResNet.residual_module(x, filters[i+1], stride=(1,1),\\n chanDim=chanDim, bnEps=bnEps,\\n bnMom=bnMom)\\n x = BatchNormalization(axis=chanDim, epsilon=bnEps,\\n momentum=bnMom)(x)\\n x = Activation(\\\"relu\\\")(x)\\n\\n if include_top:\\n x = GlobalAveragePooling2D()(x)\\n x = Dense(classes, use_bias=False, kernel_regularizer=l2(reg),\\n activation='softmax')(x)\\n else:\\n if pooling == 'avg':\\n print(\\\"Adding average pool\\\")\\n x = GlobalAveragePooling2D()(x)\\n elif pooling == 'max':\\n x = GlobalMaxPooling2D()(x)\\n\\n model = Model(inputs=inputs, outputs=x, name=\\\"SEResNet\\\")\\n return model\",\n \"def dir_conv_block(model, nb_layers, nb_filters, rate):\\n\\n for _ in range(nb_layers):\\n model, rate = dir_conv_layer(model, nb_filters, rate)\\n model = MaxPooling1D()(model)\\n model = Dropout(0.1)(model)\\n return model, rate\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def identity_block(self, input_tensor, kernel_size, filters, stage, block):\\r\\n\\t\\tfilters1, filters2, filters3 = filters # this indicates the number of filter (here, assume that all filter number are same)\\r\\n\\r\\n\\t\\tbn_axis = self.channel_last # number of classes being classified\\r\\n \\r\\n\\t\\t# names for the layers\\r\\n\\t\\tconv_name_base = 'res' + str(stage) + block + '_branch'\\r\\n\\t\\tbn_name_base = 'bn' + str(stage) + block + '_branch'\\r\\n\\r\\n\\t\\t# model definition\\r\\n\\t\\tx = Conv2D(filters1, (1, 1),\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2a')(input_tensor)\\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n\\r\\n\\t\\tx = Conv2D(filters2, kernel_size,\\r\\n\\t\\t\\t\\t\\t\\t padding='same',\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2b')(x)\\r\\n \\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n\\r\\n\\t\\tx = Conv2D(filters3, (1, 1),\\r\\n\\t\\t\\t\\t\\t\\t kernel_initializer='he_normal',\\r\\n\\t\\t\\t\\t\\t\\t name=conv_name_base + '2c')(x)\\r\\n\\t\\tx = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)\\r\\n\\r\\n\\t\\t# Here, we add the outcome tensor(layer) x to original input tensor\\r\\n\\t\\tx = add([x, input_tensor])\\r\\n\\t\\tx = Activation('relu')(x)\\r\\n \\r\\n\\t\\treturn x\",\n \"def __init__(self, in_channels, out_channels, pool=True, last=False, stride=1):\\n super(Vggish, self).__init__()\\n # The two convolutional layers\\n self.conv_1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(3, 3),\\n stride=(stride, stride), padding=(1, 1), bias=False)\\n self.conv_2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(3, 3),\\n stride=(stride, stride), padding=(1, 1), bias=False)\\n\\n # Batch normalization\\n self.bn_1 = nn.BatchNorm2d(out_channels)\\n self.bn_2 = nn.BatchNorm2d(out_channels)\\n\\n # Flags\\n self.last = last\\n self.pool = pool\\n\\n # Setting up the max pooling\\n self.max_pool = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), return_indices=True)\\n\\n # Weights initialization\\n def _weights_init(m):\\n if isinstance(m, nn.Conv2d or nn.Linear or nn.GRU or nn.LSTM):\\n init.xavier_normal_(m.weight)\\n # m.bias.data.zero_()\\n elif isinstance(m, nn.BatchNorm2d or nn.BatchNorm1d):\\n m.weight.data.fill_(1)\\n m.bias.data.zero_()\\n\\n self.apply(_weights_init)\",\n \"def init_encoder(self):\\n\\n vgg = models.vgg16(pretrained=True)\\n\\n blocks = [self.layer_1,\\n self.layer_2,\\n self.layer_3,\\n self.layer_4,\\n self.layer_5]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\",\n \"def __init__(self, kernel_size, filters, stage, block, strides=(2, 2)):\\n super().__init__(name='conv_block' + str(stage) + block)\\n filters1, filters2, filters3 = filters\\n if K.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n conv_name_base = 'res' + str(stage) + block + '_branch'\\n bn_name_base = 'bn' + str(stage) + block + '_branch'\\n\\n self.conv1 = layers.Conv2D(\\n filters1, (1, 1),\\n strides=strides,\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2a')\\n self.bn1 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')\\n self.act1 = layers.Activation('relu')\\n\\n self.conv2 = layers.Conv2D(\\n filters2,\\n kernel_size,\\n padding='same',\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2b')\\n self.bn2 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')\\n self.act2 = layers.Activation('relu')\\n\\n self.conv3 = layers.Conv2D(\\n filters3, (1, 1),\\n kernel_initializer='he_normal',\\n name=conv_name_base + '2c')\\n self.bn3 = layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')\\n\\n self.shortcut_conv = layers.Conv2D(\\n filters3, (1, 1),\\n strides=strides,\\n kernel_initializer='he_normal',\\n name=conv_name_base + '1')\\n self.shortcut_bn = layers.BatchNormalization(\\n axis=bn_axis, name=bn_name_base + '1')\\n\\n self.add = layers.Add()\\n self.act = layers.Activation('relu')\",\n \"def build(self, unused_input_shapes):\\n self.layers = []\\n for i in range(self.num_hidden_layers):\\n self.layers.append(\\n TransformerDecoderBlock(\\n hidden_size=self.hidden_size,\\n num_attention_heads=self.num_attention_heads,\\n intermediate_size=self.intermediate_size,\\n intermediate_activation=self.intermediate_activation,\\n hidden_dropout_prob=self.hidden_dropout_prob,\\n attention_probs_dropout_prob=self.attention_probs_dropout_prob,\\n initializer_range=self.initializer_range,\\n multi_channel_cross_attention=self.multi_channel_cross_attention,\\n name=(\\\"layer_%d\\\" % i)))\\n super(TransformerDecoder, self).build(unused_input_shapes)\",\n \"def build_gender_branch(self, inputs, num_genders=2):\\n x = Lambda(lambda c: tf.image.rgb_to_grayscale(c))(inputs)\\n\\n x = self.make_default_hidden_layers(inputs)\\n\\n x = Flatten()(x)\\n x = Dense(128)(x)\\n x = Activation(\\\"relu\\\")(x)\\n x = BatchNormalization()(x)\\n x = Dropout(0.5)(x)\\n x = Dense(num_genders)(x)\\n x = Activation(\\\"sigmoid\\\", name=\\\"gender_output\\\")(x)\\n\\n return x\",\n \"def __init__(self, in_channels, num_classes):\\n super(InceptionAux, self).__init__()\\n self.relu = nn.LeakyReLU()\\n self.dropout1 = nn.Dropout(p=0.5)\\n self.pool = nn.AvgPool2d(kernel_size=5, stride=3)\\n self.conv = conv_block(in_channels, 128, kernel_size=1)\\n self.fc1 = nn.Linear(12800, 1024)\\n self.fc2 = nn.Linear(1024, 420)\\n self.dropout2 = nn.Dropout(p=0.4)\\n self.fc3 = nn.Linear(420,128)\\n self.dropout3 = nn.Dropout(p=0.4)\\n self.fc4 = nn.Linear(128,num_classes)\",\n \"def __init__(self):\\n super(Backbone, self).__init__()\\n\\n # input size: (128, 282, 282)\\n # Block 1:\\n # relu + 4 conv + bn\\n self.conv1 = torch.nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=0)\\n self.conv2 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\\n self.conv3 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\\n self.conv4 = torch.nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=0)\\n\\n self.bn1 = torch.nn.BatchNorm2d(64)\\n self.bn2 = torch.nn.BatchNorm2d(64)\\n self.bn3 = torch.nn.BatchNorm2d(64)\\n self.bn4 = torch.nn.BatchNorm2d(64)\\n\\n # Block 2:\\n # relu + 6 conv + stride 2 + bn\\n self.conv5 = torch.nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=0)\\n self.conv6 = torch.nn.Conv2d(128, 128, kernel_size=3, stride=2, padding=0)\\n self.conv7 = torch.nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=0)\\n self.conv8 = torch.nn.Conv2d(64, 32, kernel_size=3, stride=1, padding=0)\\n self.conv9 = torch.nn.Conv2d(32, 16, kernel_size=3, stride=1, padding=0)\\n self.conv10 = torch.nn.Conv2d(16, 8, kernel_size=3, stride=1, padding=0)\\n\\n self.bn5 = torch.nn.BatchNorm2d(128)\\n self.bn6 = torch.nn.BatchNorm2d(128)\\n self.bn7 = torch.nn.BatchNorm2d(64)\\n self.bn8 = torch.nn.BatchNorm2d(32)\\n self.bn9 = torch.nn.BatchNorm2d(16)\\n self.bn10 = torch.nn.BatchNorm2d(8)\\n\\n # Block 3:\\n # 2 fully connected with drop out.\\n\\n self.fc1 = torch.nn.Linear( 8 * 59 * 59, 32)\\n self.fc1_bn = torch.nn.BatchNorm1d(32)\\n self.fc_out = torch.nn.Linear(32, 3)\",\n \"def init_encoder(self):\\n\\n vgg = models.vgg16(pretrained=True)\\n\\n blocks = [self.layer_1,\\n self.layer_2,\\n self.layer_3,\\n self.layer_4,\\n self.layer_5]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\\n\\n blocks = [self.layer_11,\\n self.layer_12,\\n self.layer_13,\\n self.layer_14,\\n self.layer_15]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\",\n \"def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\\r\\n\\r\\n super().__init__()\\r\\n\\r\\n self.input_size = input_dim\\r\\n self.input_dim =input_dim\\r\\n\\r\\n if type(hidden_dim) != list:\\r\\n self.hidden_sizes = [hidden_dim]*num_layers\\r\\n else:\\r\\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\\r\\n self.hidden_sizes = hidden_dim\\r\\n if type(kernel_sizes) != list:\\r\\n self.kernel_sizes = [kernel_sizes]*num_layers\\r\\n else:\\r\\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\\r\\n self.kernel_sizes = kernel_sizes\\r\\n\\r\\n self.n_layers = num_layers\\r\\n\\r\\n cells = nn.ModuleList()\\r\\n squenceCells=nn.ModuleList()\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n if i == 0:\\r\\n input_dim = self.input_size\\r\\n else:\\r\\n input_dim = self.hidden_sizes[i-1]\\r\\n\\r\\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\\r\\n\\r\\n cells.append(cell)\\r\\n\\r\\n self.cells = cells\\r\\n\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n squenceCell = SequenceGRU(gb_hidden_size[i])\\r\\n\\r\\n squenceCells.append(squenceCell)\\r\\n\\r\\n self.squenceCells = squenceCells\",\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_discriminator():\\n leakyrelu_alpha = 0.2\\n momentum = 0.8\\n input_shape = (256, 256, 3)\\n\\n input_layer = Input(shape=input_shape)\\n\\n # Add the first convolution block\\n dis1 = Conv2D(filters=64, kernel_size=3, strides=1, padding='same')(input_layer)\\n dis1 = LeakyReLU(alpha=leakyrelu_alpha)(dis1)\\n\\n # Add the 2nd convolution block\\n dis2 = Conv2D(filters=64, kernel_size=3, strides=2, padding='same')(dis1)\\n dis2 = LeakyReLU(alpha=leakyrelu_alpha)(dis2)\\n dis2 = BatchNormalization(momentum=momentum)(dis2)\\n\\n # Add the third convolution block\\n dis3 = Conv2D(filters=128, kernel_size=3, strides=1, padding='same')(dis2)\\n dis3 = LeakyReLU(alpha=leakyrelu_alpha)(dis3)\\n dis3 = BatchNormalization(momentum=momentum)(dis3)\\n\\n # Add the fourth convolution block\\n dis4 = Conv2D(filters=128, kernel_size=3, strides=2, padding='same')(dis3)\\n dis4 = LeakyReLU(alpha=leakyrelu_alpha)(dis4)\\n dis4 = BatchNormalization(momentum=0.8)(dis4)\\n\\n # Add the fifth convolution block\\n dis5 = Conv2D(256, kernel_size=3, strides=1, padding='same')(dis4)\\n dis5 = LeakyReLU(alpha=leakyrelu_alpha)(dis5)\\n dis5 = BatchNormalization(momentum=momentum)(dis5)\\n\\n # Add the sixth convolution block\\n dis6 = Conv2D(filters=256, kernel_size=3, strides=2, padding='same')(dis5)\\n dis6 = LeakyReLU(alpha=leakyrelu_alpha)(dis6)\\n dis6 = BatchNormalization(momentum=momentum)(dis6)\\n\\n # Add the seventh convolution block\\n dis7 = Conv2D(filters=512, kernel_size=3, strides=1, padding='same')(dis6)\\n dis7 = LeakyReLU(alpha=leakyrelu_alpha)(dis7)\\n dis7 = BatchNormalization(momentum=momentum)(dis7)\\n\\n # Add the eight convolution block\\n dis8 = Conv2D(filters=512, kernel_size=3, strides=2, padding='same')(dis7)\\n dis8 = LeakyReLU(alpha=leakyrelu_alpha)(dis8)\\n dis8 = BatchNormalization(momentum=momentum)(dis8)\\n\\n # Add a dense layer\\n #avgd = keras.layers.AveragePooling2D(pool_size=(4,4) , strides = (4,4))(dis8)\\n\\n #flat = keras.layers.Flatten()(dis8)\\n dis9 = Dense(units=1024)(dis8)\\n dis9 = LeakyReLU(alpha=0.2)(dis9)\\n\\n # Last dense layer - for classification\\n output = Dense(units=1, activation='sigmoid')(dis9)\\n\\n model = Model(inputs=[input_layer], outputs=[output], name='discriminator')\\n return model\",\n \"def build_graph(self):\\n n_classes = self.n_classes\\n\\n (self.feed('data')\\n .conv(3, 3, 64, 1, 1, name='conv1_1', trainable=False)\\n .conv(3, 3, 64, 1, 1, name='conv1_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool1')\\n .conv(3, 3, 128, 1, 1, name='conv2_1', trainable=False)\\n .conv(3, 3, 128, 1, 1, name='conv2_2', trainable=False)\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool2')\\n .conv(3, 3, 256, 1, 1, name='conv3_1')\\n .conv(3, 3, 256, 1, 1, name='conv3_2')\\n .conv(3, 3, 256, 1, 1, name='conv3_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool3')\\n .conv(3, 3, 512, 1, 1, name='conv4_1')\\n .conv(3, 3, 512, 1, 1, name='conv4_2')\\n .conv(3, 3, 512, 1, 1, name='conv4_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool4')\\n .conv(3, 3, 512, 1, 1, name='conv5_1')\\n .conv(3, 3, 512, 1, 1, name='conv5_2')\\n .conv(3, 3, 512, 1, 1, name='conv5_3'))\\n\\n self.compute_rDeRF() # dummy\\n\\n # Classification\\n (self.feed('conv5_3')\\n .max_pool(2, 2, 2, 2, padding='VALID', name='pool6')\\n .reshape(shape=(-1, 7, 7, 512), name='pool6_reshape')\\n .fc(4096, name='fc6')\\n .dropout(0.5, name='drop6')\\n .fc(4096, name='fc7')\\n .dropout(0.5, name='drop7')\\n # .make_time(name='drop7_reduced')\\n .fc(n_classes, relu=False, name='cls_score')\\n .softmax(name='cls_prob'))\\n pass\",\n \"def __init__(self, in_channels, out_channels, kernel_size, stride, padding, dilation, dropout):\\n super().__init__()\\n # Padding on the left side\\n pad = torch.nn.ZeroPad2d((padding, 0, 0, 0))\\n # Convolutional network (we didnt include weight norms)\\n conv2d1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(1, kernel_size),\\n stride=stride, dilation=dilation)\\n elu = nn.ELU()\\n dropout = nn.Dropout(dropout)\\n conv2d2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(1, kernel_size),\\n stride=stride, dilation=dilation)\\n self.net = nn.Sequential(pad, conv2d1, elu, dropout, pad, conv2d2, elu, dropout)\",\n \"def densenet121(growth_rate=32, compression=1.0):\\n\\n init = K.initializers.he_normal(seed=None)\\n X = K.Input(shape=(224, 224, 3))\\n\\n batch_1 = K.layers.BatchNormalization()(X)\\n activation_1 = K.layers.Activation('relu')(batch_1)\\n\\n conv_1 = K.layers.Conv2D(filters=64,\\n kernel_size=7,\\n strides=2,\\n padding='same',\\n kernel_initializer=init)(activation_1)\\n max_pool = K.layers.MaxPooling2D(pool_size=[3, 3],\\n strides=2,\\n padding='same')(conv_1)\\n\\n ly_1, nb_filters1 = dense_block(max_pool, 64, growth_rate, 6)\\n\\n ly_2, nb_filters2 = transition_layer(ly_1, nb_filters1, compression)\\n ly_3, nb_filters3 = dense_block(ly_2, nb_filters2, growth_rate, 12)\\n\\n ly_4, nb_filters4 = transition_layer(ly_3, nb_filters3, compression)\\n ly_5, nb_filters5 = dense_block(ly_4, nb_filters4, growth_rate, 24)\\n\\n ly_6, nb_filters6 = transition_layer(ly_5, nb_filters5, compression)\\n ly_7, nb_filters7 = dense_block(ly_6, nb_filters6, growth_rate, 16)\\n\\n avg_pool = K.layers.AveragePooling2D(pool_size=[7, 7],\\n strides=7,\\n padding='same')(ly_7)\\n\\n dense = K.layers.Dense(1000, activation='softmax',\\n kernel_initializer=init)(avg_pool)\\n\\n model = K.models.Model(inputs=X, outputs=dense)\\n return model\",\n \"def detection_head_graph(self, feature_map, filters):\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_1\\\", use_bias=True, padding=\\\"same\\\")(feature_map)\\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_2\\\", use_bias=True, padding=\\\"same\\\")(x)\\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"final_stage\\\", use_bias=True, padding=\\\"same\\\")(x)\\n return x\",\n \"def define(self, optimizer = Adam(lr=1e-5)): \\n \\n self.optimizer = optimizer\\n\\n model = Sequential()\\n\\n #Layer 1\\n model.add(Conv2D( filters = 96, \\n kernel_size = (11,11), \\n strides = 4, \\n padding = 'same', \\n activation = 'relu', \\n input_shape = (224, 224, 3), \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) # overlapping pooling\\n #Layer 2\\n model.add(Conv2D( filters = 256, \\n kernel_size = (5,5), \\n strides = 1, \\n padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) \\n #Layer 3\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', kernel_initializer = 'he_normal'))\\n #Layer 4\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 5\\n model.add(Conv2D( filters = 256, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 6\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None))\\n \\n #Layer 7\\n model.add(Flatten())\\n \\n #Layer 8\\n model.add(Dense( units = 4096, activation = 'relu'))\\n model.add(Dense( units = 1024, activation = 'relu'))\\n model.add(Dense( units = 512, activation = 'relu'))\\n model.add(Dense( units = 256, activation = 'relu'))\\n model.add(Dense( units = 128, activation = 'relu'))\\n \\n #Layer end\\n model.add(Dense( units = 3, activation = 'softmax'))\\n model.summary()\\n \\n self.model = model\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def build_network(self):\\n\\n input_placeholder = Input(shape = self.input_shape)\\n\\n # Stage 1\\n x = self.main_path_block(\\n input_placeholder,\\n 64, (7, 7), 'same',\\n 'conv1', 'bn_conv1',\\n activation = 'relu',\\n strides = (2, 2)\\n )\\n x = MaxPooling2D((3, 3), strides = (2, 2), padding = 'same')(x)\\n\\n # Stage 2\\n x = self.identity_block(x, 64, 'relu', 2, 'a', False)\\n x = self.identity_block(x, 64, 'relu', 2, 'b')\\n\\n # Stage 3\\n x = self.convolutional_block(x, [128, 128, 128], 'relu', 3, 'a')\\n x = self.identity_block(x, 128, 'relu', 3, 'b')\\n\\n # Stage 4\\n x = self.convolutional_block(x, [256, 256, 256], 'relu', 4, 'a')\\n x = self.identity_block(x, 256, 'relu', 4, 'b')\\n\\n # Stage 5\\n x = self.convolutional_block(x, [512, 512, 512], 'relu', 5, 'a')\\n x = self.identity_block(x, 512, 'relu', 4, 'b')\\n\\n # Fully Connected Layers\\n x = BatchNormalization(axis = 3)(x)\\n x = Activation('relu')(x)\\n x = AveragePooling2D((2, 1), padding = 'valid', strides = (2, 2))(x)\\n x = Flatten()(x)\\n x = Dense(512)\\n x = Dense(\\n self.classes, activation = 'softmax',\\n name = 'fc_' + str(self.classes),\\n kernel_initializer = glorot_uniform(seed = 0)\\n )(x)\\n\\n self.model = Model(input_placeholder, x, name = 'Resnet18')\",\n \"def faceRecoModel(input_shape):\\n\\n # Define the input as a tensor with shape input_shape\\n X_input = Input(input_shape)\\n\\n # Zero-Padding\\n X = ZeroPadding2D((3, 3))(X_input)\\n\\n # First Block\\n X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(X)\\n X = BatchNormalization(axis=1, name='bn1')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n X = MaxPooling2D((3, 3), strides=2)(X)\\n\\n # Second Block\\n X = Conv2D(64, (1, 1), strides=(1, 1), name='conv2')(X)\\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn2')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n\\n # Second Block\\n X = Conv2D(192, (3, 3), strides=(1, 1), name='conv3')(X)\\n X = BatchNormalization(axis=1, epsilon=0.00001, name='bn3')(X)\\n X = Activation('relu')(X)\\n\\n # Zero-Padding + MAXPOOL\\n X = ZeroPadding2D((1, 1))(X)\\n X = MaxPooling2D(pool_size=3, strides=2)(X)\\n\\n # Inception 1: a/b/c\\n X = inception_block_1a(X)\\n X = inception_block_1b(X)\\n X = inception_block_1c(X)\\n\\n # Inception 2: a/b\\n X = inception_block_2a(X)\\n X = inception_block_2b(X)\\n\\n # Inception 3: a/b\\n X = inception_block_3a(X)\\n X = inception_block_3b(X)\\n\\n # Top layer\\n X = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\\n X = Flatten()(X)\\n X = Dense(128, name='dense_layer')(X)\\n\\n # L2 normalization\\n X = Lambda(lambda x: tf.nn.l2_normalize(x, dim=1))(X)\\n\\n # Create model instance\\n model = Model(inputs=X_input, outputs=X, name='FaceRecoModel')\\n\\n return model\",\n \"def build_dc_classifier():\\n # return nn.Sequential(\\n # Unflatten(Batch_size, 1, 28, 28),\\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(2, stride=2),\\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(kernel_size=2, stride=2),\\n # Flatten(),\\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.Linear(4 * 4 * 64, 1)\\n # )\\n\\n return nn.Sequential(\\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\\n Flatten(),\\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\\n )\",\n \"def __init__(self, nfeat, nhid, nclass, dropout, alpha):\\n super(GCN, self).__init__()\\n self.dropout = dropout\\n\\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\\n \\n self.add_module('conv1', self.conv1)\\n\\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)\",\n \"def create_vgg_down_block(filters, in_features, activation, kernel_size=3, strategy='stride', batch_norm=False):\\n layers = []\\n if isinstance(filters, int):\\n filters = [filters]\\n\\n if not isinstance(filters, list):\\n raise ValueError(\\\"Filters has to be a list\\\")\\n\\n in_feat = in_features\\n for n in range(len(filters))[:-1]:\\n out_feat = filters[n]\\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\\n layers.append(conv)\\n in_feat = out_feat\\n\\n layers.append(Conv2d_Down(in_features=in_feat, out_features=filters[-1], activation=activation, kernel_size=kernel_size, strategy=strategy, batch_norm=batch_norm))\\n out_feat = filters[-1]\\n return layers, out_feat\",\n \"def __init__(self, ):\\n super().__init__()\\n channels = 3\\n\\n # Initial convolution block\\n out_features = 64\\n # encoder\\n self.input = nn.Sequential(\\n nn.ReflectionPad2d(channels),\\n nn.Conv2d(3, out_features, (7, 7)),\\n nn.InstanceNorm2d(out_features),\\n nn.MaxPool2d(2),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Conv2d(out_features, out_features * 2, (3, 3), stride=(1, 1), padding=(1, 1)),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.MaxPool2d(2),\\n nn.Conv2d(out_features * 2, out_features * 4, (3, 3), stride=(1, 1), padding=(1, 1)),\\n nn.LeakyReLU(0.2, inplace=True),\\n )\\n\\n self.in0 = nn.InstanceNorm2d(256)\\n self.block0 = blocks()\\n self.block1 = blocks()\\n self.block2 = blocks()\\n self.block3 = blocks()\\n self.block4 = blocks()\\n self.block5 = blocks()\\n self.block6 = blocks()\\n self.block7 = blocks()\\n\\n self.out = nn.Sequential(\\n\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(out_features * 4, out_features * 2, 3, stride=1, padding=1),\\n nn.InstanceNorm2d(out_features * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(out_features * 2, out_features, 3, stride=1, padding=1),\\n nn.InstanceNorm2d(out_features),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n nn.ReflectionPad2d(channels),\\n nn.Conv2d(out_features, channels, 7),\\n nn.Tanh(),\\n )\",\n \"def __init__(self, dropout_rate=0.0, in_channels=3):\\n\\n super(MaskNet, self).__init__()\\n\\n self.prep_block_1 = nn.Sequential(\\n nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=3, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(32),\\n nn.Dropout(dropout_rate),\\n )\\n self.prep_block_2 = nn.Sequential(\\n nn.Conv2d(in_channels=in_channels, out_channels=32, kernel_size=3, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(32),\\n nn.Dropout(dropout_rate),\\n )\\n\\n self.convblock1 = nn.Sequential(\\n nn.Conv2d(in_channels=64, out_channels=32, kernel_size=1, padding=0),\\n nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(64),\\n nn.Dropout(dropout_rate),\\n )\\n\\n self.convblock2 = nn.Sequential(\\n nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1),\\n nn.ReLU(),\\n nn.BatchNorm2d(64),\\n nn.Dropout(dropout_rate),\\n )\\n\\n self.convblock3 = nn.Sequential(\\n nn.Conv2d(in_channels=64, out_channels=1, kernel_size=1, padding=0),\\n )\",\n \"def BasicBlock(cin, cout, n):\\n layers = [\\n nn.Conv2d(cin, cout, 3, padding=1),\\n nn.BatchNorm2d(cout),\\n nn.ReLU()\\n ]\\n for _ in range(n - 1):\\n layers.append(nn.Conv2d(cout, cout, 3, padding=1))\\n layers.append(nn.BatchNorm2d(cout))\\n layers.append(nn.ReLU())\\n layers.append(nn.MaxPool2d(2))\\n return nn.Sequential(*layers)\",\n \"def _init_layers(self):\\n self.relu = nn.ReLU(inplace=True)\\n self.rpn_convs = nn.ModuleList()\\n for i in range(self.stacked_convs):\\n chn = self.in_channels if i == 0 else self.feat_channels\\n self.rpn_convs.append(\\n ConvModule(\\n chn,\\n self.feat_channels,\\n 3,\\n stride=1,\\n padding=1,\\n conv_cfg=self.conv_cfg,\\n norm_cfg=self.norm_cfg))\\n self.rpn_cls = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 1, 3, padding=1)\\n self.rpn_reg = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 4 * (self.reg_max + 1), 3, padding=1)\\n self.rpn_iou = nn.Conv2d(\\n self.feat_channels, self.num_anchors * 1, 3, padding=1)\\n self.scales = nn.ModuleList(\\n [Scale(1.0) for _ in self.anchor_generator.strides])\\n\\n ##############V2################\\n conf_vector = [nn.Conv2d(self.num_anchors * 4 * self.total_dim, self.num_anchors * self.reg_channels, 1)]\\n conf_vector += [self.relu]\\n conf_vector += [nn.Conv2d(self.num_anchors * self.reg_channels, self.num_anchors, 1), nn.Sigmoid()]\\n\\n self.reg_conf = nn.Sequential(*conf_vector)\\n ##############V2################\",\n \"def discriminator_block(in_filters, out_filters, normalization=True):\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def build_model(self):\\n\\n input_placeholder = Input(shape = self.input_shape)\\n x = ZeroPadding2D((3, 3))(input_placeholder)\\n\\n # Stage 1\\n x = self.main_path_block(x, 64, (7, 7), 'valid', 'conv1', 'bn_conv1', 'relu', (2, 2))\\n x = MaxPooling2D((3, 3), strides = (2, 2))(x)\\n\\n # Stage 2\\n x = self.convolutional_block(x, 3, [64, 64, 256], 2, 'a', 1)\\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'b')\\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'c')\\n\\n # Stage 3\\n x = self.convolutional_block(x, 3, [128, 128, 512], 3, 'a', 2)\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'b')\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'c')\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'd')\\n\\n # Stage 4\\n x = self.convolutional_block(x, 3, [256, 256, 1024], 4, 'a', 2)\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'b')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'c')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'd')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'e')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'f')\\n\\n # Stage 5\\n x = self.convolutional_block(x, 3, [512, 512, 2048], 5, 'a', 2)\\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'b')\\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'c')\\n \\n # Average Pooling Layer\\n x = AveragePooling2D((2, 2), name = 'avg_pool')(x)\\n \\n # Fully Connected Layer\\n x = Flatten()(x)\\n x = Dense(\\n self.classes,\\n activation = 'softmax',\\n name = 'fc_' + str(self.classes),\\n kernel_initializer = glorot_uniform(seed = 0)\\n )(x)\\n\\n self.model = Model(input_placeholder, x, name = 'Resnet50')\",\n \"def dense_block(X, nb_filters, growth_rate, layers):\\n init = K.initializers.he_normal()\\n\\n for i in range(layers):\\n batch = K.layers.BatchNormalization()(X)\\n act = K.layers.Activation(K.activations.relu)(batch)\\n conv = K.layers.Conv2D(growth_rate * 4, (1, 1), padding='same',\\n strides=1,\\n kernel_initializer=init)(act)\\n batch = K.layers.BatchNormalization()(conv)\\n act = K.layers.Activation(K.activations.relu)(batch)\\n conv = K.layers.Conv2D(growth_rate, (3, 3), padding='same',\\n strides=1,\\n kernel_initializer=init)(act)\\n X = K.layers.concatenate([X, conv], axis=3)\\n nb_filters += growth_rate\\n return X, nb_filters\",\n \"def default_branch_layers(\\n inputs, \\n kernel_initializer=None,\\n **kwargs\\n):\\n return sequential(\\n inputs=inputs, \\n layers=[\\n (k.layers.Conv2D,\\n {'filters':32, 'kernel_size':8, 'strides':4, 'activation':'relu', \\n 'padding':'same'}),\\n (k.layers.Conv2D,\\n {'filters':64, 'kernel_size':4, 'dilation_rate':2, \\n 'activation':'relu', 'padding':'same'}),\\n (k.layers.Conv2D,\\n {'filters':64, 'kernel_size':3, 'activation':'relu', \\n 'padding':'same'}),\\n (k.layers.UpSampling2D, {'size':4, 'interpolation':'bilinear'})\\n ],\\n kernel_initializer=kernel_initializer,\\n **kwargs,\\n )\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n layers = []\\n in_filters = channels\\n for out_filters, stride, normalize in [ (64, 2, False),\\n (128, 2, True),\\n (256, 2, True),\\n (512, 1, True)]:\\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\\n in_filters = out_filters\\n\\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\\n\\n self.model = nn.Sequential(*layers)\\n\\n \\\"\\\"\\\"CycleGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalize=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels, 64, normalize=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n *discriminator_block(256, 512),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(512, 1, 4, padding=1)\\n )\\n\\n \\\"\\\"\\\"DCGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\\n nn.Sigmoid())\\n\\n\\n \\\"\\\"\\\"DiscoGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalization=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels, 64, normalization=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(256, 1, 4, padding=1)\\n )\\n\\n \\\"\\\"\\\"DraGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Sequential( nn.Linear(128*ds_size**2, 1),\\n nn.Sigmoid())\\n\\n \\\"\\\"\\\"EBGAN\\n \\\"\\\"\\\"\\n # Upsampling\\n self.down = nn.Sequential(\\n nn.Conv2d(opt.channels, 64, 3, 2, 1),\\n nn.ReLU(),\\n )\\n # Fully-connected layers\\n self.down_size = (opt.img_size // 2)\\n down_dim = 64 * (opt.img_size // 2)**2\\n\\n self.embedding = nn.Linear(down_dim, 32)\\n\\n self.fc = nn.Sequential(\\n nn.BatchNorm1d(32, 0.8),\\n nn.ReLU(inplace=True),\\n nn.Linear(32, down_dim),\\n nn.BatchNorm1d(down_dim),\\n nn.ReLU(inplace=True)\\n )\\n # Upsampling\\n self.up = nn.Sequential(\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(64, opt.channels, 3, 1, 1)\\n )\\n\\n \\\"\\\"\\\"InfoGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n \\\"\\\"\\\"Returns layers of each discriminator block\\\"\\\"\\\"\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.conv_blocks = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n\\n # Output layers\\n self.adv_layer = nn.Sequential(nn.Linear(128*ds_size**2, 1))\\n self.aux_layer = nn.Sequential(\\n nn.Linear(128*ds_size**2, opt.n_classes),\\n nn.Softmax()\\n )\\n self.latent_layer = nn.Sequential(nn.Linear(128*ds_size**2, opt.code_dim))\\n\\n \\\"\\\"\\\"LSGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, bn=True):\\n block = [ nn.Conv2d(in_filters, out_filters, 3, 2, 1),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Dropout2d(0.25)]\\n if bn:\\n block.append(nn.BatchNorm2d(out_filters, 0.8))\\n return block\\n\\n self.model = nn.Sequential(\\n *discriminator_block(opt.channels, 16, bn=False),\\n *discriminator_block(16, 32),\\n *discriminator_block(32, 64),\\n *discriminator_block(64, 128),\\n )\\n\\n # The height and width of downsampled image\\n ds_size = opt.img_size // 2**4\\n self.adv_layer = nn.Linear(128*ds_size**2, 1)\\n\\n \\\"\\\"\\\"Pix2Pix\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, normalization=True):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n self.model = nn.Sequential(\\n *discriminator_block(in_channels*2, 64, normalization=False),\\n *discriminator_block(64, 128),\\n *discriminator_block(128, 256),\\n *discriminator_block(256, 512),\\n nn.ZeroPad2d((1, 0, 1, 0)),\\n nn.Conv2d(512, 1, 4, padding=1, bias=False)\\n )\\n\\n \\\"\\\"\\\"Pixelda\\n \\\"\\\"\\\"\\n def block(in_features, out_features, normalization=True):\\n \\\"\\\"\\\"Discriminator block\\\"\\\"\\\"\\n layers = [ nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),\\n nn.LeakyReLU(0.2, inplace=True) ]\\n if normalization:\\n layers.append(nn.InstanceNorm2d(out_features))\\n return layers\\n\\n self.model = nn.Sequential(\\n *block(opt.channels, 64, normalization=False),\\n *block(64, 128),\\n *block(128, 256),\\n *block(256, 512),\\n nn.Conv2d(512, 1, 3, 1, 1))\\n\\n \\\"\\\"\\\"SRGAN\\n \\\"\\\"\\\"\\n def discriminator_block(in_filters, out_filters, stride, normalize):\\n \\\"\\\"\\\"Returns layers of each discriminator block\\\"\\\"\\\"\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.BatchNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\\n\\n layers = []\\n in_filters = in_channels\\n for out_filters, stride, normalize in [ (64, 1, False),\\n (64, 2, True),\\n (128, 1, True),\\n (128, 2, True),\\n (256, 1, True),\\n (256, 2, True),\\n (512, 1, True),\\n (512, 2, True),]:\\n layers.extend(discriminator_block(in_filters, out_filters, stride, normalize))\\n in_filters = out_filters\\n\\n # Output layer\\n layers.append(nn.Conv2d(out_filters, 1, 3, 1, 1))\\n\\n self.model = nn.Sequential(*layers)\\n\\n \\\"\\\"\\\"StarGAN\\n \\\"\\\"\\\"\\n channels, img_size, _ = img_shape\\n\\n def discriminator_block(in_filters, out_filters):\\n \\\"\\\"\\\"Returns downsampling layers of each discriminator block\\\"\\\"\\\"\\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\\n nn.LeakyReLU(0.01)]\\n return layers\\n\\n layers = discriminator_block(channels, 64)\\n curr_dim = 64\\n for _ in range(n_strided - 1):\\n layers.extend(discriminator_block(curr_dim, curr_dim*2))\\n curr_dim *= 2\\n\\n self.model = nn.Sequential(*layers)\\n\\n # Output 1: PatchGAN\\n self.out1 = nn.Conv2d(curr_dim, 1, 3, padding=1, bias=False)\\n # Output 2: Class prediction\\n kernel_size = img_size // 2**n_strided\\n self.out2 = nn.Conv2d(curr_dim, c_dim, kernel_size, bias=False)\\n\\n \\\"\\\"\\\"WGAN\\n \\\"\\\"\\\"\\n nn.Linear(int(np.prod(img_shape)), 512),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Linear(512, 256),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Linear(256, 1)\\n\\n \\n\\n\\n# import torch.nn as nn\\n# import torch\\n# from torch.nn.modules import conv, Linear\\n# import torch.nn.functional as F\\n# from src.snlayers.snconv2d import SNConv2d\\n\\n# class _netG(nn.Module):\\n# def __init__(self, nz, nc, ngf):\\n# super(_netG, self).__init__()\\n# self.main = nn.Sequential(\\n# # input is Z, going into a convolution\\n# nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=True),\\n# nn.BatchNorm2d(ngf * 8),\\n# nn.ReLU(True),\\n# # state size. (ngf*8) x 4 x 4\\n# nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf * 4),\\n# nn.ReLU(True),\\n# # state size. (ngf*4) x 8 x 8\\n# nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf * 2),\\n# nn.ReLU(True),\\n# # state size. (ngf*2) x 16 x 16\\n# nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=True),\\n# nn.BatchNorm2d(ngf),\\n# nn.ReLU(True),\\n# # state size. (ngf) x 32 x 32\\n# nn.ConvTranspose2d(ngf, nc, 3, 1, 1, bias=True),\\n# nn.Tanh()\\n# # state size. (nc) x 32 x 32\\n# )\\n\\n# def forward(self, input):\\n# output = self.main(input)\\n# return output\\n\\n# # Actor\\n# class _netE(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netE, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# SNConv2d(nc, ndf, 7, 4, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, 3, 7, 4, 1, bias=False),\\n# nn.Sigmoid()\\n# )\\n# def forward(self, input):\\n# output = self.main(input) \\n# return output.view(-1, 3).squeeze(1)\\n\\n# class _netD1(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD1, self).__init__()\\n\\n self.main = nn.Sequential(\\n SNConv2d(nc, ndf, 5, 2, 2), \\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf, ndf * 2, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 2, ndf * 4, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 4, ndf * 8, 5, 2, 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n SNConv2d(ndf * 8, 1, 4),\\n nn.Sigmoid()\\n\\n # input is (nc) x 64 x 64\\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf) x 32 x 32\\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*2) x 16 x 16\\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*4) x 8 x 8\\n nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 8),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*8) x 4 x 4\\n nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\\n nn.Sigmoid()\\n\\n # input is (nc) x 64 x 64\\n nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf) x 32 x 32\\n nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*2) x 16 x 16\\n nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Conv2d(ndf * 4, ndf * 16, 4, 2, 1, bias=False),\\n nn.BatchNorm2d(ndf * 16),\\n nn.LeakyReLU(0.2, inplace=True),\\n # state size. (ndf*16) x 4 x 4\\n nn.Conv2d(ndf * 16, 1, 4, 1, 0, bias=False),\\n nn.Sigmoid()\\n # )\\n # def forward(self, input):\\n # output = self.main(input)\\n # output = output.view(-1, 1).squeeze(1)\\n # return output\\n\\n# class _netD2(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD2, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, ndf, 16, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # ndf x 30 x 30\\n\\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 2, ndf * 2, 16, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # (ndf * 2) x 9 x 9\\n\\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 4, 1, 9, 1, 0, bias=False),\\n# nn.Sigmoid()\\n# # 1 x 1 x 1\\n# )\\n# def forward(self, input):\\n# output = self.main(input)\\n# return output.view(-1, 1).squeeze(1)\\n\\n# class _netD3(nn.Module):\\n# def __init__(self, nc, ndf):\\n# super(_netD3, self).__init__()\\n\\n# self.main = nn.Sequential(\\n# # input is (nc) x 32 x 32\\n# SNConv2d(nc, ndf, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf, ndf, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # state size. (ndf) x 1 x 32\\n# SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf*2, ndf * 2, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# # state size. (ndf*2) x 16 x 16\\n# SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n\\n# SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 8, ndf * 8, 4, 2, 1, bias=True),\\n\\n# # state size. (ndf*8) x 4 x 4\\n# SNConv2d(ndf * 8, ndf * 16, 3, 1, 1, bias=True),\\n# nn.LeakyReLU(0.1, inplace=True),\\n# SNConv2d(ndf * 16, 1, 4, 1, 0, bias=False),\\n# nn.Sigmoid()\\n# )\\n# def forward(self, input):\\n# output = self.main(input)\\n# output = output.view(-1, 1).squeeze(1)\\n# return output\\n\\n\\n# _netD_list = [_netD1]\",\n \"def _make_conv_layers(self):\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def detect_function(frame, faceNet, ageNet, minConf=0.5):\\n # Define the list of age range \\n AGE_RAN = [\\\"(0-2)\\\", \\\"(4-6)\\\", \\\"(8-12)\\\", \\\"(15-20)\\\", \\\"(25-32)\\\", \\\"(38-43)\\\", \\\"(48-53)\\\", \\\"(60-100)\\\"]\\n \\n # Initialize the results list\\n results = []\\n (h, w) = frame.shape[:2] # extacting the image coordinates\\n # To preprocess the image\\n blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300), (104.0, 177.0, 123.0))\\n \\n # Passing the transformed image through the network and obtain the face detections\\n faceNet.setInput(blob)\\n detections = faceNet.forward()\\n \\n # Loop for the prediction on each image\\n for i in range(0, detections.shape[2]):\\n \\n # Extract the confidence for all predictions\\n confidence = detections[0, 0, i, 2]\\n \\n # Condition to eliminate the low confidences\\n if confidence > minConf:\\n \\n # grabbing the coordinates of the detected faces\\n box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\\n (X, Y, dX, dY) = box.astype(\\\"int\\\")\\n \\n # Defining the region of interest to each detected face and applying the blob to them\\n face = frame[Y:dY, X:dX]\\n # Ensure that the ROI is sufficiently large\\n \\n if face.shape[0] < 20 or face.shape[1] < 20:\\n continue\\n faceBlob = cv2.dnn.blobFromImage(face, 1.0, (227, 227), (78.4263377603, 87.7689143744, 114.895847746),\\n swapRB=False)\\n \\n # Making the age prediction\\n ageNet.setInput(faceBlob)\\n preds = ageNet.forward() # age predictions\\n i = preds[0].argmax() # grab the great confidence\\n age = AGE_RAN[i] # grab the age range\\n ageConfidence = preds[0][i] # putting the confidence\\n \\n # Dictionary with ROI and predictions\\n d = {\\\"loc\\\": (X, Y, dX, dY),\\n \\\"age\\\": (age, ageConfidence)}\\n results.append(d) # appending the results into the the results list\\n \\n return results\",\n \"def vanilla_unet(input_shape=(512, 512, 3), base_depth=32, drop_rate=0,\\n seed=1337):\\n input = Input(input_shape)\\n\\n conv1 = Conv2D(base_depth, 3, activation='relu', padding='same')(input)\\n bn1 = BatchNormalization()(conv1)\\n drop1 = Dropout(drop_rate, seed=seed)(bn1)\\n conv2 = Conv2D(base_depth, 3, activation='relu', padding='same')(drop1)\\n bn2 = BatchNormalization()(conv2)\\n mp1 = MaxPooling2D(pool_size=(2, 2))(bn2)\\n\\n conv3 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(mp1)\\n bn3 = BatchNormalization()(conv3)\\n drop2 = Dropout(drop_rate, seed=seed+1)(bn3)\\n conv4 = Conv2D(base_depth*2, 3, activation='relu', padding='same')(drop2)\\n bn4 = BatchNormalization()(conv4)\\n mp2 = MaxPooling2D(pool_size=(2, 2))(bn4)\\n\\n conv5 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(mp2)\\n bn5 = BatchNormalization()(conv5)\\n drop3 = Dropout(drop_rate, seed=seed+2)(bn5)\\n conv6 = Conv2D(base_depth*4, 3, activation='relu', padding='same')(drop3)\\n bn6 = BatchNormalization()(conv6)\\n mp3 = MaxPooling2D(pool_size=(2, 2))(bn6)\\n\\n conv7 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(mp3)\\n bn7 = BatchNormalization()(conv7)\\n drop4 = Dropout(drop_rate, seed=seed+3)(bn7)\\n conv8 = Conv2D(base_depth*8, 3, activation='relu', padding='same')(drop4)\\n bn8 = BatchNormalization()(conv8)\\n mp4 = MaxPooling2D(pool_size=(2, 2))(bn8)\\n\\n conv9 = Conv2D(base_depth*16, 3, activation='relu', padding='same')(mp4)\\n bn9 = BatchNormalization()(conv9)\\n drop5 = Dropout(drop_rate, seed=seed+4)(bn9)\\n deconv0 = Conv2DTranspose(base_depth*16, 3, activation='relu',\\n padding='same')(drop5)\\n bn10 = BatchNormalization()(deconv0)\\n up1 = UpSampling2D(interpolation='bilinear')(bn10)\\n\\n deconv1 = Conv2DTranspose(base_depth*8, 3, activation='relu',\\n padding='same')(up1)\\n bn11 = BatchNormalization()(deconv1)\\n cat1 = concatenate([bn11, bn8])\\n drop6 = Dropout(drop_rate, seed=seed+5)(cat1)\\n deconv2 = Conv2DTranspose(base_depth*8, 3, activation='relu',\\n padding='same')(drop6)\\n bn12 = BatchNormalization()(deconv2)\\n up2 = UpSampling2D(interpolation='bilinear')(bn12)\\n\\n deconv3 = Conv2DTranspose(base_depth*4, 3, activation='relu',\\n padding='same')(up2)\\n bn13 = BatchNormalization()(deconv3)\\n cat2 = concatenate([bn13, bn6])\\n drop7 = Dropout(drop_rate, seed=seed+6)(cat2)\\n deconv4 = Conv2DTranspose(base_depth*4, 3, activation='relu',\\n padding='same')(drop7)\\n bn14 = BatchNormalization()(deconv4)\\n up3 = UpSampling2D(interpolation='bilinear')(bn14)\\n\\n deconv5 = Conv2DTranspose(base_depth*2, 3, activation='relu',\\n padding='same')(up3)\\n bn15 = BatchNormalization()(deconv5)\\n cat3 = concatenate([bn15, bn4])\\n drop8 = Dropout(drop_rate, seed=seed+7)(cat3)\\n deconv6 = Conv2DTranspose(base_depth*2, 3, activation='relu',\\n padding='same')(drop8)\\n bn16 = BatchNormalization()(deconv6)\\n up4 = UpSampling2D(interpolation='bilinear')(bn16)\\n\\n deconv7 = Conv2DTranspose(base_depth, 3, activation='relu',\\n padding='same')(up4)\\n bn17 = BatchNormalization()(deconv7)\\n cat4 = concatenate([bn17, bn2])\\n drop7 = Dropout(drop_rate, seed=seed+8)(cat4)\\n deconv8 = Conv2DTranspose(base_depth, 3, activation='relu',\\n padding='same')(drop7)\\n bn18 = BatchNormalization()(deconv8)\\n\\n out = Conv2DTranspose(1, 1, activation='sigmoid', padding='same')(bn18)\\n\\n return Model(input, out)\",\n \"def __init__(\\n self, \\n dim_feat_raw, \\n dim_feat_smooth, \\n dim_label_raw, \\n dim_label_smooth, \\n arch_gnn, \\n aug_feat,\\n num_ensemble, \\n train_params\\n ):\\n super().__init__()\\n self.mulhead = 1\\n self.num_layers = arch_gnn[\\\"num_layers\\\"]\\n self.dropout, self.dropedge = train_params[\\\"dropout\\\"], train_params['dropedge']\\n self.mulhead = int(arch_gnn[\\\"heads\\\"]) # only useful for GAT\\n\\n self.branch_sharing = arch_gnn['branch_sharing'] # only for ensemble\\n\\n self.type_feature_augment = aug_feat\\n assert dim_feat_raw <= dim_feat_smooth, \\\"smoothened feature cannot have smaller shape than the original one\\\"\\n # NOTE: dim_label_raw may be larger than dim_label_smooth ==> label is not used as input\\n self.num_classes = dim_label_raw\\n self.dim_label_in = dim_label_smooth\\n self.dim_feat_in = dim_feat_smooth\\n self.dim_hidden = arch_gnn['dim']\\n # build the model below\\n dim, act = arch_gnn['dim'], arch_gnn['act']\\n self.aug_layers, self.conv_layers, self.res_pool_layers = [], [], []\\n for i in range(num_ensemble):\\n # feat aug\\n if len(self.type_feature_augment) > 0:\\n self.aug_layers.append(nn.ModuleList(\\n nn.Linear(_dim, self.dim_feat_in) for _, _dim in self.type_feature_augment\\n ))\\n # graph convs\\n convs = []\\n if i == 0 or not self.branch_sharing:\\n for j in range(arch_gnn['num_layers']):\\n cls_gconv = DeepGNN.NAME2CLS[arch_gnn['aggr']]\\n dim_in = (self.dim_feat_in + self.dim_label_in) if j == 0 else dim\\n convs.append(cls_gconv(dim_in, dim, dropout=self.dropout, act=act, mulhead=self.mulhead))\\n self.conv_layers.append(nn.Sequential(*convs))\\n else: # i > 0 and branch_sharing\\n self.conv_layers.append(self.conv_layers[-1])\\n # skip-pooling layer\\n type_res = arch_gnn['residue'].lower()\\n type_pool = arch_gnn['pooling'].split('-')[0].lower()\\n cls_res_pool = layers.ResPool\\n args_pool = {}\\n if type_pool == 'sort':\\n args_pool['k'] = int(arch_gnn['pooling'].split('-')[1])\\n self.res_pool_layers.append(\\n cls_res_pool(dim, dim, arch_gnn['num_layers'], type_res, type_pool,\\n dropout=self.dropout, act=act, args_pool=args_pool\\n ))\\n if len(self.aug_layers) > 0:\\n self.aug_layers = nn.ModuleList(self.aug_layers)\\n self.conv_layers = nn.ModuleList(self.conv_layers)\\n self.res_pool_layers = nn.ModuleList(self.res_pool_layers)\\n # ------- ensembler + classifier -------\\n if num_ensemble == 1:\\n self.ensembler = layers.EnsembleDummy()\\n else:\\n self.ensembler = layers.EnsembleAggregator(dim, dim, num_ensemble, dropout=self.dropout, \\n type_dropout=train_params[\\\"ensemble_dropout\\\"], act=arch_gnn[\\\"ensemble_act\\\"])\\n self.classifier = DeepGNN.NAME2CLS['mlp'](dim, self.num_classes, act='I', dropout=0.)\\n # ---- optimizer, etc. ----\\n self.lr = train_params[\\\"lr\\\"]\\n self.sigmoid_loss = arch_gnn[\\\"loss\\\"] == \\\"sigmoid\\\"\\n self.loss, self.opt_op = 0, None\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\\n\\n self.num_ensemble = num_ensemble\",\n \"def generator():\\n\\n model = Sequential()\\n\\n in_shape = 100\\n\\n depth = 256\\n\\n model.add(Dense(depth * 7 * 7, input_shape=(in_shape,)))\\n model.add(BatchNormalization(momentum=0.9)) # add the momentum\\n # model.add(Activation('relu')) # pass the vector through a relu\\n model.add(LeakyReLU(alpha=0.2))\\n\\n model.add(Reshape((7, 7, depth))) # reshape to depth number of 7x7 images\\n model.add(Dropout(0.4))\\n\\n model.add(UpSampling2D())\\n model.add(Conv2DTranspose(int(depth / 2), 5, padding='same'))\\n model.add(BatchNormalization(momentum=0.9))\\n # model.add(Activation('relu'))\\n model.add(LeakyReLU(alpha=0.2))\\n\\n model.add(UpSampling2D())\\n model.add(Conv2DTranspose(int(depth / 4), 5, padding='same'))\\n model.add(BatchNormalization(momentum=0.9))\\n # model.add(Activation('relu'))\\n model.add(LeakyReLU(alpha=0.2))\\n\\n model.add(Conv2DTranspose(int(depth / 8), 5, padding='same'))\\n model.add(BatchNormalization(momentum=0.9))\\n # model.add(Activation('relu'))\\n model.add(LeakyReLU(alpha=0.2))\\n\\n model.add(Conv2DTranspose(1, 5, padding='same'))\\n model.add(Activation('sigmoid'))\\n\\n # model.summary()\\n\\n noise = Input(shape=(in_shape,))\\n img = model(noise)\\n\\n return Model(noise, img)\\n\\n # return model\",\n \"def create_model(input_shape=None):\\n\\n model = Sequential()\\n #n,height,width,chennel = input_shape\\n height = 146\\n width = 243\\n chennel = 3\\n\\n model.add(Conv2D(filters=4, input_shape=(width, height, chennel), kernel_size=(3, 3), padding='same'))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=4,kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=4, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=16, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=8, kernel_size=(3, 3)))\\n model.add(Activation('relu'))\\n model.add(Conv2D(filters=16, kernel_size=(5, 5)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Flatten())\\n model.add(Dense(64))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.25))\\n model.add(Dense(32))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.25))\\n model.add(Dense(8))\\n model.add(Activation('softmax'))\\n\\n sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.87, nesterov=True)\\n model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=[\\\"accuracy\\\"])\\n return model\",\n \"def _build(self, generation):\\n with tf.variable_scope ('discriminator') as scope:\\n \\n image_unflatten = unflatten_layer ( self.images )\\n gen_unflatten = unflatten_layer ( generation )\\n\\n # Conv Layer 1 - image\\n conv1_out_image, params = conv_2d_layer (\\n input = image_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'conv_1_img',\\n visualize = True ) \\n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \\n \\n # Conv Layer 1 - gen\\n conv1_out_gen, params = conv_2d_layer (\\n input = gen_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n params = params,\\n name = 'conv_1_gen',\\n visualize = False )\\n\\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \\n process_params(params, name = self.name)\\n c1_params = params\\n\\n\\n\\n\\n\\n # Conv Layer 2 - image\\n conv2_out_image, params = conv_2d_layer (\\n input = lrn1_out_img,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'conv_2_img' )\\n\\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \\n\\n\\n # Conv Layer 2 - gen\\n conv2_out_gen, params = conv_2d_layer (\\n input = lrn1_out_gen,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n params = params,\\n name = 'conv_2_gen' )\\n\\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \\n process_params(params, name = self.name)\\n c2_params = params\\n\\n # Dropout Layer\\n flat_gen = flatten_layer(lrn2_out_gen)\\n flat_img = flatten_layer(lrn2_out_img)\\n\\n flat_gen_dropout = dropout_layer ( input = flat_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_1_gen') \\n\\n flat_img_dropout = dropout_layer ( input = flat_img,\\n prob = self.dropout_prob,\\n name = 'dropout_1_img') \\n\\n\\n\\n # Dot Product Layer 1 -img\\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\\n neurons = HIDDEN_1,\\n name = 'image_disc_dot_1')\\n # Dot Product Layer 1 - gen\\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_1')\\n\\n process_params(params, name = self.name)\\n d1_params = params\\n \\n ##\\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_2_gen') \\n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_2_img')\\n\\n # Dot Product Layer 2 -img\\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\\n neurons = HIDDEN_2,\\n name = 'image_disc_dot_2')\\n # Dot Product Layer 2 - gen\\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_2')\\n process_params(params, name = self.name)\\n d2_params = params\\n\\n ##\\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_3_gen') \\n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_3_img')\\n\\n # Dot Product Layer 1 -img\\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'real')\\n # Dot Product Layer 1 -gen\\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\\n params = params,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'fake')\\n\\n process_params(params, name = self.name)\\n d3_params = params\\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \\n\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \\n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\\\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\\\\n 0.5 * tf.reduce_mean ((self.fake)**2)\\n tf.summary.scalar('discriminator_obj', discriminator_obj)\\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \\n\\n with tf.variable_scope (self.name + '_probabilites') as scope: \\n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\\n \\n self._cook_optimizer( \\n lr = DIS_GAN_LR, \\n optimizer = DIS_GAN_OPTIMIZER,\\n l1_coeff = DIS_GAN_L1_COEFF,\\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)\",\n \"def unet_network(input_tensor, nb_classes):\\n # contraction 1\\n conv1 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv1')(\\n input_tensor) # (batch_size, ?, ?, 64)\\n conv2 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv2')(\\n conv1) # (batch_size, ?, ?, 64)\\n crop2 = Cropping2D(\\n cropping=((88, 88), (88, 88)),\\n name=\\\"crop2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n maxpool2 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool2\\\")(\\n conv2) # (batch_size, ?, ?, 64)\\n\\n # contraction 2\\n conv3 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv3')(\\n maxpool2) # (batch_size, ?, ?, 128)\\n conv4 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv4')(\\n conv3) # (batch_size, ?, ?, 128)\\n crop4 = Cropping2D(\\n cropping=((40, 40), (40, 40)),\\n name=\\\"crop4\\\")(\\n conv4) # (batch_size, ?, ?, 128)\\n maxpool4 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool4\\\")(\\n conv4) # ((batch_size, ?, ?, 128)\\n\\n # contraction 3\\n conv5 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv5')(\\n maxpool4) # (batch_size, ?, ?, 256)\\n conv6 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv6')(\\n conv5) # (batch_size, ?, ?, 256)\\n crop6 = Cropping2D(\\n cropping=((16, 16), (16, 16)),\\n name=\\\"crop6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n maxpool6 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool6\\\")(\\n conv6) # (batch_size, ?, ?, 256)\\n\\n # contraction 4\\n conv7 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv7')(\\n maxpool6) # (batch_size, ?, ?, 512)\\n conv8 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv8')(\\n conv7) # (batch_size, ?, ?, 512)\\n crop8 = Cropping2D(\\n cropping=((4, 4), (4, 4)),\\n name=\\\"crop8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n maxpool8 = MaxPooling2D(\\n pool_size=(3, 3),\\n strides=(2, 2),\\n name=\\\"maxpool8\\\")(\\n conv8) # (batch_size, ?, ?, 512)\\n\\n # bottom\\n conv9 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv9')(\\n maxpool8) # (batch_size, ?, ?, 1024)\\n conv10 = Conv2D(\\n filters=1024,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv10')(\\n conv9) # (batch_size, ?, ?, 1024)\\n\\n # expansion 1\\n upconv11 = up_conv_2d(\\n input_tensor=conv10,\\n nb_filters=512,\\n name='upconv11') # (batch_size, ?, ?, 512)\\n concat11 = tf.concat(\\n values=[crop8, upconv11],\\n axis=-1,\\n name='concat11') # (batch_size, ?, ?, 1024)\\n conv12 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv12')(\\n concat11) # (batch_size, ?, ?, 512)\\n conv13 = Conv2D(\\n filters=512,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv13')(\\n conv12) # (batch_size, ?, ?, 512)\\n\\n # expansion 2\\n upconv14 = up_conv_2d(\\n input_tensor=conv13,\\n nb_filters=256,\\n name='upconv14') # (batch_size, ?, ?, 256)\\n concat14 = tf.concat(\\n values=[crop6, upconv14],\\n axis=-1,\\n name='concat14') # (batch_size, ?, ?, 512)\\n conv15 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv15')(\\n concat14) # (batch_size, ?, ?, 256)\\n conv16 = Conv2D(\\n filters=256,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv16')(\\n conv15) # (batch_size, ?, ?, 256)\\n\\n # expansion 3\\n upconv17 = up_conv_2d(\\n input_tensor=conv16,\\n nb_filters=128,\\n name='upconv17') # (batch_size, ?, ?, 128)\\n concat17 = tf.concat(\\n values=[crop4, upconv17],\\n axis=-1,\\n name='concat17') # (batch_size, ?, ?, 256)\\n conv18 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv18')(\\n concat17) # (batch_size, ?, ?, 128)\\n conv19 = Conv2D(\\n filters=128,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv19')(\\n conv18) # (batch_size, ?, ?, 128)\\n\\n # expansion 4\\n upconv20 = up_conv_2d(\\n input_tensor=conv19,\\n nb_filters=64,\\n name='upconv20') # (batch_size, ?, ?, 64)\\n concat20 = tf.concat(\\n values=[crop2, upconv20],\\n axis=-1,\\n name='concat20') # (batch_size, ?, ?, 128)\\n conv21 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv21')(\\n concat20) # (batch_size, ?, ?, 64)\\n conv22 = Conv2D(\\n filters=64,\\n kernel_size=(3, 3),\\n activation='relu',\\n name='conv22')(\\n conv21) # (batch_size, ?, ?, 64)\\n conv23 = Conv2D(\\n filters=nb_classes,\\n kernel_size=(1, 1),\\n activation='sigmoid',\\n name='conv23')(\\n conv22) # (batch_size, ?, ?, nb_classes)\\n\\n return conv23\",\n \"def discriminator_block(in_filters, out_filters, normalize=True):\\r\\n layers = [nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1)]\\r\\n if normalize:\\r\\n layers.append(nn.InstanceNorm2d(out_filters))\\r\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\r\\n return layers\",\n \"def __init__(self):\\n #conv1\\n n = inp_width*inp_height\\n #poczatkowe wagi sieci sa ustalane losowo z rozkladu normalnego. Umieszczane sa one na liscie matryc wag\\n self.Weights = [np.random.randn(layers[0][1],inp_channels,layers[0][2],layers[0][2])/np.sqrt(n)]\\n out_Size = inp_width - layers[0][2] + 1 #zmienna zawiera rozmiar wyjscia danej warstwy\\n #inicjalizacja progow \\n self.Biases = [initBias*np.ones( layers[0][1] )]\\n #przypisanie parametrow warstwie poolingu\\n self.poolParams = [(layers[1][1], layers[1][2])]\\n out_Size = out_Size/2 \\n #conv 2\\n n = out_Size*out_Size*layers[0][1]\\n self.Weights.append(np.random.randn(layers[2][1],layers[0][1],layers[2][2],layers[2][2])/np.sqrt(n))\\n out_Size = out_Size - layers[2][2]+1\\n self.Biases.append(initBias*np.ones(layers[2][1]))\\n #pool 2\\n self.poolParams.append((layers[3][1],layers[3][2]))\\n out_Size = out_Size/2 \\n #conv 3\\n n = out_Size*out_Size*layers[2][1]\\n self.Weights.append(np.random.randn(layers[4][1],layers[2][1],out_Size,out_Size)/np.sqrt(n))\\n out_Size = 1\\n self.Biases.append(initBias*np.ones(layers[4][1]))\\n #fully connected 1\\n n = layers[4][1]\\n self.Weights.append(np.random.randn(layers[5][1],layers[4][1])/np.sqrt(n))\\n self.Biases.append(initBias*np.ones(layers[5][1]))\\n #fully connected 2\\n n = layers[5][1]\\n self.Weights.append(np.random.randn(layers[6][1],layers[5][1])/np.sqrt(n))\\n self.Biases.append(initBias*np.ones(layers[6][1]))\\n\\n self.Weights = np.asarray(self.Weights)\\n self.Biases = np.asarray(self.Biases)\\n \\n delta_W = []\\n delta_B = []\\n for i in range(5):\\n delta_W.append(np.zeros(self.Weights[i].shape))\\n delta_B.append(np.zeros(self.Biases[i].shape))\\n self.delta_W = np.asarray(delta_W)\\n self.delta_B = np.asarray(delta_B)\",\n \"def __init__(\\n self,\\n include_top=True,\\n weights='imagenet',\\n input_tensor=None,\\n input_shape=None,\\n pooling=None,\\n classes=1000,\\n **kwargs):\\n backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)\\n self.include_top = include_top\\n self.pooling = pooling\\n self.weights = weights\\n self.backend = backend\\n self.layers = layers\\n self.classes = classes\\n\\n if not (weights in {'imagenet', None} or os.path.exists(weights)):\\n raise ValueError('The `weights` argument should be either '\\n '`None` (random initialization), `imagenet` '\\n '(pre-training on ImageNet), '\\n 'or the path to the weights file to be loaded.')\\n\\n if weights == 'imagenet' and include_top and classes != 1000:\\n raise ValueError('If using `weights` as `\\\"imagenet\\\"` with `include_top`'\\n ' as true, `classes` should be 1000')\\n self.block1_conv1 = []\\n self.block1_conv2 = []\\n self.block1_pool = []\\n\\n self.block2_conv1 = []\\n self.block2_conv2 = []\\n self.block2_pool = []\\n\\n self.block3_conv1 = []\\n self.block3_conv2 = []\\n self.block3_conv3 = []\\n self.block3_conv4 = []\\n self.block3_pool = []\\n\\n self.block4_conv1 = []\\n self.block4_conv2 = []\\n self.block4_conv3 = []\\n self.block4_conv4 = []\\n self.block4_pool = []\\n\\n self.block5_conv1 = []\\n self.block5_conv2 = []\\n self.block5_conv3 = []\\n self.block5_conv4 = []\\n self.block5_pool = []\\n\\n for i in xrange(FLAGS.num_replica):\\n # Block 1\\n self.block1_conv1.append(layers.Conv2D(64, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block1_conv1'))\\n self.block1_conv2.append(layers.Conv2D(64, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block1_conv2'))\\n self.block1_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool'))\\n\\n # Block 2\\n self.block2_conv1.append(layers.Conv2D(128, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block2_conv1'))\\n self.block2_conv2.append(layers.Conv2D(128, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block2_conv2'))\\n self.block2_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool'))\\n\\n # Block 3\\n self.block3_conv1.append(layers.Conv2D(256, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block3_conv1'))\\n self.block3_conv2.append(layers.Conv2D(256, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block3_conv2'))\\n self.block3_conv3.append(layers.Conv2D(256, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block3_conv3'))\\n self.block3_conv4.append(layers.Conv2D(256, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block3_conv4'))\\n self.block3_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool'))\\n\\n # Block 4\\n self.block4_conv1.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block4_conv1'))\\n self.block4_conv2.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block4_conv2'))\\n self.block4_conv3.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block4_conv3'))\\n self.block4_conv4.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block4_conv4'))\\n self.block4_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool'))\\n\\n # Block 5\\n self.block5_conv1.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block5_conv1'))\\n self.block5_conv2.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block5_conv2'))\\n self.block5_conv3.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block5_conv3'))\\n self.block5_conv4.append(layers.Conv2D(512, (3, 3),\\n activation='relu',\\n padding='same',\\n name='block5_conv4'))\\n self.block5_pool.append(layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool'))\\n\\n if include_top:\\n # Classification block\\n self.flatten = layers.Flatten(name='flatten')\\n self.fc1 = layers.Dense(4096, activation='relu', name='fc1')\\n self.fc2 = layers.Dense(4096, activation='relu', name='fc2')\\n self.predict = layers.Dense(classes, activation='softmax', name='predictions')\\n else:\\n if pooling == 'avg':\\n self.pool = layers.GlobalAveragePooling2D()\\n elif pooling == 'max':\\n self.pool = layers.GlobalMaxPooling2D()\",\n \"def inference(image, keep_prob):\\r\\n '''\\r\\n print(\\\"setting up vgg initialized conv layers ...\\\")\\r\\n model_data = utils.get_model_data(FLAGS.model_dir, MODEL_URL)\\r\\n\\r\\n mean = model_data['normalization'][0][0][0]\\r\\n mean_pixel = np.mean(mean, axis=(0, 1))\\r\\n\\r\\n weights = np.squeeze(model_data['layers'])\\r\\n print(\\\"weights.shape\\\",weights.shape)\\r\\n\\r\\n processed_image = utils.process_image(image, mean_pixel)'''\\r\\n\\r\\n with tf.variable_scope(\\\"inference\\\"):\\r\\n pooling_net,conv_final_layer = inference_op(image)\\r\\n #conv_final_layer = image_net[\\\"conv5_3\\\"]\\r\\n\\r\\n pool5 = utils.max_pool_2x2(conv_final_layer)\\r\\n\\r\\n W6 = utils.weight_variable([7, 7, 512, 4096], name=\\\"W6\\\")\\r\\n b6 = utils.bias_variable([4096], name=\\\"b6\\\")\\r\\n conv6 = utils.conv2d_basic(pool5, W6, b6)\\r\\n relu6 = tf.nn.relu(conv6, name=\\\"relu6\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu6)\\r\\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\\r\\n\\r\\n W7 = utils.weight_variable([1, 1, 4096, 4096], name=\\\"W7\\\")\\r\\n b7 = utils.bias_variable([4096], name=\\\"b7\\\")\\r\\n conv7 = utils.conv2d_basic(relu_dropout6, W7, b7)\\r\\n relu7 = tf.nn.relu(conv7, name=\\\"relu7\\\")\\r\\n if FLAGS.debug:\\r\\n utils.add_activation_summary(relu7)\\r\\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\\r\\n\\r\\n W8 = utils.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\\\"W8\\\")\\r\\n b8 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b8\\\")\\r\\n conv8 = utils.conv2d_basic(relu_dropout7, W8, b8)\\r\\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\\\"prediction1\\\")\\r\\n\\r\\n # now to upscale to actual image size\\r\\n deconv_shape1 = pooling_net[\\\"pool4\\\"].get_shape()\\r\\n W_t1 = utils.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\\\"W_t1\\\")\\r\\n b_t1 = utils.bias_variable([deconv_shape1[3].value], name=\\\"b_t1\\\")\\r\\n # 对第8层的结果进行反卷积(上采样),通道数也由NUM_OF_CLASSESS变为第4层的通道数\\r\\n conv_t1 = utils.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(pooling_net[\\\"pool4\\\"]))\\r\\n fuse_1 = tf.add(conv_t1, pooling_net[\\\"pool4\\\"], name=\\\"fuse_1\\\")\\r\\n\\r\\n deconv_shape2 = pooling_net[\\\"pool3\\\"].get_shape()\\r\\n W_t2 = utils.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\\\"W_t2\\\")\\r\\n b_t2 = utils.bias_variable([deconv_shape2[3].value], name=\\\"b_t2\\\")\\r\\n conv_t2 = utils.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(pooling_net[\\\"pool3\\\"]))\\r\\n fuse_2 = tf.add(conv_t2, pooling_net[\\\"pool3\\\"], name=\\\"fuse_2\\\")\\r\\n\\r\\n shape = tf.shape(image)\\r\\n deconv_shape3 = tf.stack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\\r\\n W_t3 = utils.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\\\"W_t3\\\")\\r\\n b_t3 = utils.bias_variable([NUM_OF_CLASSESS], name=\\\"b_t3\\\")\\r\\n conv_t3 = utils.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\\r\\n\\r\\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\\\"prediction\\\")\\r\\n print(\\\"annotation_pred.shape\\\",annotation_pred.shape)\\r\\n print(\\\"conv_t3\\\",conv_t3)\\r\\n print(\\\"tf.expand_dims(annotation_pred, dim=3)\\\",tf.expand_dims(annotation_pred, dim=3))\\r\\n return tf.expand_dims(annotation_pred, dim=3), conv_t3\",\n \"def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\\\"sigmoid\\\"):\\n\\n # inizializzo il modello come sequenziale\\n model = Sequential()\\n inputShape = (imageHeight, imageWidth, imageDepth)\\n chanDim = -1\\n\\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\\n # Utilizzo 32 filtri 3*3\\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\\\"same\\\", input_shape=inputShape))\\n # con attivazione Rectified Linear Unit\\n model.add(Activation(\\\"relu\\\"))\\n # applico una batch normalization\\n model.add(BatchNormalization(axis=chanDim))\\n # un MaxPooling 3*3\\n model.add(MaxPooling2D(pool_size=(3, 3)))\\n # ed un 25% di dropout per ridurre overfitting\\n model.add(Dropout(0.25))\\n\\n # Secondo blocco\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Terzo blocco\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Passo ai Fully Connected Layers\\n # Trasformo il modello in un vettore\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Activation(\\\"sigmoid\\\"))\\n model.add(BatchNormalization())\\n model.add(Dropout(0.5))\\n\\n # Infine utilizzo l'attivazione per la rete\\n model.add(Dense(classesNumber))\\n model.add(Activation(finalAct))\\n\\n return model\",\n \"def _init_predictor(self):\\n self.conv_cls_prev = self._init_branch(\\n conv_channels=self.cls_branch,\\n conv_strides=(1, ) * len(self.cls_branch))\\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\\n 1)\\n # init regression head\\n self.conv_reg_prevs = nn.ModuleList()\\n # init output head\\n self.conv_regs = nn.ModuleList()\\n # group_reg_dims:\\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\\n for i in range(len(self.group_reg_dims)):\\n reg_dims = self.group_reg_dims[i]\\n reg_branch_channels = self.reg_branch[i]\\n out_channel = self.out_channels[i]\\n reg_list = nn.ModuleList()\\n if len(reg_branch_channels) > 0:\\n self.conv_reg_prevs.append(\\n self._init_branch(\\n conv_channels=reg_branch_channels,\\n conv_strides=(1, ) * len(reg_branch_channels)))\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\\n self.conv_regs.append(reg_list)\\n else:\\n self.conv_reg_prevs.append(None)\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\\n self.conv_regs.append(reg_list)\",\n \"def __init__(self):\\n super(PackageNet, self).__init__()\\n \\n # remove last layers of vgg19 model, save first fc layer and maxpool layer\\n self.vgg = models.vgg19(pretrained=True)\\n del self.vgg.classifier[2:]\\n\\n # get size of some layers\\n start_num = self.vgg.classifier[0].out_features\\n mid_num0 = int(np.sqrt(start_num))\\n mid_num1 = int(start_num**0.667)\\n mid_num2 = int(start_num**0.333)\\n \\n cls_out_num = 9 \\n reg_out_num = 16 # 8 3D bounding box coords\\n \\n # define classifier\\n self.classifier = nn.Sequential(\\n nn.Linear(start_num,mid_num0,bias=True),\\n nn.ReLU(),\\n nn.Linear(mid_num0,cls_out_num,bias = True),\\n nn.Softmax(dim = 1)\\n )\\n \\n # define regressor\\n # try relu and tanh, also try without bias\\n self.regressor = nn.Sequential(\\n nn.Linear(start_num,mid_num1,bias=True),\\n nn.ReLU(),\\n nn.Linear(mid_num1,mid_num2,bias = True),\\n nn.ReLU(),\\n nn.Linear(mid_num2,reg_out_num,bias = True),\\n nn.Sigmoid()\\n \\n )\",\n \"def _make_conv_layers_bn_padding(self): ## 20 Convs, used for pretrained by IMAGE Net 1000 class\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=3, bias=False), # padding=3 so, output is 224.\\n nn.BatchNorm2d(64),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1, bias=False),\\n nn.BatchNorm2d(192),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, bias=False), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.BatchNorm2d(128),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1, bias=False), \\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, bias=False),\\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1, bias=False), \\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, bias=False),\\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, bias=False),\\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, bias=False),\\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, bias=False),\\n nn.BatchNorm2d(256),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1, bias=False),\\n nn.BatchNorm2d(512), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\\n nn.BatchNorm2d(1024),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\\n nn.BatchNorm2d(1024),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, bias=False),\\n nn.BatchNorm2d(512),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1, bias=False),\\n nn.BatchNorm2d(1024),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.BatchNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def VGG19(include_top=True, weights='imagenet',\\n input_tensor=None, input_shape=None,\\n pooling=None,\\n classes=1000):\\n if weights not in {'imagenet', None}:\\n raise ValueError('The `weights` argument should be either '\\n '`None` (random initialization) or `imagenet` '\\n '(pre-training on ImageNet).')\\n\\n if weights == 'imagenet' and include_top and classes != 1000:\\n raise ValueError('If using `weights` as imagenet with `include_top`'\\n ' as true, `classes` should be 1000')\\n # Determine proper input shape\\n\\n\\n img_input = input_tensor\\n # Block 1\\n x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)\\n x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)\\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)\\n\\n # Block 2\\n x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)\\n x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)\\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)\\n\\n # Block 3\\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)\\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)\\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)\\n x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv4')(x)\\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)\\n\\n # Block 4\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv4')(x)\\n x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)\\n\\n # Block 5\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)\\n x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv4')(x)\\n\\n model = Model(img_input, x, name='vgg19')\\n\\n if weights == 'imagenet':\\n if include_top:\\n weights_path = get_file('vgg19_weights_tf_dim_ordering_tf_kernels.h5',\\n WEIGHTS_PATH,\\n cache_subdir='models',\\n file_hash='cbe5617147190e668d6c5d5026f83318')\\n else:\\n weights_path = get_file('vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5',\\n WEIGHTS_PATH_NO_TOP,\\n cache_subdir='models',\\n file_hash='253f8cb515780f3b799900260a226db6')\\n model.load_weights(weights_path)\\n\\n return model\",\n \"def densenet121(growth_rate=32, compression=1.0):\\n\\n kernel_init = K.initializers.he_normal(seed=None)\\n\\n X = K.Input(shape=(224, 224, 3))\\n batchNorm0 = K.layers.BatchNormalization(axis=3)(X)\\n activation0 = K.layers.Activation('relu')(batchNorm0)\\n\\n layer1 = K.layers.Conv2D(filters=2*growth_rate, kernel_size=(7, 7),\\n strides=(2, 2), padding='same',\\n kernel_initializer=kernel_init)(activation0)\\n l1pool = K.layers.MaxPool2D(pool_size=(3, 3), strides=(2, 2),\\n padding='same')(layer1)\\n\\n layer2, n_f2 = dense_block(l1pool, 2*growth_rate, growth_rate, 6)\\n layer3, n_f3 = transition_layer(layer2, n_f2, compression)\\n layer4, n_f4 = dense_block(layer3, n_f3, growth_rate, 12)\\n layer5, n_f5 = transition_layer(layer4, n_f4, compression)\\n layer6, n_f6 = dense_block(layer5, n_f5, growth_rate, 24)\\n layer7, n_f7 = transition_layer(layer6, n_f6, compression)\\n layer8, n_f8 = dense_block(layer7, n_f7, growth_rate, 16)\\n\\n avg_pool = K.layers.AveragePooling2D(pool_size=(7, 7), strides=7,\\n padding='same')(layer8)\\n\\n Y = K.layers.Dense(1000, activation='softmax',\\n kernel_initializer=kernel_init)(avg_pool)\\n\\n model = K.models.Model(inputs=X, outputs=Y)\\n\\n return model\",\n \"def discriminator_block(in_filters, out_filters, stride, normalize):\\n layers = [nn.Conv2d(in_filters, out_filters, 3, stride, 1)]\\n if normalize:\\n layers.append(nn.InstanceNorm2d(out_filters))\\n layers.append(nn.LeakyReLU(0.2, inplace=True))\\n return layers\",\n \"def faceRecoModel(input_shape):\\n\\t# Define the input as a tensor with shape input_shape\\n\\tX_input = Input(input_shape)\\n\\t# Zero-Padding\\n\\tX = ZeroPadding2D((3, 3))(X_input)\\n\\t# First Block\\n\\tX = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1')(X)\\n\\tX = BatchNormalization(axis = 1, name = 'bn1')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\tX = MaxPooling2D((3, 3), strides = 2)(X)\\n\\t# Second Block\\n\\tX = Conv2D(64, (1, 1), strides = (1, 1), name = 'conv2')(X)\\n\\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn2')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\t# Second Block\\n\\tX = Conv2D(192, (3, 3), strides = (1, 1), name = 'conv3')(X)\\n\\tX = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn3')(X)\\n\\tX = Activation('relu')(X)\\n\\t# Zero-Padding + MAXPOOL\\n\\tX = ZeroPadding2D((1, 1))(X)\\n\\tX = MaxPooling2D(pool_size = 3, strides = 2)(X)\\n\\t# Inception 1: a/b/c\\n\\t# X = inception_block_1a(X)\\n\\t# X = inception_block_1b(X)\\n\\t# X = inception_block_1c(X)\\n\\t# # Inception 2: a/b\\n\\t# X = inception_block_2a(X)\\n\\t# X = inception_block_2b(X)\\n\\t# # Inception 3: a/b\\n\\t# X = inception_block_3a(X)\\n\\t# X = inception_block_3b(X)\\n\\t# Top layer\\n\\tX = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X)\\n\\tX = Flatten()(X)\\n\\tX = Dense(10, name='dense_layer')(X)\\n\\t# L2 normalization\\n\\tX = Lambda(lambda x: K.l2_normalize(x,axis=1))(X)\\n\\t# Create model instance\\n\\tmodel = Model(inputs = X_input, outputs = X, name='FaceRecoModel')\\n\\treturn model\",\n \"def inception_network():\\n X = K.Input(shape=(224, 224, 3))\\n initializer = K.initializers.he_normal(seed=None)\\n conv_1 = K.layers.Conv2D(filters=64, kernel_size=7,\\n padding='same', strides=2,\\n kernel_initializer=initializer,\\n activation='relu')(X)\\n max_pool_1 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(conv_1)\\n\\n conv_2 = K.layers.Conv2D(filters=64, padding='same',\\n kernel_size=1, activation='relu',\\n kernel_initializer=initializer)(max_pool_1)\\n conv2_1 = K.layers.Conv2D(filters=192, padding='same',\\n kernel_size=3, activation='relu',\\n kernel_initializer=initializer)(conv_2)\\n max_pool_2 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(conv2_1)\\n\\n incep_3a = inception_block(max_pool_2, [64, 96, 128, 16, 32, 32])\\n incep_3b = inception_block(incep_3a, [128, 128, 192, 32, 96, 64])\\n max_pool_3 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(incep_3b)\\n\\n incep_4a = inception_block(max_pool_3, [192, 96, 208, 16, 48, 64])\\n incep_4b = inception_block(incep_4a, [160, 112, 224, 24, 64, 64])\\n incep_4c = inception_block(incep_4b, [128, 128, 256, 24, 64, 64])\\n incep_4d = inception_block(incep_4c, [112, 144, 288, 32, 64, 64])\\n incep_4e = inception_block(incep_4d, [256, 160, 320, 32, 128, 128])\\n max_pool_4 = K.layers.MaxPooling2D(pool_size=3, strides=2,\\n padding='same')(incep_4e)\\n\\n incep_5a = inception_block(max_pool_4, [256, 160, 320, 32, 128, 128])\\n incep_5b = inception_block(incep_5a, [384, 192, 384, 48, 128, 128])\\n avg_pool = K.layers.AveragePooling2D(pool_size=7, strides=None)(incep_5b)\\n\\n drop_out = K.layers.Dropout(0.4)(avg_pool)\\n dense = K.layers.Dense(units=1000, activation='softmax',\\n kernel_initializer=initializer)(drop_out)\\n return K.models.Model(inputs=X, outputs=dense)\",\n \"def __init__(self):\\n torch.nn.Module.__init__(self)\\n ######################### Convolution and pooling layers of VGG-16.\\n self.features = torchvision.models.vgg16(pretrained=True).features # fine tune?\\n self.features = torch.nn.Sequential(*list(self.features.children())\\n [:-22]) # Remove pool2 and rest, lack of computational resource\\n # No grad for convVGG\\n # for param in self.features.parameters():\\n # param.requires_grad = False\\n\\n #################### Channel Grouping Net\\n # self.fc1_ = torch.nn.Linear(128, 128*16)#lack of resource\\n # self.fc2_ = torch.nn.Linear(128, 128*16)\\n # self.fc3_ = torch.nn.Linear(128, 128*16)\\n #\\n # torch.nn.init.kaiming_normal_(self.fc1_.weight.data, nonlinearity='relu')\\n # if self.fc1_.bias is not None:\\n # torch.nn.init.constant_(self.fc1_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc2_.weight.data, nonlinearity='relu')\\n # if self.fc2_.bias is not None:\\n # torch.nn.init.constant_(self.fc2_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc3_.weight.data, nonlinearity='relu')\\n # if self.fc3_.bias is not None:\\n # torch.nn.init.constant_(self.fc3_.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.fc1 = torch.nn.Linear(128*28*28, 128)\\n self.fc2 = torch.nn.Linear(128*28*28, 128)\\n self.fc3 = torch.nn.Linear(128*28*28, 128)\\n\\n\\n torch.nn.init.kaiming_normal_(self.fc1.weight.data, nonlinearity='relu')\\n if self.fc1.bias is not None:\\n torch.nn.init.constant_(self.fc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc2.weight.data, nonlinearity='relu')\\n if self.fc2.bias is not None:\\n torch.nn.init.constant_(self.fc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc3.weight.data, nonlinearity='relu')\\n if self.fc3.bias is not None:\\n torch.nn.init.constant_(self.fc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.layerNorm=nn.LayerNorm([224,224])\\n\\n # global grad for hook\\n self.image_reconstruction = None\\n self.register_hooks()\\n self.GradWeight=1e-1\\n\\n # ################### STN input N*3*448*448\\n # self.localization = [\\n # nn.Sequential(\\n # nn.MaxPool2d(4,stride=4),#112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5,stride=1,padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3,stride=1,padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) #output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda()\\n # ]\\n # # Regressor for the 3 * 2 affine matrix\\n # self.fc_loc = [\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda()\\n # ]\\n # # Initialize the weights/bias with identity transformation\\n # for fc_locx in self.fc_loc:\\n # fc_locx[2].weight.data.zero_()\\n # fc_locx[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\\n\\n ########################Bilinear CNN output 256 channels\\n self.bcnnConv_1=torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_2 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_3 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n #BCNN Linear classifier.\\n self.bfc1 = torch.nn.Linear(512*512, 200)\\n self.bfc2 = torch.nn.Linear(512*512, 200)\\n self.bfc3 = torch.nn.Linear(512*512, 200)\\n torch.nn.init.kaiming_normal_(self.bfc1.weight.data) # 何凯明初始化\\n if self.bfc1.bias is not None:\\n torch.nn.init.constant_(self.bfc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc2.weight.data) # 何凯明初始化\\n if self.bfc2.bias is not None:\\n torch.nn.init.constant_(self.bfc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc3.weight.data) # 何凯明初始化\\n if self.bfc3.bias is not None:\\n torch.nn.init.constant_(self.bfc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n # self.CBP1 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP2 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP3 = CompactBilinearPooling(512, 512, 50000)\",\n \"def __init__(self, in_channels, out_channels, kernel_size,\\n stride=1, padding=0, dilation=1, groups=1, bias=True):\\n super(BatchConv2D_5D, self).__init__()\\n self.out_channels = out_channels\\n self.conv = nn.Conv2d(in_channels*groups, out_channels*groups,\\n kernel_size, stride=stride,\\n padding=padding, dilation=dilation,\\n groups=groups, bias=bias)\",\n \"def inference_deep_pyramid_cnn(self):\\n #1.region embedding\\n embedding_documents=self.region_embedding() #shape:[batch_size,total_sequence_length,embedding_size]\\n\\n #2.two layers of convs\\n embedding_documents = tf.expand_dims(embedding_documents ,-1) # [batch_size,total_sequence_length,embed_size,1). expand dimension so meet input requirement of 2d-conv\\n conv=self.dpcnn_two_layers_conv(embedding_documents,double_num_filters=False) #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\\n #skip connection: add and activation\\n conv=conv+embedding_documents #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\\n b = tf.get_variable(\\\"b-inference\\\", [self.hpcnn_number_filters])\\n print(\\\"conv:\\\",conv,\\\";b:\\\",b)\\n conv = tf.nn.relu(tf.nn.bias_add(conv, b),\\\"relu-inference\\\") #shape:[batch_size,total_sequence_length,embed_size,hpcnn_number_filters]\\n\\n #3. repeat of building blocks\\n for i in range(self.num_repeat):\\n conv=self.dpcnn_pooling_two_conv(conv,i) #shape:[batch_size,total_sequence_length/np.power(2,i),hpcnn_number_filters]\\n\\n #4. max pooling\\n seq_length1=conv.get_shape().as_list()[1] #sequence length after multiple layers of conv and pooling\\n seq_length2=conv.get_shape().as_list()[2] #sequence length after multiple layers of conv and pooling\\n print(\\\"before.final.pooling:\\\",conv)\\n pooling=tf.nn.max_pool(conv, ksize=[1,seq_length1,seq_length2,1], strides=[1,1,1,1], padding='VALID',name=\\\"pool\\\") #[batch_size,hpcnn_number_filters]\\n pooling=tf.squeeze(pooling)\\n print(\\\"pooling.final:\\\",pooling)\\n\\n #5. classifier\\n\\n return pooling\",\n \"def densenet121(growth_rate=32, compression=1.0):\\n inputs = K.Input(shape=(224, 224, 3))\\n out_l = K.layers.BatchNormalization(axis=3)(inputs)\\n out_l = K.layers.Activation('relu')(out_l)\\n out_l = K.layers.Conv2D(64, kernel_size=(7, 7), padding='same',\\n kernel_initializer='he_normal',\\n strides=(2, 2))(out_l)\\n out_l = K.layers.MaxPool2D((3, 3), (2, 2), padding=\\\"same\\\")(out_l)\\n out_l, filters = dense_block(out_l, 64, growth_rate, 6)\\n out_l, filters = transition_layer(out_l, filters, compression)\\n out_l, filters = dense_block(out_l, filters, growth_rate, 12)\\n out_l, filters = transition_layer(out_l, filters, compression)\\n out_l, filters = dense_block(out_l, filters, growth_rate, 24)\\n out_l, filters = transition_layer(out_l, filters, compression)\\n out_l, filters = dense_block(out_l, filters, growth_rate, 16)\\n out_l = K.layers.AvgPool2D((7, 7), padding='same')(out_l)\\n out_l = K.layers.Dense(1000, activation='softmax')(out_l)\\n model = K.Model(inputs, out_l)\\n return model\",\n \"def densenet121(growth_rate=32, compression=1.0):\\n X_input = K.Input(shape=(224, 224, 3))\\n initializer = K.initializers.he_normal(seed=None)\\n\\n batch1 = K.layers.BatchNormalization()(X_input)\\n activation1 = K.layers.Activation('relu')(batch1)\\n conv1 = K.layers.Conv2D(64, kernel_size=(7, 7), strides=2,\\n padding='same',\\n kernel_initializer=initializer)(activation1)\\n max_pool = K.layers.MaxPooling2D(pool_size=(3, 3),\\n strides=2, padding='same')(conv1)\\n X, nb_filters = dense_block(max_pool, 64, growth_rate, 6)\\n X, nb_filters = transition_layer(X, nb_filters, compression)\\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 12)\\n X, nb_filters = transition_layer(X, nb_filters, compression)\\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 24)\\n X, nb_filters = transition_layer(X, nb_filters, compression)\\n X, nb_filters = dense_block(X, nb_filters, growth_rate, 16)\\n\\n avg_pool = K.layers.AveragePooling2D(pool_size=(7, 7), strides=None,\\n padding='same')(X)\\n\\n dense = K.layers.Dense(1000, activation='softmax',\\n kernel_initializer=initializer)(avg_pool)\\n model = K.models.Model(inputs=X_input, outputs=dense)\\n\\n return model\",\n \"def build_discriminator2D(self, model_shape, filters=32, k_size=4, drop=False, rate=0.5, extra_conv=False, summary=False, ln=False, model_file=None, name='gan_d_'):\\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 Create a Discriminator Model using hyperparameters values defined as follows\\n \\\"\\\"\\\"\\n n_rows = model_shape[0]\\n n_cols = model_shape[1]\\n c_dims = model_shape[2]\\n\\n input_shape = (n_rows, n_cols, c_dims) \\n input_layer = Input(shape=input_shape, name=name+'input')\\n\\n d = self.Conv2D_Block(input_layer, filters, k_size=k_size, name=name+'1', bn=False) # 30x30x32\\n d = self.Conv2D_Block(d, 2*filters, k_size=k_size, ln=ln, name=name+'2') # 15x15x64\\n d = self.Conv2D_Block(d, 4*filters, k_size=k_size, ln=ln, name=name+'3') # 8x8x128\\n if extra_conv:\\n d = self.Conv2D_Block(d, 8*filters, strides=2, k_size=k_size, ln=ln, name=name+'4') # 8x8x256 \\n d = self.Conv2D_Block(d, 16*filters, strides=1, k_size=k_size, ln=ln, name=name+'5') # 8x8x256\\n else:\\n d = self.Conv2D_Block(d, 8*filters, strides=1, k_size=k_size, ln=ln, name=name+'4')\\n\\n d = Flatten(name=name+'flatten')(d)\\n if drop:\\n d = Dropout(rate=rate, name=name+'dropout')(d, training=True)\\n logits = Dense(1, activation='linear', kernel_initializer=RandomNormal(stddev=0.02), name=name+'dense')(d)\\n out = Activation('sigmoid', name=name+'sigmoid')(logits)\\n\\n model = Model(inputs=[input_layer], outputs=[out, logits], name='Discriminator')\\n if (summary):\\n model.summary()\\n return model\",\n \"def __init__(self, img_rows=400, img_cols=400, vgg_weights=\\\"imagenet\\\", inference_only=False, net_name='default', gpus=1, vgg_device=None):\\n \\n # Settings\\n self.img_rows = img_rows\\n self.img_cols = img_cols\\n self.img_overlap = 30\\n self.inference_only = inference_only\\n self.net_name = net_name\\n self.gpus = gpus\\n self.vgg_device = vgg_device\\n\\n # Scaling for VGG input\\n self.mean = [0.485, 0.456, 0.406]\\n self.std = [0.229, 0.224, 0.225]\\n \\n #get PowerSpect_CMB\\n reader = np.zeros((2507,))\\n fp = open('./data/COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt')\\n \\n for i,line in enumerate(fp):\\n if i >= 1:\\n reader[i-1] = line.split()[1]\\n \\n fp.close() \\n readers = np.log(reader)\\n self.cl = K.constant(readers)\\n # Assertions\\n assert self.img_rows >= 256, 'Height must be >256 pixels'\\n assert self.img_cols >= 256, 'Width must be >256 pixels'\\n\\n # Set current epoch\\n self.current_epoch = 0\\n \\n # VGG layers to extract features from (first maxpooling layers, see pp. 7 of paper)\\n self.vgg_layers = [3, 6, 10]\\n\\n # Instantiate the vgg network\\n if self.vgg_device:\\n with tf.device(self.vgg_device):\\n self.vgg = self.build_vgg(vgg_weights)\\n else:\\n self.vgg = self.build_vgg(vgg_weights)\\n \\n # Create UNet-like model\\n if self.gpus <= 1:\\n self.model, inputs_mask= self.build_pconv_unet()\\n self.compile_pconv_unet(self.model, inputs_mask) \\n else:\\n with tf.device(\\\"/cpu:0\\\"):\\n self.model, inputs_mask = self.build_pconv_unet()\\n self.model = multi_gpu_model(self.model, gpus=self.gpus)\\n self.compile_pconv_unet(self.model, inputs_mask)\",\n \"def count_model(input_shape):\\n kernel_size = (3, 3)\\n pool_size = (2, 2)\\n first_filters = 32\\n second_filters = 64\\n third_filters = 128\\n dropout_conv = 0.3\\n\\n model = Sequential()\\n\\n model.add(Conv2D(first_filters, kernel_size, activation='relu',\\n input_shape=input_shape))\\n\\n model.add(ZeroPadding2D(padding=(3, 3), data_format=None))\\n\\n model.add(Conv2D(first_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(first_filters, kernel_size, activation='relu'))\\n model.add(MaxPooling2D(pool_size=pool_size))\\n model.add(Dropout(dropout_conv))\\n\\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(second_filters, kernel_size, activation='relu'))\\n model.add(MaxPooling2D(pool_size=pool_size))\\n model.add(Dropout(dropout_conv))\\n\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(MaxPooling2D(pool_size=pool_size))\\n model.add(Dropout(dropout_conv))\\n\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(Conv2D(third_filters, kernel_size, activation='relu'))\\n model.add(MaxPooling2D(pool_size=pool_size))\\n model.add(Dropout(dropout_conv))\\n\\n model.add(Flatten())\\n\\n model.add(Dense(1024))\\n model.add(LeakyReLU())\\n model.add(BatchNormalization())\\n\\n model.add(Dense(512))\\n model.add(LeakyReLU())\\n model.add(BatchNormalization())\\n\\n # set activation='relu' to keep all values positive\\n model.add(Dense(1, activation='relu'))\\n\\n return model\",\n \"def __init__(self, in_channels, out_channels, group=1):\\n super(Block, self).__init__()\\n if group == 1:\\n self.b1 = RB(in_channels, out_channels, activation='relu')\\n self.b2 = RB(out_channels, out_channels, activation='relu')\\n self.b3 = RB(out_channels, out_channels, activation='relu')\\n elif group > 1:\\n self.b1 = EResidualBlock(64, 64, group=group)\\n self.b2 = self.b3 = self.b1\\n self.c1 = EasyConv2d(in_channels + out_channels, out_channels, 1, activation='relu')\\n self.c2 = EasyConv2d(in_channels + out_channels * 2, out_channels, 1, activation='relu')\\n self.c3 = EasyConv2d(in_channels + out_channels * 3, out_channels, 1, activation='relu')\",\n \"def target(total_epoch, filter_num, filter_len, num_dense_nodes):\\n \\n start = time.time()\\n total_epoch = int(round(total_epoch))\\n filter_num = int(round(filter_num))\\n filter_len = int(round(filter_len))\\n num_dense_nodes = int(round(num_dense_nodes))\\n print(\\\"Epochs =\\\", total_epoch, \\\"| # Conv filters =\\\", filter_num, \\\"| Filter length =\\\", filter_len, \\\"| # Dense nodes =\\\", num_dense_nodes)\\n\\n # model specification\\n model = Sequential()\\n model.add(Convolution1D(input_dim=4, input_length=dna_bp_length, nb_filter=filter_num, filter_length=filter_len, activation=\\\"relu\\\", border_mode =\\\"same\\\"))\\n model.add(MaxPooling1D(pool_length=dna_bp_length))\\n model.add(Flatten())\\n model.add(BatchNormalization())\\n model.add(Dense(input_dim=filter_num,output_dim=num_dense_nodes))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization())\\n model.add(Dense(output_dim=num_classes))\\n model.add(Activation(\\\"softmax\\\"))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[\\\"accuracy\\\"])\\n print(model.summary())\\n \\n max_val_acc = 0.0\\n max_acc_pair = 0.0\\n num_chunks = 6 \\n \\n epoch_train_acc = np.zeros((total_epoch,num_chunks))\\n epoch_val_acc = np.zeros((total_epoch,1))\\n\\n # train the model\\n for e in range(total_epoch):\\n print(\\\"Epoch =\\\", e+1, \\\"out of\\\", total_epoch)\\n for f in range(num_chunks-1):\\n X_train = np.load(\\\"/mnt/data\\\"+str(f)+\\\".npy\\\")\\n y_train = np.load(\\\"/mnt/labels\\\"+str(f)+\\\".npy\\\")\\n history = model.fit(X_train, y_train, batch_size = 8, \\\\\\n validation_split=0.0, nb_epoch=1, verbose=1, class_weight=cl_weight)\\n epoch_train_acc[e,f] = history.history['acc'][0]\\n \\n # train final chunk and do validation\\n X_train = np.load(\\\"/mnt/data\\\"+str(num_chunks-1)+\\\".npy\\\")\\n y_train = np.load(\\\"/mnt/labels\\\"+str(num_chunks-1)+\\\".npy\\\")\\n history = model.fit(X_train, y_train, batch_size = 8, \\\\\\n validation_data=(val_dna_seqs_onehot, val_pi_labels_onehot), nb_epoch=1, verbose=1, class_weight=cl_weight)\\n epoch_train_acc[e,num_chunks-1] = history.history['acc'][0]\\n epoch_val_acc[e,0] = history.history['val_acc'][0]\\n\\n # record max validation accuracy\\n if history.history['val_acc'][0] > max_val_acc:\\n max_val_acc = history.history['val_acc'][0]\\n max_acc_pair = history.history['acc'][0]\\n \\n # save network stats\\n print(\\\"Epoch training accuracy\\\")\\n print(epoch_train_acc)\\n print(\\\"Mean epoch training accuracy\\\")\\n print(np.transpose(np.mean(epoch_train_acc, axis=1)))\\n end = time.time()\\n np.save(str(int(end))+'conv'+str(filter_num)+'x'+str(filter_len)+'dense'+str(num_dense_nodes)+'time'+str(int(end-start))+'_mean_train_acc.out', np.transpose(np.mean(epoch_train_acc, axis=1)))\\n print(\\\"Epoch validation accuracy\\\" )\\n print(epoch_val_acc)\\n np.save(str(int(end))+'conv'+str(filter_num)+'x'+str(filter_len)+'dense'+str(num_dense_nodes)+'time'+str(int(end-start))+'_epoch_val_acc.out', epoch_val_acc, end-start)\\n \\n return max_val_acc/(end-start)\",\n \"def dense_block(x, nb_layers, nb_filter, growth_rate, dropout_rate=None, weight_decay=1E-4):\\n\\n concat_axis = 1 if K.image_dim_ordering() == \\\"th\\\" else -1\\n\\n feature_list = [x]\\n\\n for i in range(nb_layers):\\n x = conv_block(x, growth_rate, dropout_rate, weight_decay)\\n feature_list.append(x)\\n x = Concatenate(axis=concat_axis)(feature_list)\\n nb_filter += growth_rate\\n\\n return x, nb_filter\",\n \"def __init__(self, input_dim, hidden_dim_1, hidden_dim_2):\\n super(BinaryGraphClassifier, self).__init__()\\n\\n # Define the graph convolutional layers\\n self.conv_1 = DenseSAGEConv(in_feats=input_dim, out_feats=hidden_dim_1)\\n self.conv_2 = DenseSAGEConv(in_feats=hidden_dim_1, out_feats=hidden_dim_2)\\n\\n # Define the fully connected layers\\n self.fc_1 = nn.Linear(hidden_dim_2, hidden_dim_2)\\n self.fc_2 = nn.Linear(hidden_dim_2, 1)\\n\\n # Drop out layers\\n self.conv_dropout_1 = nn.Dropout(p=0.4)\\n self.conv_dropout_2 = nn.Dropout(p=0.4)\\n self.fc_dropout = nn.Dropout(p=0.4)\\n\\n # The output activation function\\n self.output_func = nn.Sigmoid()\",\n \"def __init__(self, input_dim=(3,32,32), num_filters=[32], hidden_layers=[100], \\r\\n num_classes=10 ,filter_size=7, weight_scale=1e-3, reg=0, dropout=0, \\r\\n use_batch_norm=False, dtype=np.float32):\\r\\n self.params={}\\r\\n self.use_dropout = dropout > 0\\r\\n self.use_batch_norm = use_batch_norm\\r\\n self.conv_params = {'stride': 1, 'pad': (filter_size - 1) // 2}\\r\\n self.pool_params = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\r\\n self.num_conv_layers = len(num_filters)\\r\\n self.num_hidden_layers = len(hidden_layers)\\r\\n self.bn_params = []\\r\\n self.dropout_params = []\\r\\n self.reg = reg\\r\\n\\r\\n # Initialize batch normalization parameters if necessary.\\r\\n num_layers = self.num_conv_layers + self.num_hidden_layers\\r\\n if self.use_batch_norm:\\r\\n for i in range(num_layers):\\r\\n self.bn_params.append({'mode':'train'})\\r\\n # Initialize dropout parameters if necessary\\r\\n if self.use_dropout:\\r\\n self.dropout_params = {'mode':'trian', 'p':dropout}\\r\\n\\r\\n C, H, W = input_dim\\r\\n channels, HH, WW = C, H, W\\r\\n # Initialize the parameters for the Convolutional network.\\r\\n for i in range(1, self.num_conv_layers+1):\\r\\n self.params['W{}'.format(i)] = np.random.randn(num_filters[i-1], \\r\\n channels, filter_size, \\r\\n filter_size) * weight_scale\\r\\n self.params['b{}'.format(i)] = np.zeros(num_filters[i-1])\\r\\n # Keeping track of the Height and Width of the image as we convolve\\r\\n # it through multiple layers. After pooling make sure the dimensions\\r\\n # make sense\\r\\n if (HH <= self.pool_params['pool_height']):\\r\\n raise Exception('The pool height and input height are equal'.\\\\\\r\\n format(self.pool_params['pool_height'], HH))\\r\\n else:\\r\\n HH = (HH - self.pool_params['pool_height']) / self.pool_params['stride'] + 1\\r\\n if (WW <= self.pool_params['pool_width']):\\r\\n raise Exception('The pool width and input width are equal'.\\\\\\r\\n format(self.params['pool_width'], WW))\\r\\n else:\\r\\n WW = (WW - self.pool_params['pool_width']) / self.pool_params['stride'] + 1\\r\\n\\r\\n\\r\\n # Updating the number of channels for the new input.\\r\\n channels = num_filters[i-1]\\r\\n # Initialize the parameters for the batch normalization if necessary.\\r\\n if self.use_batch_norm:\\r\\n self.params['gamma{}'.format(i)] = np.ones(channels)\\r\\n self.params['beta{}'.format(i)] = np.zeros(channels)\\r\\n\\r\\n # Initialize the parameters for the fully connected network.\\r\\n fc_input_dim = np.prod((HH, WW, channels))\\r\\n for i in range(1, self.num_hidden_layers+1):\\r\\n self.params['W{}'.format(i+self.num_conv_layers)] = np.random.randn(fc_input_dim, \\r\\n hidden_layers[i-1]) * weight_scale\\r\\n self.params['b{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\\r\\n # Initialize the parameters for batch normalization if necessary.\\r\\n if self.use_batch_norm:\\r\\n self.params['gamma{}'.format(i+self.num_conv_layers)] = np.ones(hidden_layers[i-1])\\r\\n self.params['beta{}'.format(i+self.num_conv_layers)] = np.zeros(hidden_layers[i-1])\\r\\n fc_input_dim = hidden_layers[i-1]\\r\\n\\r\\n # Initialize the parameters for the last layer of the fully connected network.\\r\\n self.params['W{}'.format(i+self.num_conv_layers+1)] = np.random.randn(hidden_layers[i-1],\\r\\n num_classes) * weight_scale\\r\\n self.params['b{}'.format(i+self.num_conv_layers+1)] = np.zeros(num_classes)\\r\\n\\r\\n # Convert the dtype for the parameters of the model.\\r\\n for k, v in self.params.items():\\r\\n self.params[k] = v.astype(dtype)\",\n \"def get_unet2(patch_height, patch_width, channels, n_classes):\\n axis = 3\\n k = 3 # kernel size 卷积核大小\\n s = 2 # stride 步长\\n n_filters = 32 # number of filters 通道数\\n\\n #初始化keras张量\\n inputs = Input((patch_height, patch_width, channels))\\n\\n # n_filters：输出的维度 （k，k）：卷积核尺寸 padding：边缘填充\\n # 400,400,3 ==> 400,400,32\\n conv1 = Conv2D(n_filters, (k,k), padding='same')(inputs)\\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\\n conv1 = Activation('relu')(conv1)\\n conv1 = Conv2D(n_filters, (k, k), padding='same')(conv1)\\n conv1 = BatchNormalization(scale=False, axis=axis)(conv1)\\n conv1 = Activation('relu')(conv1)\\n # 400,400,32 ==> 200,200,32\\n pool1 = MaxPooling2D(pool_size=(s,s))(conv1)\\n\\n # DenseBlock模块 200,200,32 ==> 200,200,32\\n conv2 = Conv2D(n_filters, (1,1), padding='same')(pool1)\\n # battleneck层 第一层Dense\\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\\n conv2 = Activation('relu')(conv2)\\n conv2 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv2)\\n conv2 = BatchNormalization(scale=False, axis=axis)(conv2)\\n conv2 = Activation('relu')(conv2)\\n conv2 = Conv2D(n_filters,(k,k),padding='same')(conv2)\\n # 200,200,32 ==> 200,200,64\\n x1 = Concatenate(axis=axis)([conv2,pool1])\\n\\n # Transition层\\n ts = Conv2D(n_filters * 4, (1, 1), padding='same')(x1)\\n # 200,200,64 ==> 100,100,64 #将pool2 看成 x1\\n pool2 = AveragePooling2D(pool_size=(s, s), strides=2)(ts)\\n\\n conv3 = Conv2D(n_filters,(1,1),padding='same')(pool2)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = Activation('relu')(conv3)\\n conv3 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv3)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = Activation('relu')(conv3)\\n conv3 = Conv2D(n_filters, (k, k), padding='same')(conv3)\\n # 100,100,32 ==> 100,100,96\\n tmp2 = Concatenate(axis=axis)([conv3,pool2])\\n\\n conv3 = Conv2D(n_filters, (1, 1), padding='same')(tmp2)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = Activation('relu')(conv3)\\n conv3 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv3)\\n conv3 = BatchNormalization(scale=False, axis=axis)(conv3)\\n conv3 = Activation('relu')(conv3)\\n conv3 = Conv2D(n_filters, (k, k), padding='same')(conv3)\\n # 100,100,32 ==> 100,100,128\\n x2 = Concatenate(axis=axis)([conv3, tmp2])\\n\\n # Transition层\\n ts1 = Conv2D(n_filters * 4,(1,1),padding='same')(x2)\\n # 100,100,128 ==> 50,50,128\\n pool2 = AveragePooling2D(pool_size=(s,s),strides=2)(ts1)\\n\\n # 50,50,128 ==> 50,50,32\\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(pool2)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\\n # 50,50,32 ==> 50,50,160\\n tmp3 = Concatenate(axis=axis)([conv4,pool2])\\n\\n # 50,50,160 ==> 50,50,32\\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp3)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\\n # 50,50,32 ==> 50,50,192\\n tmp4 = Concatenate(axis=axis)([conv4, tmp3])\\n\\n # 50,50,192 ==> 50,50,32\\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\\n # 50,50,32 ==> 50,50,224\\n tmp5 = Concatenate(axis=axis)([conv4, tmp4])\\n\\n # 50,50,224 ==> 50,50,32\\n conv4 = Conv2D(n_filters, (1, 1), padding='same')(tmp5)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv4)\\n conv4 = BatchNormalization(scale=False, axis=axis)(conv4)\\n conv4 = Activation('relu')(conv4)\\n conv4 = Conv2D(n_filters, (k, k), padding='same')(conv4)\\n # 50,50,32 ==> 50,50,256\\n x3 = Concatenate(axis=axis)([conv4, tmp5])\\n\\n ts2 = Conv2D(n_filters * 8, (1, 1), padding='same')(x3)\\n # 50,50,256 ==> 25,25,256\\n pool3 = AveragePooling2D(pool_size=(s, s), strides=2)(ts2)\\n\\n # 25,25,256 ==> 25,25,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(pool3)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 25,25,32 ==> 25,25,288\\n tmp6 = Concatenate(axis=axis)([conv5, pool3])\\n\\n # 50,50,288 ==> 50,50,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp6)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,320\\n tmp7 = Concatenate(axis=axis)([conv5, tmp6])\\n\\n # 50,50,288 ==> 50,50,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp7)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,352\\n tmp8 = Concatenate(axis=axis)([conv5, tmp7])\\n\\n # 50,50,352 ==> 50,50,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp8)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,384\\n tmp9 = Concatenate(axis=axis)([conv5, tmp8])\\n\\n # 50,50,352 ==> 50,50,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp9)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,416\\n tmp10 = Concatenate(axis=axis)([conv5, tmp9])\\n\\n # 50,50,352 ==> 50,50,32\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp10)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,448\\n tmp11 = Concatenate(axis=axis)([conv5, tmp10])\\n\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp11)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 50,50,32 ==> 50,50,480\\n tmp12 = Concatenate(axis=axis)([conv5, tmp11])\\n\\n conv5 = Conv2D(n_filters, (1, 1), padding='same')(tmp12)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(4 * n_filters, (1, 1), padding='same')(conv5)\\n conv5 = BatchNormalization(scale=False, axis=axis)(conv5)\\n conv5 = Activation('relu')(conv5)\\n conv5 = Conv2D(n_filters, (k, k), padding='same')(conv5)\\n # 25,25,32 ==> 25,25,512\\n conv5 = Concatenate(axis=axis)([conv5, tmp12])\\n\\n #先上采样放大 在进行卷积操作 相当于转置卷积 并进行拼接\\n # 25,25,512 ==> 50,50,768\\n up1 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv5), x3])\\n conv6 = Conv2D(8 * n_filters, (k,k), padding='same')(up1)\\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\\n conv6 = Activation('relu')(conv6)\\n conv6 = Conv2D(8 * n_filters, (k, k), padding='same')(conv6)\\n conv6 = BatchNormalization(scale=False, axis=axis)(conv6)\\n conv6 = Activation('relu')(conv6)\\n\\n #50,50,768 ==> 100,100,896\\n up2 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv6), x2])\\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(up2)\\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\\n conv7 = Activation('relu')(conv7)\\n conv7 = Conv2D(4 * n_filters, (k, k), padding='same')(conv7)\\n conv7 = BatchNormalization(scale=False, axis=axis)(conv7)\\n conv7 = Activation('relu')(conv7)\\n\\n # 100,100,896 ==> 200,200,960\\n up3 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv7), x1])\\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(up3)\\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\\n conv8 = Activation('relu')(conv8)\\n conv8 = Conv2D(2 * n_filters, (k, k), padding='same')(conv8)\\n conv8 = BatchNormalization(scale=False, axis=axis)(conv8)\\n conv8 = Activation('relu')(conv8)\\n\\n # 200,200,960 ==> 400,400,992\\n up4 = Concatenate(axis=axis)([UpSampling2D(size=(s, s))(conv8), conv1])\\n conv9 = Conv2D(n_filters, (k, k), padding='same')(up4)\\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\\n conv9 = Activation('relu')(conv9)\\n conv9 = Conv2D(n_filters, (k, k), padding='same')(conv9)\\n conv9 = BatchNormalization(scale=False, axis=axis)(conv9)\\n conv9 = Activation('relu')(conv9)\\n\\n # 全连接层 400,400,992 ==> 400,400,5\\n outputs = Conv2D(n_classes, (1,1), padding='same', activation='softmax')(conv9)\\n\\n unet = Model(inputs=inputs, outputs=outputs)\\n\\n return unet\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6322069","0.62509495","0.6210222","0.6205929","0.61850744","0.6165662","0.61332285","0.6119399","0.6096222","0.60777825","0.6053835","0.60508585","0.60431457","0.6030179","0.60178214","0.6007941","0.5995195","0.5962688","0.59607214","0.59575105","0.59514","0.59498066","0.5914623","0.59121513","0.590779","0.59007925","0.5893799","0.58919287","0.5886318","0.58854264","0.58681625","0.5856961","0.58447236","0.58434474","0.5839476","0.5839282","0.58289057","0.58265936","0.5823725","0.581561","0.58085006","0.5807736","0.5806038","0.57991016","0.5798425","0.579585","0.5790782","0.57825196","0.57825196","0.57813644","0.5779016","0.57754815","0.57721394","0.5771519","0.5768356","0.5760673","0.57582414","0.57572633","0.5755986","0.5749992","0.5746482","0.57426864","0.5741499","0.57390004","0.57385796","0.57384384","0.5737899","0.57352084","0.573086","0.57240474","0.5723621","0.57087106","0.57069516","0.56964","0.569201","0.5688458","0.5688448","0.5688218","0.5681068","0.5679425","0.567637","0.5676126","0.56682855","0.5666982","0.56653005","0.56648964","0.56643414","0.5664299","0.56613725","0.5654732","0.5654493","0.565306","0.5647625","0.5646073","0.5646039","0.56427145","0.5640922","0.5635073","0.5626616","0.5622927"],"string":"[\n \"0.6322069\",\n \"0.62509495\",\n \"0.6210222\",\n \"0.6205929\",\n \"0.61850744\",\n \"0.6165662\",\n \"0.61332285\",\n \"0.6119399\",\n \"0.6096222\",\n \"0.60777825\",\n \"0.6053835\",\n \"0.60508585\",\n \"0.60431457\",\n \"0.6030179\",\n \"0.60178214\",\n \"0.6007941\",\n \"0.5995195\",\n \"0.5962688\",\n \"0.59607214\",\n \"0.59575105\",\n \"0.59514\",\n \"0.59498066\",\n \"0.5914623\",\n \"0.59121513\",\n \"0.590779\",\n \"0.59007925\",\n \"0.5893799\",\n \"0.58919287\",\n \"0.5886318\",\n \"0.58854264\",\n \"0.58681625\",\n \"0.5856961\",\n \"0.58447236\",\n \"0.58434474\",\n \"0.5839476\",\n \"0.5839282\",\n \"0.58289057\",\n \"0.58265936\",\n \"0.5823725\",\n \"0.581561\",\n \"0.58085006\",\n \"0.5807736\",\n \"0.5806038\",\n \"0.57991016\",\n \"0.5798425\",\n \"0.579585\",\n \"0.5790782\",\n \"0.57825196\",\n \"0.57825196\",\n \"0.57813644\",\n \"0.5779016\",\n \"0.57754815\",\n \"0.57721394\",\n \"0.5771519\",\n \"0.5768356\",\n \"0.5760673\",\n \"0.57582414\",\n \"0.57572633\",\n \"0.5755986\",\n \"0.5749992\",\n \"0.5746482\",\n \"0.57426864\",\n \"0.5741499\",\n \"0.57390004\",\n \"0.57385796\",\n \"0.57384384\",\n \"0.5737899\",\n \"0.57352084\",\n \"0.573086\",\n \"0.57240474\",\n \"0.5723621\",\n \"0.57087106\",\n \"0.57069516\",\n \"0.56964\",\n \"0.569201\",\n \"0.5688458\",\n \"0.5688448\",\n \"0.5688218\",\n \"0.5681068\",\n \"0.5679425\",\n \"0.567637\",\n \"0.5676126\",\n \"0.56682855\",\n \"0.5666982\",\n \"0.56653005\",\n \"0.56648964\",\n \"0.56643414\",\n \"0.5664299\",\n \"0.56613725\",\n \"0.5654732\",\n \"0.5654493\",\n \"0.565306\",\n \"0.5647625\",\n \"0.5646073\",\n \"0.5646039\",\n \"0.56427145\",\n \"0.5640922\",\n \"0.5635073\",\n \"0.5626616\",\n \"0.5622927\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7157092"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17078,"cells":{"query":{"kind":"string","value":"Used to assemble our multioutput model CNN."},"document":{"kind":"string","value":"def assemble_full_model(self, width, height, num_races):\n input_shape = (height, width, 3)\n\n inputs = Input(shape=input_shape)\n\n age_branch = self.build_age_branch(inputs)\n race_branch = self.build_race_branch(inputs, num_races)\n gender_branch = self.build_gender_branch(inputs)\n\n model = Model(inputs=inputs,\n outputs = [age_branch, race_branch, gender_branch],\n name=\"face_net\")\n\n return model"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def build_model(input_classes,output_classes):\n dimensions = 20\n inputs = []\n embedded_outputs = []\n for i in input_classes:\n input_layer = Input((1,))\n inputs.append(input_layer)\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\n embedded_layer = embedder(input_layer)\n embedded_outputs.append(embedded_layer)\n\n embedded_concats = Concatenate()(embedded_outputs)\n flatten_layer = Flatten()\n\n dense_layer = Dense(output_classes)\n\n flattened_output = flatten_layer(embedded_concats)\n dense_output = dense_layer(flattened_output)\n\n # dense_output = dense_layer(embedded_concats)\n\n model = Model(inputs,dense_output)\n print(model.summary())\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\n\n return model","def build_cnn(self):\n model = Sequential()\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\n model.add(Flatten())\n model.add(Dense(len(ACTIONS), activation = 'linear'))\n model.compile(loss = 'mse', optimizer = Adam(lr = alpha))\n\n return model","def buildClassifier(input_shape=(100, 100, 3)):\n # Initialising the CNN\n classifier = Sequential()\n classifier.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape, padding='same'))\n classifier.add(MaxPooling2D(pool_size=(3, 3), padding='same'))\n classifier.add(Dropout(0.5)) # added extra Dropout layer\n classifier.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\n classifier.add(Conv2D(128, (3, 3), padding='same', activation='relu'))\n classifier.add(Dropout(0.5)) # added extra dropout layer\n classifier.add(Conv2D(256, (3, 3), activation='relu', padding='same'))\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\n classifier.add(Dropout(0.2)) # antes era 0.25\n classifier.add(Conv2D(512, (3, 3), padding='same', activation='relu'))\n classifier.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\n classifier.add(Dense(units=1024, activation='relu')) # added new dense layer\n classifier.add(Dropout(0.2)) # antes era 0.25\n # Step 3 - Flattening\n classifier.add(Flatten())\n classifier.add(Dense(units=1024, activation='relu')) # added new dense layer\n classifier.add(Dense(units=256, activation='relu')) # added new dense layer\n # Step 4 - Full connection\n classifier.add(Dropout(0.2))\n classifier.add(Dense(units=1, activation='sigmoid'))\n classifier.summary()\n\n # Compiling the CNN\n classifier.compile(optimizer='adam',\n loss='binary_crossentropy',\n metrics=['accuracy'])\n plot_model(classifier, to_file='model_plot.png', show_shapes=True, show_layer_names=True)\n return classifier","def construct_model():\n # model = Sequential()\n # model.add(Dense(units=64, activation='relu', input_dim=100))\n # model.add(Dense(units=10, activation='softmax'))\n # model.compile(loss='categorical_crossentropy',\n # optimizer='sgd',\n # metrics=['accuracy'])\n # return model\n\n model = Sequential()\n # Input Layer\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\n input_shape=(img_width, img_height, 3)))\n model.add(MaxPool2D(pool_size=2, strides=2))\n # Hidden Layer 1\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 2\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n # Hidden Layer 3\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\n model.add(MaxPool2D(pool_size=2, strides=2))\n\n\n # Fully Connected Layer\n model.add(Flatten())\n # 512 Neuron Layer\n model.add(Dense(512, activation='relu'))\n model.add(Dropout(0.5))\n # Output Layer\n model.add(Dense(num_of_classes))\n model.add(Activation('softmax'))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n return model","def concat_model():\n x = tf.keras.Input(shape=[10, 10, 3, ])\n x1 = tf.keras.layers.Conv2D(5, (2, 2))(x)\n x2 = tf.keras.layers.Conv2D(6, (2, 2))(x)\n x3 = tf.keras.layers.Conv2D(7, (2, 2))(x)\n z = tf.keras.layers.concatenate([x2, x1, x3], axis=-1)\n z1 = tf.keras.layers.Conv2D(10, (2, 2))(z)\n z2 = tf.keras.layers.Conv2D(10, (2, 2))(z)\n z = tf.add(z1, z2)\n z = tf.keras.layers.Flatten()(z)\n output = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\"concat_model\")(z)\n return output","def build(self):\n input_shape_img = (None, None, 3)\n img_input = Input(shape=input_shape_img)\n roi_input = Input(shape=(None, 4))\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\n \n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\n output_classifier = self.classifier(shared_layers,\n self.cnn_model.classifier_layers, \n roi_input, self.C.num_roi, \n num_class=len(self.class_count), trainable=True)\n \n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\n self.model_classifier = Model([img_input, roi_input], output_classifier)\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\n\n optimizer = Adam(lr=1e-5)\n self.model_region_proposal.compile(optimizer=optimizer, \n loss=[losses.rpn_loss_cls(num_anchors), \n losses.rpn_loss_regr(num_anchors)])\n self.model_classifier.compile(optimizer=optimizer, \n loss=[losses.class_loss_cls, \n losses.class_loss_regr(len(self.class_count)-1)], \n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\n self.model_all.compile(optimizer='sgd', loss='mae')\n\n # print(self.model_all.summary())\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')","def multiple_input_model():\n\n input1 = tf.keras.Input(name='input1', shape=(10, 10, 3))\n input2 = tf.keras.Input(name='input2', shape=(12, 12, 3))\n x1 = tf.keras.layers.Conv2D(8, (1, 1), name='conv1a')(input1)\n x2 = tf.keras.layers.Conv2D(8, (3, 3), name='conv1b')(input2)\n x = tf.keras.layers.add([x1, x2])\n x = tf.keras.layers.Conv2D(4, (1, 1), name='conv2')(x)\n x = tf.keras.layers.Flatten()(x)\n outputs = tf.keras.layers.Dense(2, activation=tf.nn.softmax, name=\"multiple_input_model\")(x)\n\n return outputs","def __init__(self, n_input_channels=3, n_conv_output_channels=16, k=3, s=1, pad=1, p = 0.5):\n super(ModelCNN, self).__init__()\n # 1. Convolutional layers\n # Single image is in shape: 3x96x96 (CxHxW, H==W), RGB images\n self.conv1 = nn.Conv2d(in_channels = n_input_channels, out_channels = n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn1 = nn.BatchNorm2d(n_conv_output_channels)\n self.conv2 = nn.Conv2d(in_channels = n_conv_output_channels, out_channels = 2*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn2 = nn.BatchNorm2d(2*n_conv_output_channels)\n self.conv3 = nn.Conv2d(in_channels = 2*n_conv_output_channels, out_channels = 4*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn3 = nn.BatchNorm2d(4*n_conv_output_channels)\n self.conv4 = nn.Conv2d(in_channels = 4*n_conv_output_channels, out_channels = 8*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn4 = nn.BatchNorm2d(8*n_conv_output_channels)\n self.pool = nn.MaxPool2d(kernel_size = k - 1, stride = 2*s, padding = pad - pad)\n \n self.dropout = nn.Dropout(p = p)\n \n # 2. FC layers to final output\n self.fc1 = nn.Linear(in_features = 288*n_conv_output_channels, out_features = 32*n_conv_output_channels)\n self.fc_bn1 = nn.BatchNorm1d(32*n_conv_output_channels)\n self.fc2 = nn.Linear(in_features = 32*n_conv_output_channels, out_features = 16*n_conv_output_channels)\n self.fc_bn2 = nn.BatchNorm1d(16*n_conv_output_channels)\n self.fc3 = nn.Linear(in_features = 16*n_conv_output_channels, out_features = 8*n_conv_output_channels)\n self.fc_bn3 = nn.BatchNorm1d(8*n_conv_output_channels)\n self.fc4 = nn.Linear(in_features = 8*n_conv_output_channels, out_features = 1)","def c3d(self):\n model = Sequential()\n # 1st layer group\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\n border_mode='same', name='conv1',\n subsample=(1, 1, 1),\n input_shape=self.input_shape))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\n border_mode='valid', name='pool1'))\n # 2nd layer group\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\n border_mode='same', name='conv2',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool2'))\n # 3rd layer group\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool3'))\n # 4th layer group\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='valid', name='pool4'))\n\n # 5th layer group\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5b',\n subsample=(1, 1, 1)))\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\n # model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n # border_mode='valid', name='pool5', dim_ordering=\"tf\"))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool5', dim_ordering=\"tf\"))\n model.add(Flatten())\n\n # FC layers group\n model.add(Dense(4096, activation='relu', name='fc6'))\n model.add(Dropout(0.5))\n model.add(Dense(4096, activation='relu', name='fc7'))\n model.add(Dropout(0.5))\n model.add(Dense(self.nb_classes, activation='softmax'))\n for layer in model.layers:\n print(layer.output_shape)\n return model","def build(bottom_model, num_classes):\n\n top_model = bottom_model.output\n top_model = GlobalAveragePooling2D()(top_model)\n top_model = Dense(1024,activation='relu')(top_model)\n top_model = Dense(1024,activation='relu')(top_model)\n top_model = Dense(512,activation='relu')(top_model)\n top_model = Dense(num_classes,activation='softmax')(top_model)\n return top_model","def create_multioutput_model(input_cols, output_cols):\n # Defining the model\n characteristics_input = keras.Input(shape=(len(input_cols)), name=\"characteristics\")\n x = layers.Dense(35, activation=\"relu\")(characteristics_input)\n x = layers.Dropout(0.22)(x)\n x = layers.Dense(31, activation=\"softmax\", kernel_constraint=constraints.NonNeg())(x)\n x = layers.Dropout(0.32)(x)\n\n fdc_outputs = []\n for i, fdc_exceedance_value in enumerate(output_cols):\n fdc_outputs.append(keras.layers.Dense(1, activation=\"linear\", kernel_constraint=constraints.NonNeg(),\n name=fdc_exceedance_value)(x))\n\n # Create the model\n model = keras.Model(\n inputs=[characteristics_input],\n outputs=fdc_outputs\n )\n\n # Compiling the model\n model.compile(\n loss=keras.losses.MeanAbsoluteError(),\n optimizer=keras.optimizers.Adam(learning_rate=0.005)\n )\n\n return model","def model_build(self):\n\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\n X_input = Input(self.inputData[0].shape)\n\n '''\n # CONV -> BN -> RELU Block applied to X\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\n X = BatchNormalization(name='bn0')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\n X = Dropout(0.1, name='dropout0')(X)\n\n X = Conv2D(16, (16, 16), name='conv1')(X)\n X = BatchNormalization(name='bn1')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\n X = Dropout(0.1, name='dropout1')(X)\n\n X = Conv2D(16, (32, 32), name='conv2')(X)\n X = BatchNormalization(name='bn2')(X)\n X = Activation('relu')(X)\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\n X = Dropout(0.1, name='dropout2')(X)\n' '''\n\n X = Dense(500, activation='relu', name='fc0')(X_input)\n X = Dropout(0.1, name='dropout1')(X)\n X = Dense(500, activation='relu', name='fc1')(X)\n X = Dropout(0.1, name='dropout2')(X)\n X = Dense(3, activation='softmax', name='fc2')(X)\n\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')","def __init__(self,inputSize,outputSize, *args, **kwds):\n #currently the code is only for 2 hidden layers, apart from in and out\n self._saveFile = kwds.get('saveFile')\n self._inputSize = inputSize\n self._outputSize= outputSize\n self._layer1 = keras.layers.Dense(128,activation='relu')\n self._layer2 = keras.layers.Dense(64,activation='relu') \n self._layer3 = keras.layers.Dense(128,activation='relu')\n self._piLayer = keras.layers.Dense(self._outputSize-1,activation='softmax')\n self._zLayer = keras.layers.Dense(1,activation='tanh')\n self._inputs = keras.Input(shape=(self._inputSize,)) #returns placeholder\n x = self._layer1(self._inputs)\n x = self._layer2(x)\n x = self._layer3(x)\n self._outPi = self._piLayer(x)\n self._outZ = self._zLayer(x)\n self._output = keras.layers.concatenate([self._outPi,self._outZ],axis = -1)\n self._model = keras.Model(inputs=self._inputs,outputs=self._outPi)\n# self._model = keras.Model(inputs=self._inputs,outputs=self._outPi)\n self._model.compile(optimizer=keras.optimizers.Adam(lr=0.001, beta_1=0.99, beta_2=0.999, epsilon=1e-10, decay=0.0001),\n loss=\"categorical_crossentropy\",\n metrics=['accuracy'])\n self._epochSize = 256","def build(self, input_image, num_class):\n x = build_resnet(101)\n # add classifier\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)","def __init__(self):\n super(Decoder_1m, self).__init__()\n self.lconvtwos = nn.ModuleList(\n [\n nn.Sequential(\n nn.Dropout(p=0.1),\n nn.Conv2d(128, 32, kernel_size=(3, 3), padding=1),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=1),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n ),\n ]\n )\n\n self.convtwos = nn.ModuleList(\n [\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=1),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=1),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n nn.Sequential(\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(32),\n nn.ReLU(inplace=True),\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\n nn.BatchNorm2d(64),\n nn.ReLU(inplace=True),\n ),\n ]\n )\n self.final = nn.Sequential(\n nn.Conv2d(64, 5, kernel_size=(1, 1), padding=0),\n nn.BatchNorm2d(5),\n nn.ReLU(inplace=True),\n nn.Conv2d(5, 1, kernel_size=(1, 1), padding=0),\n )","def __add_model_tail(model,\n n_outputs,\n dropout_rate,\n max_pool_size,\n lr=0.001):\n model.add(Dropout(dropout_rate))\n model.add(MaxPool1D(pool_size=max_pool_size))\n model.add(Flatten())\n model.add(Dense(100, activation='relu'))\n model.add(Dense(n_outputs, activation='softmax'))\n adam = Adam(lr)\n model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['categorical_accuracy'])\n\n return model","def _build_model(self):\n \n #convolutional part\n conv_inputs = keras.Input(shape = self._state_shape[0])\n c1 = layers.Conv2D(filters = 4, kernel_size = 2, strides = (2,2), padding = \"same\", activation = 'relu')(conv_inputs)\n c2 = layers.Conv2D(filters = 8, kernel_size = 2, strides = (1,1), padding = \"same\", activation = 'relu')(c1)\n flat = layers.Flatten()(c2)\n\n\n #current green phase layer\n # phase_inputs = keras.Input(shape = (self._state_shape[1],))\n \n #elapsed green time layer\n elapsed_time_inputs = keras.Input(shape = (self._state_shape[2],))\n \n \n #combine elapsed time and green time layer\n # combined_green = layers.concatenate([phase_inputs, elapsed_time_inputs])\n # green_dense = layers.Dense(10, activation='relu')(elapsed_time_inputs)\n \n #combine green layer with conv layer\n all_combined = layers.concatenate([elapsed_time_inputs, flat])\n dense = layers.Dense(32, activation='relu')(all_combined)\n dense = layers.Dense(16, activation='relu')(dense)\n outputs = layers.Dense(self._output_dim, activation='linear')(dense)\n \n model = keras.Model(inputs = [conv_inputs, elapsed_time_inputs], outputs = outputs, name='simple_CNN') \n model.compile(loss=losses.mean_squared_error, optimizer=Adam(lr=self._learning_rate))\n \n return model","def __init__(self, args):\n \n super(MicroNet, self).__init__()\n self.conv1 = nn.Conv2d(3, 1, kernel_size=1)\n self.conv2 = nn.Conv2d(1, 29, kernel_size=5)\n self.maxpool2 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv3 = nn.Conv2d(29, 59, kernel_size=3)\n self.maxpool3 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv4 = nn.Conv2d(59, 74, kernel_size=3)\n self.maxpool4 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\n self.conv2_drop = nn.Dropout2d()\n self.conv3_drop = nn.Dropout2d()\n self.fc1 = nn.Linear(1184, 300)\n self.fc2 = nn.Linear(300, args.num_classes)\n self.conv0_bn = nn.BatchNorm2d(3)\n self.conv1_bn = nn.BatchNorm2d(1)\n self.conv2_bn = nn.BatchNorm2d(29)\n self.conv3_bn = nn.BatchNorm2d(59)\n self.conv4_bn = nn.BatchNorm2d(74)\n self.dense1_bn = nn.BatchNorm1d(300)","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 build_combined(self, num_classes: int = 10) -> KM.Model:\n\n # For decoder number of features in opposite order of encoder\n decoder_features = self.encoder_features.copy()\n decoder_features.reverse()\n\n # build the encoder model\n self.encoder_model = self.encoder(\n features=self.encoder_features, name=\"encoder\"\n )\n\n # build the decoder model\n decoder = self.decoder(features=decoder_features, name=\"decoder\")\n input_tensor = KL.Input(\n shape=(32, 32, 3)\n ) # shape of images for cifar10 dataset\n\n # Encode the images\n encoded_features = self.encoder_model(input_tensor)\n # Decode the image from the final layer features of Auto-encoder\n decoded = decoder(encoded_features[-1])\n contrastive_features = KL.Lambda(lambda x: K.mean(x, [1, 2]), name=\"contrast\")(\n encoded_features[-1]\n )\n # Calculate class probs from multiple latent representations\n probs = classifier_block(encoded_features, num_classes=num_classes)\n\n return KM.Model(\n inputs=input_tensor,\n outputs=[decoded, probs, contrastive_features],\n name=\"combined\",\n )","def compile_model_cnn(genome, nb_classes, input_shape):\n # Get our network parameters.\n nb_layers = genome.geneparam['nb_layers' ]\n nb_neurons = genome.nb_neurons()\n activation = genome.geneparam['activation']\n optimizer = genome.geneparam['optimizer' ]\n\n logging.info(\"Architecture:%s,%s,%s,%d\" % (str(nb_neurons), activation, optimizer, nb_layers))\n\n model = Sequential()\n\n # Add each layer.\n for i in range(0,nb_layers):\n # Need input shape for first layer.\n if i == 0:\n model.add(Conv2D(nb_neurons[i], kernel_size = (3, 3), activation = activation, padding='same', input_shape = input_shape))\n else:\n model.add(Conv2D(nb_neurons[i], kernel_size = (3, 3), activation = activation))\n \n if i < 2: #otherwise we hit zero\n model.add(MaxPooling2D(pool_size=(2, 2)))\n \n model.add(Dropout(0.2))\n\n model.add(Flatten())\n # always use last nb_neurons value for dense layer\n model.add(Dense(nb_neurons[len(nb_neurons) - 1], activation = activation))\n model.add(Dropout(0.5))\n model.add(Dense(nb_classes, activation = 'softmax'))\n\n #BAYESIAN CONVOLUTIONAL NEURAL NETWORKS WITH BERNOULLI APPROXIMATE VARIATIONAL INFERENCE\n #need to read this paper\n\n model.compile(loss='categorical_crossentropy',\n optimizer=optimizer,\n metrics=['accuracy'])\n\n return model","def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\n\t\t# We have to match this output size.\n\t\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\n\t\n\t\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\n\t\n\t\t# Convolutional ops will go here.\n\t\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tconv_output = c5\n\t\n\t\t# Transition to FC layers.\n\t\tpre_flat_shape = conv_output.get_shape().as_list()\n\t\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\n\t\n\t\t# Dense connections\n\t\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\n\t\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\n\t\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\n\t\tfc_out = fc2\n\t\n\t\t# Output point and our encoder mix-in.\n\t\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\n\t\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\n\t\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\n\t\n\t\t# More dense connections on the offset.\n\t\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\n\t\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\n\t\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\n\t\n\t\t# Expand for more convolutional operations.\n\t\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\n\t\n\t\t# More convolutions here.\n\t\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\n\t\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\n\t\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\n\t\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tdeconv_output = dc0\n\t\n\t\t# Return result + encoder output\n\t\treturn deconv_output, encoded_output","def build_model_mobilenet(num_classes):","def set_component_outputs(self):\n outputs = []\n\n text = Text(self.get_data(), self.vocabulary)\n dp = DataPack(text, usage=self.indices)\n outputs.append(dp)\n\n if self.is_labelled():\n labels_data = Numeric(self.labels)\n labels_usage = Labels(self.label_names, self.multilabel)\n dp = DataPack(labels_data, labels_usage)\n dp.add_usage(self.indices)\n outputs.append(dp)\n if self.targets:\n # tar = self.train_targets + self.test_targets\n # dp = DataPack.make(tar, GroundTruth)\n dp = DataPack.make(self.targets, GroundTruth)\n dp.add_usage(self.indices)\n outputs.append(dp)\n\n self.data_pool.add_data_packs(outputs, self.name)","def buildModel(self, img_shape = 20, num_categories = 10):\n\n # Add first convolutional layer and max pooling\n self.model.add(Conv2D(32, # Number of features detectors (filters)\n (3, # 3 Row (conv. matrix)\n 3), # 3 Columns (conv.matrix usually 3x3)\n input_shape=(img_shape, img_shape, 3), # 3 Channels, img_shape x img_shape images\n activation='relu', # Activation function to increase nonlinearity of images\n name = 'FirstConv2DLayer')) # Layer name\n self.model.add(MaxPooling2D(pool_size=(2, 2))) # Size of pooling matrix (usually 2x2)\n\n # Add second convolutional layer and max pooling\n self.model.add(Conv2D(32, (3, 3), input_shape=(img_shape, img_shape, 3), activation='relu', name ='SecondConv2DLayer'))\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\n\n # Flattening\n self.model.add(Flatten())\n\n # Full connection\n self.model.add(Dense(units=128, activation='relu'))\n\n # One output for each category we predicted want to predict\n self.model.add(Dense(units=num_categories, activation='softmax', name='Probabilities')) # Softmax for more than two outcome\n\n # Compile the CNN (Gradient descent)\n self.model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])","def create_cnn(num_features: int = None) -> models.Model:\n nclass = num_features or 5\n inp = Input(shape=(187, 1))\n img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\"valid\")(inp)\n # img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = GlobalMaxPool1D()(img_1)\n img_1 = Dropout(rate=0.2)(img_1)\n\n dense_1 = Dense(64, activation=activations.relu, name=\"dense_1\")(img_1)\n dense_1 = Dense(64, activation=activations.relu, name=\"dense_2\")(dense_1)\n dense_1 = Dense(nclass, activation=activations.softmax, name=\"dense_3_mitbih\")(dense_1)\n\n model = models.Model(inputs=inp, outputs=dense_1)\n opt = optimizers.Adam(learning_rate=0.001)\n\n model.compile(optimizer=opt,\n loss=losses.sparse_categorical_crossentropy,\n metrics=['accuracy'])\n model.summary()\n return model","def build_outputs(self):\n with tf.variable_scope(\"build_outputs\"):\n\n self.optical_flow = self.__optical_flow_src2_tgt\n self.disp = self.baselineNet.disp_tgt\n self.semantic = self.__semantic\n self.motion_mask = self.prepare_final_motion_mask()","def build(self):\n\n # bgr_ = bgr*255.0\n bgr_= self.X\n start_time = time.time()\n print(\"build model started\")\n\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n bgr = tf.concat(axis=3, values=[\n # blue - VGG_MEAN[0],\n # green - VGG_MEAN[1],\n # red - VGG_MEAN[2],\n\n red - VGG_MEAN[0],\n green - VGG_MEAN[1],\n blue - VGG_MEAN[2],\n ])\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n\n\n\n print(bgr.shape)\n\n self.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\n self.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\n self.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\n self.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\n\n\n\n self.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\n self.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\n self.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\n\n self.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\n self.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\n self.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\n\n\n\n\n\n self.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\n self.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\n self.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\n\n self.fc6 = self.fc_layer(self.pool5, \"fc6\")\n assert self.fc6.get_shape().as_list()[1:] == [4096]\n self.relu6 = tf.nn.relu(self.fc6)\n\n self.fc7 = self.fc_layer(self.relu6, \"fc7\")\n self.relu7 = tf.nn.relu(self.fc7)\n\n self.fc8 = self.fc_layer(self.relu7, \"fc8\")\n\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\n # self.relu9 = tf.nn.relu(self.fc9)\n\n\n\n\n relu8 = tf.nn.relu(self.fc8)\n fc9 = self.fc_layer(relu8, 'fc9')\n print((\"build model finished: %ds\" % (time.time() - start_time)))\n return fc9\n\n # self.prob = tf.nn.softmax(self.fc8, name=\"prob\")","def initialize_models(self): \n state_shape = list(self.env.observation_space.shape)\n img_height, img_width, n_channels = state_shape\n num_actions = self.env.action_space.n\n print(\"img_height: \", img_height)\n print(\"img_width: \", img_width)\n print(\"n_channels: \", n_channels)\n print(\"n_actions: \", num_actions)\n\n ##############################################################\n ################ YOUR CODE HERE - 25-30 lines lines ################\n modules = OrderedDict()\n\n # def conv_output_shape(h_w, kernel_size=1, stride=1, pad=0, dilation=1): -> h,w \n pad1 = (3 * img_height - 4 + 8) // 2\n modules['0'] = nn.Conv2d(n_channels * self.config.state_history, 32, 8, stride=4, padding=pad1)\n modules['relu1'] = nn.ReLU()\n out1h, out1w = conv_output_shape((img_height, img_width), kernel_size=8, stride=4, pad=pad1, dilation=1)\n\n pad2 = (out1w + 2) // 2\n modules['2'] = nn.Conv2d(32, 64, 4, stride=2, padding=pad2)\n modules['relu3'] = nn.ReLU()\n out2h, out2w = conv_output_shape((out1h, out1w), kernel_size=4, stride=2, pad=pad2, dilation=1)\n\n pad3 = 1\n modules['4'] = nn.Conv2d(64, 64, 3, stride=1, padding=pad3)\n modules['relu5'] = nn.ReLU()\n out3h, out3w = conv_output_shape((out2h, out2w), kernel_size=3, stride=1, pad=pad3, dilation=1)\n\n modules['flatten'] = nn.Flatten()\n modules['fc'] = nn.Linear(out3h*out3w*64, num_actions)\n self.q_network = nn.Sequential(modules)\n\n target_modules = OrderedDict()\n target_modules['t_layer1'] = nn.Conv2d(n_channels * self.config.state_history, 32, 8, stride=4, padding=pad1)\n target_modules['t_relu1'] = nn.ReLU()\n target_modules['t_layer2'] = nn.Conv2d(32, 64, 4, stride=2, padding=pad2)\n target_modules['t_relu2'] = nn.ReLU()\n target_modules['t_layer3'] = nn.Conv2d(64, 64, 3, stride=1, padding=pad3)\n target_modules['t_relu3'] = nn.ReLU()\n target_modules['t_flatten'] = nn.Flatten()\n target_modules['t_fc'] = nn.Linear(out3h*out3w*64, num_actions)\n self.target_network = nn.Sequential(target_modules)\n\n ##############################################################\n ######################## END YOUR CODE #######################","def build_dc_classifier():\n # return nn.Sequential(\n # Unflatten(Batch_size, 1, 28, 28),\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(2, stride=2),\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.MaxPool2d(kernel_size=2, stride=2),\n # Flatten(),\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\n # nn.LeakyReLU(negative_slope=0.01),\n # nn.Linear(4 * 4 * 64, 1)\n # )\n\n return nn.Sequential(\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\n nn.LeakyReLU(negative_slope=0.01),\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\n Flatten(),\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\n nn.LeakyReLU(negative_slope=0.01),\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\n )","def build_model_multihead_attention_multiscaleCNN4_covermore(self,\n dim_attention,headnum,\n embedding_vec,\n load_weights=False, weight_dir=None,\n nb_filters=32,filters_length1=1,\n filters_length2=5,\n filters_length3=10,\n pooling_size=3,\n drop_input=0,\n drop_cnn=0.2,\n drop_flat=0,\n W1_regularizer=0.005,\n W2_regularizer=0.005,\n Att_regularizer_weight=0.0005,\n BatchNorm=False,\n fc_dim = 50,\n fcnum=0,\n posembed=False,\n pos_dmodel=40,\n pos_nwaves = 20,\n posmod = 'concat',\n regularfun=1,\n huber_delta=1,\n activation='gelu',\n activationlast='gelu',\n add_avgpooling = False,\n poolingmod=1,\n normalizeatt=False,\n regressionmodel=False,\n attmod = \"softmax\",\n sharp_beta=1,\n lr = 0.001 \n ):\n ###print('Advanced Masking')\n def mask_func(x):\n return x[0] * x[1]\n \n ###print(posembed)\n ###print(posmod)\n input = Input(shape=(self.max_len,), dtype='int8')\n input_mask = Input(shape=([int(self.max_len/pooling_size), 1]), dtype='float32')\n embedding_layer = Embedding(len(embedding_vec), len(embedding_vec[0]), weights=[embedding_vec],\n input_length=self.max_len,\n trainable=False)\n embedding_output = Dropout(drop_input)(embedding_layer(input)) #layer2\n if 'gelu' in activation:\n activationfun=gelu\n else:\n activationfun = 'relu'\n \n if 'gelu' in activationlast:\n activationlastfun = gelu\n else:\n activationlastfun='relu'\n \n ###print(activationfun)\n ###print(activationlastfun)\n with tf.name_scope('first_cnn'):\n first_cnn = Convolution1D(nb_filters, filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN1')(embedding_output) #layer3\n first_cnn2 = Convolution1D(int(nb_filters/2), filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(first_cnn) #layer5\n second_cnn = Convolution1D(nb_filters, filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN2')(embedding_output) #layer4\n second_cnn2 = Convolution1D(int(nb_filters/2), filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(second_cnn)\n third_cnn = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationfun, use_bias=False,name='CNN3')(embedding_output)\n \n third_cnn2 = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\n border_mode='same', activation=activationlastfun, use_bias=False)(third_cnn)\n if BatchNorm:\n first_cnn2 = BatchNormalization()(first_cnn2)\n second_cnn2 = BatchNormalization()(second_cnn2)\n third_cnn2 = BatchNormalization()(third_cnn2)\n \n if not add_avgpooling:\n if poolingmod == 1:\n pooling_layer = MaxPooling1D(pool_length=pooling_size, stride=pooling_size)\n else:\n pooling_layer = AveragePooling1D(pool_length=pooling_size, stride=pooling_size)\n \n cnn_output1 = Dropout(drop_cnn)(pooling_layer(first_cnn2))\n cnn_output2 = Dropout(drop_cnn)(pooling_layer(second_cnn2))\n cnn_output3 = Dropout(drop_cnn)(pooling_layer(third_cnn2))\n else:\n first_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\n first_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\n cnn_output1 = Dropout(drop_cnn)(concatenate([first_cnn2_max,first_cnn2_avg],axis=-1))\n second_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\n second_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\n cnn_output2 = Dropout(drop_cnn)(concatenate([second_cnn2_max,second_cnn2_avg],axis=-1))\n third_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\n third_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\n cnn_output3 = Dropout(drop_cnn)(concatenate([third_cnn2_max,third_cnn2_avg],axis=-1))\n \n \n \n if posembed:\n ##print(posmod)\n from position_embedding import PositionEmbedding\n if posmod == 'concat':\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb1')(cnn_output1)\n cnn_output1 = concatenate([cnn_output1, pos_emb1], axis=-1)\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb2')(cnn_output2)\n cnn_output2 = concatenate([cnn_output2, pos_emb2], axis=-1)\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb3')(cnn_output3)\n cnn_output3 = concatenate([cnn_output3, pos_emb3], axis=-1)\n else:\n ##print(\"yes add posmod\")\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output1)[-1]/2), d_model=int_shape(cnn_output1)[-1],name='pos_emb1')(cnn_output1)\n cnn_output1 = Add()([cnn_output1, pos_emb1])\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output2)[-1]/2), d_model=int_shape(cnn_output2)[-1],name='pos_emb2')(cnn_output2)\n cnn_output2 = Add()([cnn_output2, pos_emb2])\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output3)[-1]/2), d_model=int_shape(cnn_output3)[-1],name='pos_emb3')(cnn_output3)\n cnn_output3 = Add()([cnn_output3, pos_emb3])\n \n mask_input1 = []\n mask_input1.append(cnn_output1)\n mask_input1.append(input_mask)\n cnn_mask_output1 = Lambda(mask_func)(mask_input1)\n del mask_input1\n mask_input2 = []\n mask_input2.append(cnn_output2)\n mask_input2.append(input_mask)\n cnn_mask_output2 = Lambda(mask_func)(mask_input2)\n del mask_input2\n mask_input3 = []\n mask_input3.append(cnn_output3)\n mask_input3.append(input_mask)\n cnn_mask_output3 = Lambda(mask_func)(mask_input3)\n del mask_input3\n \n if regularfun==1:\n regularizerfunction_W1 = regularizers.l1(W1_regularizer)\n regularizerfunction_W2 = regularizers.l1(W2_regularizer)\n elif regularfun==2:\n regularizerfunction_W1 = regularizers.l2(W1_regularizer)\n regularizerfunction_W2 = regularizers.l2(W2_regularizer)\n elif regularfun ==3:\n regularizerfunction_W1 = smoothL1(W1_regularizer,huber_delta)\n regularizerfunction_W2 = smoothL1(W2_regularizer,huber_delta)\n \n with tf.name_scope('multihead_attention'):\n att1,att1_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att1\")(concatenate([cnn_mask_output1, input_mask]))#-5 layer\n \n att2,att2_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att2\")(concatenate([cnn_mask_output2, input_mask])) #-4 layer\n \n att3,att3_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\n W1_regularizer=regularizerfunction_W1,\n W2_regularizer=regularizerfunction_W2,\n W1_constraint=None, W2_constraint=None, return_attention=True,\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\"att3\")(concatenate([cnn_mask_output3, input_mask])) #-3 layer\n \n if BatchNorm:\n att1 = BatchNormalization()(att1)\n att2 = BatchNormalization()(att2)\n att3 = BatchNormalization()(att3)\n \n \n output = Dropout(drop_flat)(Flatten()(concatenate([att1,att2,att3]))) #-2 layer\n \n fc = output\n for _ in range(fcnum):\n fc = Dense(fc_dim,activation='relu')(fc)\n fc = Dropout(drop_flat)(fc)\n \n with tf.name_scope(''):\n if regressionmodel:\n preds = Dense(self.nb_classes,activation='softmax')(fc) #-1 layer\n else:\n preds = Dense(self.nb_classes,activation='sigmoid')(fc) #-1 layer\n \n self.model = Model(inputs=[input,input_mask], outputs=preds)\n from keras import optimizers\n # optim = optimizers.RMSprop()\n optim = optimizers.Adam(lr=lr, decay=5e-5) #The paper uses a decay rate alpha = alpha/sqrt(t) updted each epoch (t) for the logistic regression demonstration.\n #optim = optimizers.nadam()\n #optim = RAdam()\n if regressionmodel:\n self.model.compile(loss='kld',optimizer=optim,metrics=['acc'])\n else:\n self.model.compile(loss='binary_crossentropy',optimizer=optim,metrics=['binary_accuracy','categorical_accuracy'])\n \n \n \n if load_weights:\n self.model.load_weights(weight_dir)\n \n self.is_built = True\n self.bn = False\n self.model.summary()","def MakeModel(self):\n group1, group2 = self.data\n self.n, self.m = len(group1), len(group2)\n self.pool = np.hstack((group1, group2))","def MakeModel(self):\n group1, group2 = self.data\n self.n, self.m = len(group1), len(group2)\n self.pool = np.hstack((group1, group2))","def build_model_cnn(x_train, n=32, d=0.25, k=5):\n model = Sequential()\n model.add(Dropout(rate = d, input_shape = (x_train.shape[1], 1)))\n model.add(Conv1D(filters=n, kernel_size=(5), strides=1, activation = 'relu', kernel_constraint=max_norm(4)))\n model.add(Dropout(rate = d))\n model.add(MaxPooling1D(pool_size=k))\n model.add(Conv1D(filters=n, kernel_size=(5), strides=1, activation = 'relu', kernel_constraint=max_norm(4)))\n model.add(Dropout(rate = d))\n model.add(MaxPooling1D(pool_size=k))\n model.add(Flatten())\n model.add(Dense(n, activation ='relu', kernel_constraint=max_norm(4)))\n model.add(Dense(4, activation = 'softmax')) # eliminated Q label\n model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['categorical_accuracy'])\n return model","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_CNNflexi_Modular(input):\n\n params_3D = input['params']\n sample_shape = input['sample_shape']\n inputA = Input(shape=sample_shape[1:])\n clf = params_3D['clf']\n\n # Model head\n for i_layers in range(0,params_3D['n_layers']):\n if i_layers == 0:\n x = conv3D_block(params_3D,inputA)\n else:\n x = conv3D_block(params_3D, x)\n\n # Classifiers\n if clf == 'dense':\n x = Flatten()(x)\n x = Dense(256, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\n x = Dense(128, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\n x = Dense(64, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\n elif clf == 'gap':\n x = GlobalAveragePooling3D()(x)\n else:\n raise('Invalid classifier choice!')\n\n\n model = Model(inputs=inputA, outputs=x)\n return model","def build_network(self):\n net = self.ccf_data\n\n # Reshape [length] -> [length, 1].\n net = tf.expand_dims(net, -1)\n\n # create summary object\n summary = []\n\n for i in self.hparams.conv_block_filters:\n for _ in range(self.hparams.conv_layers_per_block):\n input_shape = net.shape.as_list()\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\n activation=tf.nn.relu)\n net = conv_op(net)\n summary.append(\"Conv1D-{}-{}. Input shape: {}. Output shape: {}\".format(self.hparams.kernel_size, i, input_shape,\n net.shape.as_list()))\n pool_size = 2\n strides = 2\n max_pool = tf.keras.layers.MaxPool1D(pool_size=pool_size, strides=strides)\n net = max_pool(net)\n summary.append(\"MaxPool1D-{}. Pool Size: {}. Strides: {}\".format(self.hparams.kernel_size, pool_size, strides))\n\n for i in self.hparams.final_conv_num_filters:\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\n activation=tf.nn.relu)\n net = conv_op(net)\n flatten = tf.keras.layers.Flatten()\n net = flatten(net)\n\n for i in self.hparams.dense_num_layers:\n dense = tf.keras.layers.Dense(i, activation=tf.nn.relu)\n net = dense(net)\n\n # output layer\n output = tf.keras.layers.Dense(1)\n net = tf.squeeze(output(net))\n\n self.summary = \"\\n\".join(summary)\n self.predicted_rv = net","def output(self,x=None,h=None,in_features=0,in_features_h=0,reuse=False):\n assert (x is not None or h is not None)\n print('re'*10,reuse , self.name)\n stride=[1, self.cnn_stride, self.cnn_stride, 1]\n with tf.variable_scope(self.name):\n Wxi=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Wxi')\n Whi=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Whi')\n Wxf=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Wxf')\n Whf=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Whf')\n Wxc=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Wxc')\n Whc=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Whc')\n Wxo=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Wxo')\n Who=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='conv_Who')\n Wci=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='ele_Wci')\n Wcf=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='ele_Wcf')\n Wco=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\n kname=self.weight_init, name='ele_Wco')\n if not reuse and h is None:\n print('xr'*20,x.get_shape().as_list(),in_features,self.out_features,in_features_h)\n h=tf.zeros((1,self.height,self.width,self.out_features))\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi')+self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf')+self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc')+self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo')+self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\n else:\n # print('x'*10,x.shape,'\\\\n Wxi',Wxi.shape,'\\\\n h ',h.shape,Whi.shape,'\\\\n c ',Wci.shape)\n if h is None:\n # print('x'*20,x.get_shape().as_list(),in_features,out_features)\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi',use_bias=True)+Wci*self._cell)\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf',use_bias=True)+Wcf*self._cell)\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc',use_bias=True))\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo',use_bias=True)+Wco*self._cell)\n elif x is None:\n # print('h'*20,h.get_shape().as_list(),in_features_h,out_features)\n self._input=tf.sigmoid(self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\n self._forget=tf.sigmoid(self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\n self._output=tf.sigmoid(self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\n else:\n # print('xh'*20,x.get_shape().as_list(),in_features,out_features,in_features_h)\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi')+self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf')+self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc')+self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo')+self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\n h=self._output*tf.tanh(self._cell)\n\n return h","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 SRCNN(input_shape, depth_multiplier=1, multi_output=False):\n inputs = Input(input_shape, name=\"inputs\")\n conv1 = Convolution2D(filters=64*depth_multiplier, kernel_size=9, padding=\"same\", name=\"conv1\", activation=\"relu\")(inputs)\n #conv1 = BatchNormalization(name='bn_conv1')(conv1)\n \n mapping = Convolution2D(filters=32*depth_multiplier, kernel_size=1, padding=\"same\", name=\"mapping\", activation=\"relu\")(conv1)\n #mapping = BatchNormalization(name='bn_mapping')(mapping)\n \n if multi_output:\n out = Convolution2D(filters=2, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n else:\n out = Convolution2D(filters=1, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n return Model(inputs, out)","def __init__(self):\n\n super(ConvModule, self).__init__()\n\n self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=5, stride=[1, 2])\n self.conv1_bn = nn.BatchNorm2d(64)\n self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5, stride=[1, 2])\n self.conv2_bn = nn.BatchNorm2d(128)\n self.pool1 = nn.MaxPool2d(kernel_size=4, stride=2)\n self.dropout0 = nn.Dropout(p=0.4)\n\n self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=[1, 2])\n self.conv3_bn = nn.BatchNorm2d(256)\n self.conv4 = nn.Conv2d(in_channels=256, out_channels=64, kernel_size=3, stride=[1, 2])\n self.conv4_bn = nn.BatchNorm2d(64)\n self.pool2 = nn.MaxPool2d(kernel_size=4, stride=2)\n #\n # self.conv5 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=[1, 2])\n # self.conv5_bn = nn.BatchNorm2d(64)\n # self.pool3 = nn.MaxPool2d(kernel_size=3, stride=[1, 2])","def __init__(self):\n super(Generator, self).__init__()\n\n # output feature map will have the size of 8x8\n self.first_deconv = TransitionUp(in_channels=3, out_channels=256, stride=2, padding=1, kernel_size=4)\n self.first_batch_norm = nn.BatchNorm2d(256)\n\n # output feature map will have the size of 16x16\n self.second_deconv = TransitionUp(in_channels=256, out_channels=128, stride=2, padding=1, kernel_size=4)\n self.second_batch_norm = nn.BatchNorm2d(128)\n\n # output feature map will have the size of 32x32\n self.third_deconv = TransitionUp(in_channels=128, out_channels=32, stride=2, padding=1, kernel_size=4)\n self.third_batch_norm = nn.BatchNorm2d(32)\n\n # output feature map will have the size of 64x64\n self.fourth_deconv = TransitionUp(in_channels=32, out_channels=16, stride=2, padding=1, kernel_size=4)\n self.fourth_batch_norm = nn.BatchNorm2d(16)\n\n # output feature map will have the size of 128x128\n self.fifth_deconv = TransitionUp(in_channels=16, out_channels=16, stride=1, padding=1, kernel_size=4)\n self.fifth_batch_norm = nn.BatchNorm2d(16)\n\n # output feature map will have the size of 128x128\n self.sixth_deconv = TransitionUp(in_channels=16, out_channels=16, stride=1, padding=1, kernel_size=4)\n self.sixth_batch_norm = nn.BatchNorm2d(16)\n\n # output feature map will have the size of 128x128\n self.seventh_deconv = TransitionUp(in_channels=16, out_channels=3, stride=1, padding=1, kernel_size=4)","def c3dLSTM(self):\n model = Sequential()\n # 1st layer group\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\n border_mode='same', name='conv1',\n subsample=(1, 1, 1),\n input_shape=self.input_shape))\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\n border_mode='same', name='pool1'))\n # 2nd layer group\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\n border_mode='same', name='conv2',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool2'))\n # 3rd layer group\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\n border_mode='same', name='conv3b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool3'))\n # 4th layer groupprint(layer.get_shape())\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv4b',\n subsample=(1, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool4'))\n\n # 5th layer group\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5a',\n subsample=(1, 1, 1)))\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\n border_mode='same', name='conv5b',\n subsample=(1, 1, 1)))\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\n border_mode='same', name='pool5'))\n shaped=model.layers[13].output.get_shape()\n print(shaped[1], shaped[2], shaped[3])\n # model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='sigmoid', padding='same', input_shape=[self.seq_length,shaped[1],shaped[2],shaped[3]],\n # return_sequences=True)) GlobalAveragePooling3D\n # model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='relu', padding='valid',\n # input_shape=[1, shaped[1], shaped[2], shaped[3]],\n # return_sequences=True,kernel_regularizer=l2(0.1),recurrent_dropout=0.5))\n model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='relu', padding='valid', return_sequences=True,kernel_regularizer=l2(0.1),recurrent_dropout=0.5))\n model.add(ConvLSTM2D(640, kernel_size=(3, 3), activation='relu', padding='valid', return_sequences=True,\n kernel_regularizer=l2(0.1), recurrent_dropout=0.5))\n model.add(BatchNormalization())\n model.add(Flatten())\n #new added two dense\n model.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.001)))\n model.add(Dropout(0.5))\n model.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.001)))\n model.add(Dropout(0.5))\n # FC layers group\n #x = Dense(2048,activation='relu',kernel_regularizer=l2(weight_decay))(x)\n # x = Dropout(0.5)(x)\n model.add(Dense(self.nb_classes, activation='softmax'))\n\n return model","def SRCNNv2(input_shape, depth_multiplier=1, multi_output=False):\n inputs = Input(input_shape, name=\"inputs\")\n conv1 = Convolution2D(filters=64, kernel_size=9, padding=\"same\", name=\"conv1\", activation=\"relu\")(inputs)\n conv2 = Convolution2D(filters=64, kernel_size=7, padding=\"same\", name=\"conv2\", activation=\"relu\")(conv1)\n #conv3 = Convolution2D(filters=64, kernel_size=3, padding=\"same\", name=\"conv3\", activation=\"relu\")(conv2)\n\n mapping = Convolution2D(filters=32, kernel_size=5, padding=\"same\", name=\"mapping\", activation=\"relu\")(conv2)\n #mapping2 = Convolution2D(filters=16, kernel_size=7, padding=\"same\", name=\"mapping2\", activation=\"relu\")(mapping)\n \n \n if multi_output:\n out = Convolution2D(filters=2, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n else:\n out = Convolution2D(filters=1, kernel_size=5, padding=\"same\", name=\"output\", activation=\"sigmoid\")(mapping)\n return Model(inputs, out)","def compile_model(self, nb_classes, input_shape):\n\n # Get our network parameters.\n number_of_layers = self.network['number_of_layers']\n neurons_per_layer = self.network['neurons_per_layer']\n dropout_per_layer = self.network['dropout_per_layer']\n activation = self.network['activation']\n optimizer = self.network['optimizer']\n\n model = Sequential()\n\n if type(neurons_per_layer) is int:\n self.network['neurons_per_layer'] = [neurons_per_layer]\n\n if type(dropout_per_layer) is float:\n self.network['dropout_per_layer'] = [dropout_per_layer]\n\n\n if number_of_layers != len(self.network['neurons_per_layer']):\n self.network['neurons_per_layer'] = correct_neurons_per_layer(self.network)\n\n if number_of_layers != len(self.network['dropout_per_layer']):\n self.network['dropout_per_layer'] = correct_dropout_per_layer(self.network)\n\n print(\"number of layers: \" + str(number_of_layers))\n print(\"neurons: \" + str(self.network['neurons_per_layer']) + \" with \" + activation)\n print(\"dropout: \" + str(self.network['dropout_per_layer']))\n\n # Add each layer.\n for i in range(len(self.network['neurons_per_layer'])):\n # Need input shape for first layer.\n if i == 0:\n model.add(Dense(self.network['neurons_per_layer'][i], activation=activation, input_shape=input_shape))\n else:\n model.add(Dense(self.network['neurons_per_layer'][i], activation=activation))\n\n model.add(Dropout(self.network['dropout_per_layer'][i]))\n\n # Output layer.\n model.add(Dense(nb_classes, activation='softmax'))\n\n model.compile(loss='categorical_crossentropy', optimizer=optimizer,\n metrics=['accuracy'])\n\n return model","def build_all_connected_models(feature_dim, output_scheme=\"regression\", num_classes=num_classes):\n\tinput_layer = keras.layers.Input(shape=[feature_dim])\n\thidden1 = keras.layers.Dense(800, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_layer)\n\t#bn1 = keras.layers.BatchNormalization()(hidden1)\n\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\n\t#hidden2 = keras.layers.Dense(500, activation='relu', \n\t#\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t#\tkernel_initializer=\"he_uniform\")(dropout1)\n\t#bn2 = keras.layers.BatchNormalization()(hidden2)\n\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\n\thidden3 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\n\t# trait-specific network\n\thidden4_1 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_2 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_3 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_4 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\thidden4_5 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout3)\n\t#bn3 = keras.layers.BatchNormalization()(hidden3)\n\tif (output_scheme==\"regression\"):\n\t\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\n\t\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tout1 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden4_1)\n\t\tout2 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden4_2)\n\t\tout3 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden4_3)\n\t\tout4 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden4_4)\n\t\tout5 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden4_5)\n\tmodel = keras.models.Model(inputs=[input_layer],\n\t\t\t\t\t\t\t outputs=[out1, out2, out3, out4, out5])\n\tif (output_scheme == \"regression\"):\n\t\tmodel.compile(loss=\"mse\", \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.0001),\n\t\t\t\t\t metrics=['mae', custom_r2_metric])\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.001))\n\tprint(model.summary())\n\treturn model","def compile_model(self, data):\n model=Sequential()\n\n model.add(Conv2D(self.conv_1_mapnum, \n (self.filter_width, self.filter_width),\n input_shape=data.shape[1:], \n strides=self.strides_len,\n padding='same', data_format='channels_last',\n dilation_rate=1, activation=self.acti_1_func, use_bias=True, \n kernel_initializer='glorot_uniform', bias_initializer='zeros', \n kernel_regularizer=l2(0.001), bias_regularizer=None, \n activity_regularizer=None, kernel_constraint=None, \n bias_constraint=None))\n\n if self.batch_norm:\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \n center=True, scale=True, \n beta_initializer='zeros', gamma_initializer='ones',\n moving_mean_initializer='zeros', \n moving_variance_initializer='ones',\n beta_regularizer=None, gamma_regularizer=None,\n beta_constraint=None, gamma_constraint=None))\n\n if self.spatial_drop:\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\n\n if self.pool_method=='mean':\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n if self.pool_method=='max':\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n \n model.add(Conv2D(self.conv_2_mapnum, \n (self.filter_width, self.filter_width),\n strides=self.strides_len,\n padding='same', data_format='channels_last',\n dilation_rate=1, activation=self.acti_2_func, use_bias=True, \n kernel_initializer='glorot_uniform', bias_initializer='zeros', \n kernel_regularizer=l2(0.001), bias_regularizer=None, \n activity_regularizer=None, kernel_constraint=None, \n bias_constraint=None))\n\n if self.batch_norm:\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \n center=True, scale=True, \n beta_initializer='zeros', gamma_initializer='ones',\n moving_mean_initializer='zeros', \n moving_variance_initializer='ones',\n beta_regularizer=None, gamma_regularizer=None,\n beta_constraint=None, gamma_constraint=None))\n\n if self.spatial_drop:\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\n\n if self.pool_method=='mean':\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n if self.pool_method=='max':\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n\n model.add(Conv2D(self.conv_3_mapnum, \n (self.filter_width, self.filter_width),\n strides=self.strides_len,\n padding='same', data_format='channels_last',\n dilation_rate=1, activation=self.acti_3_func, use_bias=True, \n kernel_initializer='glorot_uniform', bias_initializer='zeros', \n kernel_regularizer=l2(0.001), bias_regularizer=None, \n activity_regularizer=None, kernel_constraint=None, \n bias_constraint=None))\n\n if self.batch_norm:\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \n center=True, scale=True, \n beta_initializer='zeros', gamma_initializer='ones',\n moving_mean_initializer='zeros', \n moving_variance_initializer='ones',\n beta_regularizer=None, gamma_regularizer=None,\n beta_constraint=None, gamma_constraint=None))\n\n if self.spatial_drop:\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\n\n if self.pool_method=='mean':\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n if self.pool_method=='max':\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \n data_format='channels_last'))\n \n model.add(Flatten())\n \n if self.additional_dense:\n model.add(Dense(units=self.additional_dense_units, activation=self.additional_dense_activation))\n\n if self.batch_norm:\n model.add(BatchNormalization(axis=1, momentum=0.99, epsilon=0.001, \n center=True, scale=True, \n beta_initializer='zeros', gamma_initializer='ones',\n moving_mean_initializer='zeros', \n moving_variance_initializer='ones',\n beta_regularizer=None, gamma_regularizer=None,\n beta_constraint=None, gamma_constraint=None))\n if self.spatial_drop:\n model.add(Dropout(rate=self.spatial_drop_perc))\n \n model.add(Dense(units=self.denseshape, activation=self.output_activation))\n\n model.compile(optimizer=Adam(lr=self.learning_rate), loss=self.loss_func, metrics=['accuracy', 'mean_squared_error', 'mean_absolute_error'])\n print(model.summary())\n return model","def mgcNetArchCommonCnn(outLayer, l2_val, **kwargs):\n def_vals = {\"input_img_rows\" : 72,\n \"input_img_cols\" : 72,\n \"channels\" : 1,\n \"nb_classes\" : 13\n } # default parameters value\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n input_img_rows = kwargs['input_img_rows']\n input_img_cols = kwargs['input_img_cols']\n channels = kwargs['channels']\n nb_classes = kwargs['nb_classes']\n\n \n # Input: 72 x 72 x 1\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\n\n # Layer 1\n #------------------------\n conv1 = layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(img_shape)\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\n\n # Layer 2\n #------------------------\n conv2 = layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu')(conv1)\n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\n\n # FC Layer\n #------------------------\n out = layers.Flatten()(conv2)\n out = layers.Dropout(0.5)(out)\n out = layers.Dense(nb_classes, activation='softmax')(out)\n \n # prediction model\n model = Model(img_shape, out, name = 'common_cnn')\n\n return model","def get_model(summary=False):\n\timage_input=Input(shape=(220,220,5),name='image_input')\n\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\n\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\t\n\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\n\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\n\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\t\n\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\n\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\n\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\t\n\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\n\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\n\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\t\n\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\n\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\n\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\t\n\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\n\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\n\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\t\n\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\n\tbranch1_flat=Flatten()(branch6_pool1)\n\tdrop=Dropout(.3)(branch1_flat)\n\t# FC layers group\n\tdense1=Dense(512, activation='relu', name='fc1')(drop)\n\tdrop1=Dropout(.3)(dense1)\n\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\n\tdrop3=Dropout(.3)(dense2)\n\tout=Dense(2, activation='softmax', name='fc4')(drop3)\n\tmodel=Model(inputs=image_input,outputs=out)\n\treturn model","def build_model(self):\n self.G = Generator(self.g_conv_dim)\n self.D = Discriminator(self.d_conv_dim, self.c_dim)\n self.generator = Generator(self.g_conv_dim).train(False)\n\n self.G = nn.DataParallel(self.G)\n self.D = nn.DataParallel(self.D)\n\n # For Adam (Unofficial)\n # self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr, [self.beta1, self.beta2])\n # self.d_optimizer = torch.optim.Adam(self.D.parameters(), self.d_lr, [self.beta1, self.beta2])\n\n # For RMSprop(Official)\n self.g_optimizer = torch.optim.RMSprop(self.G.parameters(), lr=0.0001)\n self.d_optimizer = torch.optim.RMSprop(self.D.parameters(), lr=0.0001)\n\n self.accumulate(self.generator, self.G.module, 0)\n # self.print_network(self.G, 'G')\n # self.print_network(self.D, 'D')\n \n self.G.to(self.device)\n self.D.to(self.device)\n self.generator.to(self.device)\n\n # weight init\n self.G.apply(self.weights_init)\n self.D.apply(self.weights_init)\n self.generator.apply(self.weights_init)","def build_mlp(input_, config):\n current_input = input_\n print(current_input)\n for i in range(len(config['fcc_layers']) - 1):\n current_input = tf.keras.layers.Dense(\n units=config['fcc_layers'][i], activation='tanh',\n name='fcc_layer_{}'.format(i + 1))(current_input)\n current_input = tf.keras.layers.Dropout(\n rate=config['dropout'], name='dropout_{}'.format(i + 1))(current_input)\n cascade_embedding_layer = tf.keras.layers.Dense(\n units=config['fcc_layers'][-1], activation='tanh',\n name='cascade_embedding_layer')(current_input)\n cascade_embedding_layer_do = tf.keras.layers.Dropout(\n rate=config['dropout'],\n name='cascade_embedding_dropout')(cascade_embedding_layer)\n prediction_layer = tf.keras.layers.Dense(\n units=1, activation='sigmoid',\n name='prediction_layer')(cascade_embedding_layer_do)\n return cascade_embedding_layer, prediction_layer","def build(self, input_shape):\n self.embedding = layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN)\n self.conv_1 = layers.Conv1D(16, kernel_size=5, name=\"conv_1\", activation=\"relu\")\n self.pool_1 = layers.MaxPool1D(name=\"pool_1\")\n self.conv_2 = layers.Conv1D(\n 128, kernel_size=2, name=\"conv_2\", activation=\"relu\"\n )\n self.pool_2 = layers.MaxPool1D(name=\"pool_2\")\n self.flatten = layers.Flatten()\n self.dense = layers.Dense(1, activation=\"sigmoid\")\n super(CnnModel, self).build(input_shape)","def compile_model(network, nb_classes, input_shape):\r\n nb_layers = network['nb_layers']\r\n layer = network['layer']\r\n nb_neurons = network['nb_neurons']\r\n activation = network['activation']\r\n optimizer = network['optimizer']\r\n\r\n model = Sequential()\r\n\r\n for i in range(nb_layers):\r\n if i == 0:\r\n model.add(Conv2D(nb_neurons, activation=activation, input_shape=input_shape))\r\n else:\r\n model.add(layer(nb_neurons, activation=activation))\r\n \r\n model.add(Dropout(0.2))\r\n\r\n model.add(Dense(nb_classes, activation='softmax'))\r\n\r\n model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\r\n\r\n return model","def CNN_model():\n prob = 0.1\n model = Sequential()\n # model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same',\n # activation ='relu', input_shape = (28,28,1)))\n # model.add(Conv2D(filters = 64, kernel_size = (5,5),padding = 'Same',\n # activation ='relu'))\n # model.add(BatchNormalization())\n # model.add(MaxPooling2D(pool_size=(2,2)))\n # model.add(Dropout(0.25))\n\n # model.add(Flatten())\n model.add(Dense(512, activation = \"relu\"))\n model.add(Dropout(prob))\n\n model.add(Dense(1024, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(2048, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(2048, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(4096, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(2048, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(2048, activation = \"relu\"))\n model.add(Dropout(prob))\n model.add(Dense(1024, activation = \"relu\"))\n model.add(Dropout(prob))\n\n # model.add(Dense(2048, activation = \"relu\"))\n # model.add(Dropout(prob))\n #\n # model.add(Dense(2048, activation = \"relu\"))\n # model.add(Dropout(prob))\n\n model.add(Dense(1024, activation = \"relu\"))\n model.add(Dropout(prob))\n\n # model.add(BatchNormalization())\n model.add(Dense(512, activation = \"relu\"))\n model.add(Dropout(prob))\n # model.add(BatchNormalization())\n # model.add(Dropout(0.5))\n model.add(Dense(2, activation = \"softmax\"))\n\n return model","def _build(self, input_var, name=None):\n out = input_var\n for model in self._models:\n self._last_network = model.build(out, name=name)\n if self._first_network is None:\n self._first_network = self._last_network\n out = self._last_network.outputs\n\n return out","def build_model(num_classes=43):\n model = models.Sequential()\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.MaxPooling2D((2, 2)))\n\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\n input_shape=(32, 32, 3)))\n model.add(layers.MaxPooling2D((2, 2)))\n \n\n model.add(layers.Flatten())\n model.add(layers.Dense(num_classes, activation='softmax'))\n model.summary()\n\n return model","def _reshape_output_batch(self, number, output):\n #tt = cutotime('reshape')\n #tt.start()\n output = output.reshape(self.output_shapes[number]) # batch, h, w, 3, (5 + 80)\n #tt.stop()\n return output","def make_layer(self, out_channels, num_blocks, first_block=False):\n layers = []\n for i in range(num_blocks):\n first_block = first_block if i == 0 else False\n combine_mode = 'concat' if i == 0 else 'add'\n layers.append(ShuffleUnit(self.in_channels, out_channels, groups=self.groups, first_block=first_block, combine=combine_mode, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, act_cfg=self.act_cfg, with_cp=self.with_cp))\n self.in_channels = out_channels\n return nn.Sequential(*layers)","def _init_predictor(self):\n self.conv_cls_prev = self._init_branch(\n conv_channels=self.cls_branch,\n conv_strides=(1, ) * len(self.cls_branch))\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\n 1)\n # init regression head\n self.conv_reg_prevs = nn.ModuleList()\n # init output head\n self.conv_regs = nn.ModuleList()\n # group_reg_dims:\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\n for i in range(len(self.group_reg_dims)):\n reg_dims = self.group_reg_dims[i]\n reg_branch_channels = self.reg_branch[i]\n out_channel = self.out_channels[i]\n reg_list = nn.ModuleList()\n if len(reg_branch_channels) > 0:\n self.conv_reg_prevs.append(\n self._init_branch(\n conv_channels=reg_branch_channels,\n conv_strides=(1, ) * len(reg_branch_channels)))\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\n self.conv_regs.append(reg_list)\n else:\n self.conv_reg_prevs.append(None)\n for reg_dim in reg_dims:\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\n self.conv_regs.append(reg_list)","def addExportLayerToCoreml(builder):\n outputNames = [output.name for output in builder.spec.description.output]\n\n for i, outputName in enumerate(outputNames):\n # formulas: https://github.com/ultralytics/yolov5/issues/471\n builder.add_activation(\n name=f\"sigmoid_{outputName}\",\n non_linearity=\"SIGMOID\",\n input_name=outputName,\n output_name=f\"{outputName}_sigmoid\",\n )\n\n ### Coordinates calculation ###\n # input (1, 3, nC, nC, 85), output (1, 3, nC, nC, 2) -> nC = 640 / strides[i]\n builder.add_slice(\n name=f\"slice_coordinates_xy_{outputName}\",\n input_name=f\"{outputName}_sigmoid\",\n output_name=f\"{outputName}_sliced_coordinates_xy\",\n axis=\"width\",\n start_index=0,\n end_index=2,\n )\n # x,y * 2\n builder.add_elementwise(\n name=f\"multiply_xy_by_two_{outputName}\",\n input_names=[f\"{outputName}_sliced_coordinates_xy\"],\n output_name=f\"{outputName}_multiplied_xy_by_two\",\n mode=\"MULTIPLY\",\n alpha=2,\n )\n # x,y * 2 - 0.5\n builder.add_elementwise(\n name=f\"subtract_0_5_from_xy_{outputName}\",\n input_names=[f\"{outputName}_multiplied_xy_by_two\"],\n output_name=f\"{outputName}_subtracted_0_5_from_xy\",\n mode=\"ADD\",\n alpha=-0.5,\n )\n grid = make_grid(featureMapDimensions[i], featureMapDimensions[i]).numpy()\n # x,y * 2 - 0.5 + grid[i]\n builder.add_bias(\n name=f\"add_grid_from_xy_{outputName}\",\n input_name=f\"{outputName}_subtracted_0_5_from_xy\",\n output_name=f\"{outputName}_added_grid_xy\",\n b=grid,\n shape_bias=grid.shape,\n )\n # (x,y * 2 - 0.5 + grid[i]) * stride[i]\n builder.add_elementwise(\n name=f\"multiply_xy_by_stride_{outputName}\",\n input_names=[f\"{outputName}_added_grid_xy\"],\n output_name=f\"{outputName}_calculated_xy\",\n mode=\"MULTIPLY\",\n alpha=strides[i],\n )\n\n # input (1, 3, nC, nC, 85), output (1, 3, nC, nC, 2)\n builder.add_slice(\n name=f\"slice_coordinates_wh_{outputName}\",\n input_name=f\"{outputName}_sigmoid\",\n output_name=f\"{outputName}_sliced_coordinates_wh\",\n axis=\"width\",\n start_index=2,\n end_index=4,\n )\n # w,h * 2\n builder.add_elementwise(\n name=f\"multiply_wh_by_two_{outputName}\",\n input_names=[f\"{outputName}_sliced_coordinates_wh\"],\n output_name=f\"{outputName}_multiplied_wh_by_two\",\n mode=\"MULTIPLY\",\n alpha=2,\n )\n # (w,h * 2) ** 2\n builder.add_unary(\n name=f\"power_wh_{outputName}\",\n input_name=f\"{outputName}_multiplied_wh_by_two\",\n output_name=f\"{outputName}_power_wh\",\n mode=\"power\",\n alpha=2,\n )\n # (w,h * 2) ** 2 * anchor_grid[i]\n anchor = (\n anchorGrid[i]\n .expand(-1, featureMapDimensions[i], featureMapDimensions[i], -1)\n .numpy()\n )\n builder.add_load_constant_nd(\n name=f\"anchors_{outputName}\",\n output_name=f\"{outputName}_anchors\",\n constant_value=anchor,\n shape=anchor.shape,\n )\n builder.add_elementwise(\n name=f\"multiply_wh_with_achors_{outputName}\",\n input_names=[f\"{outputName}_power_wh\", f\"{outputName}_anchors\"],\n output_name=f\"{outputName}_calculated_wh\",\n mode=\"MULTIPLY\",\n )\n\n builder.add_concat_nd(\n name=f\"concat_coordinates_{outputName}\",\n input_names=[f\"{outputName}_calculated_xy\", f\"{outputName}_calculated_wh\"],\n output_name=f\"{outputName}_raw_coordinates\",\n axis=-1,\n )\n builder.add_scale(\n name=f\"normalize_coordinates_{outputName}\",\n input_name=f\"{outputName}_raw_coordinates\",\n output_name=f\"{outputName}_raw_normalized_coordinates\",\n W=torch.tensor([1 / 640]).numpy(),\n b=0,\n has_bias=False,\n )\n\n ### Confidence calculation ###\n builder.add_slice(\n name=f\"slice_object_confidence_{outputName}\",\n input_name=f\"{outputName}_sigmoid\",\n output_name=f\"{outputName}_object_confidence\",\n axis=\"width\",\n start_index=4,\n end_index=5,\n )\n builder.add_slice(\n name=f\"slice_label_confidence_{outputName}\",\n input_name=f\"{outputName}_sigmoid\",\n output_name=f\"{outputName}_label_confidence\",\n axis=\"width\",\n start_index=5,\n end_index=0,\n )\n # confidence = object_confidence * label_confidence\n builder.add_multiply_broadcastable(\n name=f\"multiply_object_label_confidence_{outputName}\",\n input_names=[\n f\"{outputName}_label_confidence\",\n f\"{outputName}_object_confidence\",\n ],\n output_name=f\"{outputName}_raw_confidence\",\n )\n\n # input: (1, 3, nC, nC, 85), output: (3 * nc^2, 85)\n builder.add_flatten_to_2d(\n name=f\"flatten_confidence_{outputName}\",\n input_name=f\"{outputName}_raw_confidence\",\n output_name=f\"{outputName}_flatten_raw_confidence\",\n axis=-1,\n )\n builder.add_flatten_to_2d(\n name=f\"flatten_coordinates_{outputName}\",\n input_name=f\"{outputName}_raw_normalized_coordinates\",\n output_name=f\"{outputName}_flatten_raw_coordinates\",\n axis=-1,\n )\n\n builder.add_concat_nd(\n name=\"concat_confidence\",\n input_names=[\n f\"{outputName}_flatten_raw_confidence\" for outputName in outputNames\n ],\n output_name=\"raw_confidence\",\n axis=-2,\n )\n builder.add_concat_nd(\n name=\"concat_coordinates\",\n input_names=[\n f\"{outputName}_flatten_raw_coordinates\" for outputName in outputNames\n ],\n output_name=\"raw_coordinates\",\n axis=-2,\n )\n\n builder.set_output(\n output_names=[\"raw_confidence\", \"raw_coordinates\"],\n output_dims=[(25200, numberOfClassLabels), (25200, 4)],\n )","def model(self, input_shape=(3, 224, 224), nclasses=3):\n inputs = Input(input_shape)\n\n pad1_1 = ZeroPadding2D(padding=(1, 1))(inputs)\n conv1_1 = Conv2D(64, 3, 3, activation='relu', name='conv1_1')(pad1_1)\n pad1_2 = ZeroPadding2D(padding=(1, 1))(conv1_1)\n conv1_2 = Conv2D(64, 3, 3, activation='relu', name='conv1_2')(pad1_2)\n pool1 = MaxPooling2D((2, 2), strides=(2, 2))(conv1_2)\n\n pad2_1 = ZeroPadding2D((1, 1))(pool1)\n conv2_1 = Conv2D(128, 3, 3, activation='relu', name='conv2_1')(pad2_1)\n pad2_2 = ZeroPadding2D((1, 1))(conv2_1)\n conv2_2 = Conv2D(128, 3, 3, activation='relu', name='conv2_2')(pad2_2)\n pool2 = MaxPooling2D((2, 2), strides=(2, 2))(conv2_2)\n\n pad3_1 = ZeroPadding2D((1, 1))(pool2)\n conv3_1 = Conv2D(256, 3, 3, activation='relu', name='conv3_1')(pad3_1)\n pad3_2 = ZeroPadding2D((1, 1))(conv3_1)\n conv3_2 = Conv2D(256, 3, 3, activation='relu', name='conv3_2')(pad3_2)\n pad3_3 = ZeroPadding2D((1, 1))(conv3_2)\n conv3_3 = Conv2D(256, 3, 3, activation='relu', name='conv3_3')(pad3_3)\n pool3 = MaxPooling2D((2, 2), strides=(2, 2))(conv3_3)\n\n pad4_1 = ZeroPadding2D((1, 1))(pool3)\n conv4_1 = Conv2D(512, 3, 3, activation='relu', name='conv4_1')(pad4_1)\n pad4_2 = ZeroPadding2D((1, 1))(conv4_1)\n conv4_2 = Conv2D(512, 3, 3, activation='relu', name='conv4_2')(pad4_2)\n pad4_3 = ZeroPadding2D((1, 1))(conv4_2)\n conv4_3 = Conv2D(512, 3, 3, activation='relu', name='conv4_3')(pad4_3)\n pool4 = MaxPooling2D((2, 2), strides=(2, 2))(conv4_3)\n\n pad5_1 = ZeroPadding2D((1, 1))(pool4)\n conv5_1 = Conv2D(512, 3, 3, activation='relu', name='conv5_1')(pad5_1)\n pad5_2 = ZeroPadding2D((1, 1))(conv5_1)\n conv5_2 = Conv2D(512, 3, 3, activation='relu', name='conv5_2')(pad5_2)\n pad5_3 = ZeroPadding2D((1, 1))(conv5_2)\n conv5_3 = Conv2D(512, 3, 3, activation='relu', name='conv5_3')(pad5_3)\n pool5 = MaxPooling2D((2, 2), strides=(2, 2))(conv5_3)\n\n # fc5 = base_model.layers[-8].output\n fc6 = Flatten()(pool5)\n fc7_1 = Dense(256, activation='relu', name='fc7_1')(fc6)\n dropout7_1 = Dropout(0.3, name='dropout7_1')(fc7_1)\n fc7_2 = Dense(128, activation='relu', name='fc7_2')(dropout7_1)\n # dropout7_2 = Dropout(0.2, name='dropout7_2')(fc7_2)\n # fc7_3 = Dense(128, activation=\"relu\", name=\"fc7_pre3\")(dropout7_2)\n prediction = Dense(nclasses, activation='softmax')(fc7_2)\n model = Model(inputs, prediction)\n model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n # model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n return model","def genModel():\n inp = (160, 320, 3) # initial image size\n oup1 = (160, 320, 1) # gray image size\n oup2 = (80, 320, 1) # cropped image size\n\n model = Sequential()\n model.add(Lambda(color2gray, input_shape = inp, output_shape= oup1))\n # crop top 50 pixels, bottom 30 pixels, left/right 0 pixels\n model.add(Cropping2D(cropping=((50,30), (0,0))))\n # Preprocess incoming data, centered around zero with small standard deviation \n model.add(Lambda(lambda x: x/127.5 - 1., output_shape= oup2))\n model.add(Convolution2D(24,5,5,subsample=(1,2), activation=\"relu\"))\n model.add(Convolution2D(36,5,5,subsample=(2,2), activation=\"relu\"))\n model.add(Convolution2D(48,5,5,subsample=(2,2), activation=\"relu\"))\n model.add(Convolution2D(64,3,3, activation=\"relu\"))\n model.add(Convolution2D(64,3,3, activation=\"relu\"))\n model.add(Flatten())\n model.add(Dropout(0.3))\n model.add(Dense(180, activation=\"relu\"))\n model.add(Dense(60))\n model.add(Dense(10, activation=\"relu\"))\n model.add(Dense(1))\n # print layer size for each model layers\n for layer in model.layers:\n print(layer.get_output_at(0).get_shape().as_list())\n return model","def __init__(self, ):\n super().__init__()\n channels = 3\n\n # Initial convolution block\n out_features = 64\n # encoder\n self.input = nn.Sequential(\n nn.ReflectionPad2d(channels),\n nn.Conv2d(3, out_features, (7, 7)),\n nn.InstanceNorm2d(out_features),\n nn.MaxPool2d(2),\n nn.LeakyReLU(0.2, inplace=True),\n nn.Conv2d(out_features, out_features * 2, (3, 3), stride=(1, 1), padding=(1, 1)),\n nn.LeakyReLU(0.2, inplace=True),\n nn.MaxPool2d(2),\n nn.Conv2d(out_features * 2, out_features * 4, (3, 3), stride=(1, 1), padding=(1, 1)),\n nn.LeakyReLU(0.2, inplace=True),\n )\n\n self.in0 = nn.InstanceNorm2d(256)\n self.block0 = blocks()\n self.block1 = blocks()\n self.block2 = blocks()\n self.block3 = blocks()\n self.block4 = blocks()\n self.block5 = blocks()\n self.block6 = blocks()\n self.block7 = blocks()\n\n self.out = nn.Sequential(\n\n nn.Upsample(scale_factor=2),\n nn.Conv2d(out_features * 4, out_features * 2, 3, stride=1, padding=1),\n nn.InstanceNorm2d(out_features * 2),\n nn.LeakyReLU(0.2, inplace=True),\n\n nn.Upsample(scale_factor=2),\n nn.Conv2d(out_features * 2, out_features, 3, stride=1, padding=1),\n nn.InstanceNorm2d(out_features),\n nn.LeakyReLU(0.2, inplace=True),\n\n nn.ReflectionPad2d(channels),\n nn.Conv2d(out_features, channels, 7),\n nn.Tanh(),\n )","def define(self, optimizer = Adam(lr=1e-5)): \n \n self.optimizer = optimizer\n\n model = Sequential()\n\n #Layer 1\n model.add(Conv2D( filters = 96, \n kernel_size = (11,11), \n strides = 4, \n padding = 'same', \n activation = 'relu', \n input_shape = (224, 224, 3), \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) # overlapping pooling\n #Layer 2\n model.add(Conv2D( filters = 256, \n kernel_size = (5,5), \n strides = 1, \n padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None)) \n #Layer 3\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', kernel_initializer = 'he_normal'))\n #Layer 4\n model.add(Conv2D( filters = 384, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 5\n model.add(Conv2D( filters = 256, \n kernel_size = (3,3), \n strides = 1, padding = 'same', \n activation = 'relu', \n kernel_initializer = 'he_normal'))\n #Layer 6\n model.add(MaxPooling2D( pool_size = (3,3), \n strides = (2,2), \n padding= 'same', \n data_format = None))\n \n #Layer 7\n model.add(Flatten())\n \n #Layer 8\n model.add(Dense( units = 4096, activation = 'relu'))\n model.add(Dense( units = 1024, activation = 'relu'))\n model.add(Dense( units = 512, activation = 'relu'))\n model.add(Dense( units = 256, activation = 'relu'))\n model.add(Dense( units = 128, activation = 'relu'))\n \n #Layer end\n model.add(Dense( units = 3, activation = 'softmax'))\n model.summary()\n \n self.model = model","def _make_conv_layers(self):\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def _build(self, *args, **kwargs):\n num_targets = self.get('num_targets', self.config)\n dropout_rate = self.get('dropout_rate', self.config)\n input_shape = self.get('input_shape', self.config)\n\n inputs = Input(shape=input_shape)\n block_A = self.reduction_block_I(inputs, 32, scope='Block_A')\n block_B = self.reduction_block_I(block_A, 64, scope='Block_B')\n block_C = self.reduction_block_II(block_B, 128, scope='Block_C')\n block_D = self.reduction_block_II(block_C, 256, scope='Block_D')\n block_E = self.reduction_block_II(block_D, 256, scope='Block_E')\n\n z = self.dense_block(block_E, units=self.get('units', self.config),\n dropout=dropout_rate, scope='DenseBlock-I')\n\n output_tensor = Dense(num_targets, activation='sigmoid', name='output')(z)\n\n return [inputs], [output_tensor]","def forward(self, inputs):\n # inputs is (batch, slen)\n x = self.embed(inputs) # x is (batch, seq, dim_e)\n x = x.transpose(1, 2) # x is (batch, dim_e, slen)\n # because conv1d requires (batch, channels_in=dim_e, slen)\n # to produce an output (batch, channels_out, slen - k + 1)\n # we then pool1d (kernel=slen-k) over the output of conv1d\n # since 1d works along time (i.e. sequence) this means\n # we get (batch, channels_out=cshannels_outs_k, 1) which we squeeze\n conv_blocks_out = [self.conv_blocks[n](x).squeeze(-1)\n for n in range(self.nk)]\n # and finally we concatenate all our conv1ds with different kernel\n # sizes together to get (batch, sum_k(channels_outs_k))\n # i.e. we concat the channels_out (i.e. featutres)\n x = torch.cat(conv_blocks_out, dim=1)\n\n # and do some dropout\n x = self.dropout(x)\n\n # squeeze into hidden\n if self.hidden_size > 0:\n x = self.fc(x)\n x = self.dropout2(x)\n x = self.fc_act(x)\n\n # map to classes and return\n x = self.output(x)\n return x","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 forward(self, inputs):\n x, meta = inputs\n features = self.arch(x)\n if self.n_meta_features:\n meta_features = self.meta(meta)\n features = torch.cat((cnn_features, meta_features), dim=1)\n return self.ouput(features)","def __init__(\n self,\n num_frames = 2,\n dim = 64,\n channels = 3,\n stages = 4,\n num_blocks = 2,\n dim_head = 64,\n window_size = 16,\n heads = 8,\n ff_mult = 4,\n input_channels = None,\n output_channels = None,\n device = None,\n skip_type = 'ConcatCross'\n ):\n super().__init__()\n input_channels = channels if input_channels is None else input_channels\n output_channels = channels if output_channels is None else output_channels\n\n self.project_in = nn.Sequential(\n nn.Conv3d(input_channels, dim, kernel_size = (1, 3, 3), padding = (0, 1, 1)),\n nn.GELU()\n )\n\n self.project_out = nn.Sequential(\n nn.Conv3d(dim, output_channels, kernel_size = (1, 3, 3), padding = (0, 1, 1))\n )\n\n self.downs = nn.ModuleList([])\n self.ups = nn.ModuleList([])\n\n # render each hyperparam a tuple so that we can iterate thru them\n heads, window_size, dim_head, num_blocks = map(partial(cast_tuple, depth = stages), (heads, window_size, dim_head, num_blocks))\n\n for ind, heads, window_size, dim_head, num_blocks in zip(range(stages), heads, window_size, dim_head, num_blocks):\n is_last = ind == (stages - 1)\n\n self.downs.append(nn.ModuleList([ # need 3d version of this\n Block(dim, depth = num_blocks, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size, device = device),\n nn.Conv3d(dim, dim * 2, kernel_size = (1, 4, 4), stride = (1, 2, 2), padding = (0, 1, 1))\n ]))\n\n self.ups.append(nn.ModuleList([\n nn.ConvTranspose3d(dim * 2, dim, (1, 2, 2), stride = (1, 2, 2)),\n Block(dim, depth = num_blocks, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size, device = device, skip_type = skip_type)\n ]))\n\n dim *= 2\n if is_last:\n self.mid = nn.Sequential(\n Rearrange('b c f h w -> b (c f) 1 h w'),\n Block(dim = dim*num_frames, depth = 1, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size),\n nn.Conv3d(dim*num_frames, dim, kernel_size = (1, 3, 3), padding = (0, 1, 1)),\n Block(dim = dim, depth = 2, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size),\n )","def build_model(self):\n\n input_placeholder = Input(shape = self.input_shape)\n x = ZeroPadding2D((3, 3))(input_placeholder)\n\n # Stage 1\n x = self.main_path_block(x, 64, (7, 7), 'valid', 'conv1', 'bn_conv1', 'relu', (2, 2))\n x = MaxPooling2D((3, 3), strides = (2, 2))(x)\n\n # Stage 2\n x = self.convolutional_block(x, 3, [64, 64, 256], 2, 'a', 1)\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'b')\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'c')\n\n # Stage 3\n x = self.convolutional_block(x, 3, [128, 128, 512], 3, 'a', 2)\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'b')\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'c')\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'd')\n\n # Stage 4\n x = self.convolutional_block(x, 3, [256, 256, 1024], 4, 'a', 2)\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'b')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'c')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'd')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'e')\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'f')\n\n # Stage 5\n x = self.convolutional_block(x, 3, [512, 512, 2048], 5, 'a', 2)\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'b')\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'c')\n \n # Average Pooling Layer\n x = AveragePooling2D((2, 2), name = 'avg_pool')(x)\n \n # Fully Connected Layer\n x = Flatten()(x)\n x = Dense(\n self.classes,\n activation = 'softmax',\n name = 'fc_' + str(self.classes),\n kernel_initializer = glorot_uniform(seed = 0)\n )(x)\n\n self.model = Model(input_placeholder, x, name = 'Resnet50')","def __init__(self):\n self.model = Sequential()\n self.model.add(AveragePooling2D(pool_size=(4, 4), input_shape=(224, 224, 3)))\n self.model.add(Conv2D(16, (9, 9)))\n self.model.add(Activation('relu'))\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\n self.model.add(Conv2D(16, (5, 5)))\n self.model.add(Activation('relu'))\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\n self.model.add(Flatten())\n self.model.add(Dropout(0.5))\n self.model.add(Dense(1, activation='sigmoid'))\n self.model.compile(loss=binary_crossentropy,\n optimizer=keras.optimizers.Adadelta(),\n metrics=['accuracy'])","def sub_model_net(self):\r\n # define input\r\n x = keras.Input(shape=(960,), name='input')\r\n fc_2 = keras.layers.Dense(160, name='fc_2')(x)\r\n add_1 = keras.layers.Activation('relu')(fc_2)\r\n drop = keras.layers.Dropout(0.5)\r\n # output\r\n y_hat = keras.layers.Dense(1283, activation='softmax', name='output')(add_1)\r\n model = keras.Model(inputs=x, outputs=y_hat)\r\n\r\n return model","def build(self, hp):\n\n model = Sequential()\n model.add(Conv2D(filters=hp.Choice('num_filters_0', values=[8, 16, 32, 64]),\n kernel_size=hp.Choice('kernel_size_0', values=[3, 4, 5]),\n activation=hp.Choice('activation_0', values=['relu', 'tanh']),\n input_shape=self.input_shape))\n\n for i in range(hp.Int('num_layers', 1, 3)):\n model.add(Conv2D(filters=hp.Choice('num_filters_%d' % (i + 1), values=[8, 16, 32, 64]),\n kernel_size=hp.Choice('kernel_size_%d' % (i + 1), values=[3, 4, 5]),\n activation=hp.Choice('activation_%d' % (i + 1), values=['relu', 'tanh'])))\n model.add(Flatten())\n model.add(Dense(N_zern))\n model.summary()\n\n model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-3, 5e-4, 1e-4])),\n loss='mean_squared_error')\n return model","def output(self, input, in_features, out_features,reuse=False):\n # with tf.variable_scope(self.name):\n # print('f'*20,input.get_shape().as_list(),in_features,out_features)\n w=self._create_weight([self.cnn_size,self.cnn_size,in_features,out_features],name='Wfn')\n out=self._conv2d(input,w,[1, self.cnn_stride, self.cnn_stride, 1],pre_name='convfn')\n return out","def modelbuilder():\n model = Sequential()\n # Add a convolution layer with with a sigmoid activation function\n model.add(layers.Conv2D(1, (2, 2), strides=(1, 1), activation='sigmoid', padding='same', input_shape=(256, 256, 3)))\n model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n model.summary()\n return model","def sweep_image_model():\n for c1 in [4, 8, 16]:\n for c2 in [2, 4]:\n for c3 in [2, 4]:\n for c4 in [1, 2]:\n flags = flag_reader.read_flag()\n print(c1)\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\n print('channel list = ', flags.channel_list)\n flags.last_dim = flags.channel_list[-1]\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\n print(flags.model_name)\n training_from_flag(flags)","def __init__(self):\n # def __init__(self, embed_size, input_channels):\n super(EncoderCNN, self).__init__()\n self.off_model = OffsetCNN()\n self.sig_model = SignificanceCNN()\n self.sigmoid = nn.Sigmoid()\n self.W = nn.Conv3d(1, 1, (5, 1, 1))","def _build_output_layer(self,\n answer_modeling,\n answer_modeling_mask):\n answer_start_dropout = self.hyperparams.model_output_answer_start_dropout if self.mode == \"train\" else 0.0\n answer_start_trainable = self.hyperparams.model_output_answer_start_trainable\n answer_end_dropout = self.hyperparams.model_output_answer_end_dropout if self.mode == \"train\" else 0.0\n answer_end_trainable = self.hyperparams.model_output_answer_end_trainable\n \n with tf.variable_scope(\"output\", reuse=tf.AUTO_REUSE):\n self.logger.log_print(\"# build answer output layer\")\n answer_output_list = []\n answer_output_mask_list = []\n \n with tf.variable_scope(\"start\", reuse=tf.AUTO_REUSE):\n answer_start_list = [answer_modeling[0], answer_modeling[1]]\n answer_start_mask_list = [answer_modeling_mask[0], answer_modeling_mask[1]]\n (answer_start,\n answer_start_mask) = self._build_fusion_result(answer_start_list,\n answer_start_mask_list, None)\n \n answer_ouput_start_layer = create_dense_layer(\"single\", 1, 1, 1, None,\n [answer_start_dropout], None, False, False, False, self.num_gpus, self.default_gpu_id,\n self.regularizer, self.random_seed, answer_start_trainable)\n answer_output_start, answer_output_start_mask = answer_ouput_start_layer(answer_start, answer_start_mask)\n answer_output_list.append(answer_output_start)\n answer_output_mask_list.append(answer_output_start_mask)\n \n with tf.variable_scope(\"end\", reuse=tf.AUTO_REUSE):\n answer_end_list = [answer_modeling[0], answer_modeling[2]]\n answer_end_mask_list = [answer_modeling_mask[0], answer_modeling_mask[2]]\n (answer_end,\n answer_end_mask) = self._build_fusion_result(answer_end_list,\n answer_end_mask_list, None)\n \n answer_output_end_layer = create_dense_layer(\"single\", 1, 1, 1, None,\n [answer_end_dropout], None, False, False, False, self.num_gpus, self.default_gpu_id,\n self.regularizer, self.random_seed, answer_end_trainable)\n answer_output_end, answer_output_end_mask = answer_output_end_layer(answer_end, answer_end_mask)\n answer_output_list.append(answer_output_end)\n answer_output_mask_list.append(answer_output_end_mask)\n \n return answer_output_list, answer_output_mask_list","def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\"sigmoid\"):\n\n # inizializzo il modello come sequenziale\n model = Sequential()\n inputShape = (imageHeight, imageWidth, imageDepth)\n chanDim = -1\n\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\n # Utilizzo 32 filtri 3*3\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", input_shape=inputShape))\n # con attivazione Rectified Linear Unit\n model.add(Activation(\"relu\"))\n # applico una batch normalization\n model.add(BatchNormalization(axis=chanDim))\n # un MaxPooling 3*3\n model.add(MaxPooling2D(pool_size=(3, 3)))\n # ed un 25% di dropout per ridurre overfitting\n model.add(Dropout(0.25))\n\n # Secondo blocco\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Terzo blocco\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Passo ai Fully Connected Layers\n # Trasformo il modello in un vettore\n model.add(Flatten())\n model.add(Dense(1024))\n model.add(Activation(\"sigmoid\"))\n model.add(BatchNormalization())\n model.add(Dropout(0.5))\n\n # Infine utilizzo l'attivazione per la rete\n model.add(Dense(classesNumber))\n model.add(Activation(finalAct))\n\n return model","def input_output_network(self, X):\n layer_wise_output = [[] for i in range(len(self.layers) + 1)]\n # if X contains only one data\n if len(X.shape) == 1:\n X = X.reshape(1, -1)\n # for every data in X\n for x in X:\n for l in range(len(self.layers)):\n p_h = self.layers[l].input_output(x)\n layer_wise_output[l].append(p_h)\n x = (np.random.random_sample(self.layers[l].output_size) <\n p_h) * 1\n # last layer --> softmax\n layer_wise_output[-1].append(self.softmax(self.classif_RBM, x))\n\n # just reshape\n layer_wise_output = [[\n layer_wise_output[i][j].reshape(1, -1)\n for j in range(len(layer_wise_output[i]))\n ] for i in range(len(layer_wise_output))]\n # concat results for each layers for each sample\n layer_wise_output = [\n np.concatenate(layer_wise_output[i])\n for i in range(len(layer_wise_output))\n ]\n return layer_wise_output","def CNN_ClassModel(input_shape=(1, 72, 72),n_class=3,lr=0.001):\n model=Sequential()\n model.add(Convolution2D(filters=16,nb_row=5,nb_col=5, \n # kernel_size=5,strides=1,\n padding='same',data_format='channels_first',\n input_shape=input_shape))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same',data_format='channels_first'))\n model.add(Dropout(0.9))\n model.add(Flatten())\n model.add(Dense(200))\n model.add(Activation('relu'))\n\n model.add(Dense(n_class))\n model.add(Activation('softmax'))\n\n adam=Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-6, amsgrad=False)\n model.compile(optimizer=adam,\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n return model","def __init__(self, n_in_channels: int = 1, n_hidden_layers: int = 3, n_kernels: int = 32, kernel_size: int = 7):\n super(SimpleCNN, self).__init__()\n \n cnn = []\n for i in range(n_hidden_layers):\n cnn.append(torch.nn.Conv2d(in_channels=n_in_channels, out_channels=n_kernels, kernel_size=kernel_size,\n bias=True, padding=int(kernel_size/2)))\n cnn.append(torch.nn.ReLU())\n n_in_channels = n_kernels\n self.hidden_layers = torch.nn.Sequential(*cnn)\n self.output_layer = torch.nn.Conv2d(in_channels=n_in_channels, out_channels=1,\n kernel_size=kernel_size, bias=True, padding=int(kernel_size/2))","def build_cut_model(self):\n model = None\n if self.model_name == 'vgg16':\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'resnet':\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'densenet':\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'mobilenet':\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\n elif self.model_name == 'efficientnet':\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\n elif self.model_name == 'vit':\n model = VisionTransformer(image_size=self.ex_input_size,\n patch_size=vit_settings['patch_size'],\n num_layers=vit_settings['num_layers'],\n num_classes=num_classes,\n d_model=vit_settings['d_model'],\n num_heads=vit_settings['num_heads'],\n mlp_dim=vit_settings['mlp_dim'],\n channels=self.ex_channels,\n dropout=vit_settings['dropout']).build_VisionTransformer()\n model.load_weights(self.path_to_weights)\n model = Model(model.input, model.get_layer(self.ex_last_conv_layer_name2).output)\n model.summary()\n return model","def generator_model():\n\n Generator = Sequential(name='Generator')\n\n # Fully Connected layer --> 512 activation maps of 2x2 \n Generator.add(Dense(units=512 * 2 * 2, input_shape=GENERATOR_INPUT, kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\n Generator.add(Reshape((2, 2, 512)))\n Generator.add(BatchNormalization(momentum=MOMENTUM))\n Generator.add(ReLU())\n\n # Upsampling : 2x2x512 --> 4x4x256 \n Generator.add(Conv2DTranspose(filters=256, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\n Generator.add(BatchNormalization(momentum=MOMENTUM))\n Generator.add(ReLU())\n\n # Upsampling : 4x4x256 --> 8x8x128 \n Generator.add(Conv2DTranspose(filters=256, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\n Generator.add(BatchNormalization(momentum=MOMENTUM))\n Generator.add(ReLU())\n\n # Upsampling : 8x8x128 --> 16x16x64\n Generator.add(Conv2DTranspose(filters=128, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\n Generator.add(BatchNormalization(momentum=MOMENTUM))\n Generator.add(ReLU())\n\n # Upsampling : 16x16x63 --> 32x32x3 \n Generator.add(Conv2DTranspose(filters=3, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD), activation='tanh'))\n\n return Generator","def get_model_2(parameters):\n # Parameters\n BANDS = parameters['num_features']\n CLASSES = parameters['num_classes']\n \n # Sequential model\n model = keras.models.Sequential()\n \n # Add convolution (1)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(9, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh',\n input_shape=(9, BANDS,1)))\n \n # Add convolution (2)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Add convolution (3)\n # -------------------\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\n model.add(keras.layers.Conv2D(filters=32,\n kernel_size=(1, 16),\n padding='same',\n data_format=\"channels_last\",\n activation='tanh'))\n \n # Flatten before dense layer\n model.add(keras.layers.Flatten())\n \n # Add fully connected (4)\n # -----------------------\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='tanh'))\n \n # Add fully connected (5)\n # -----------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, 800)\n model.add(keras.layers.Dense(units=800,\n activation='softmax'))\n \n # Add fully connected to reduce to number of categories\n # -----------------------------------------------------\n # Intput_shape (batch, dim) = (-, 800)\n # Output_shape (batch, dim) = (-, CLASSES)\n model.add(keras.layers.Dense(units=CLASSES,\n activation='softmax'))\n \n # Compile model\n model.compile(optimizer='adam',\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n \n # Print the model summary to output file\n # To print to stdout: model.summary()\n with open(OUTPUT_FILE, 'a') as f:\n # Pass the file handle in as a lambda function to make it callable\n model.summary(print_fn=lambda x: f.write(x + '\\n'))\n \n # Return the model\n return model","def __init__(self, Nchannels, Nsamples, output_units):\n super(conv2DNet_1, self).__init__()\n # Layer 1\n l1_channels = 16 \n self.conv1 = nn.Conv2d(1, l1_channels, (Nchannels, 1), padding = 0)\n self.batchnorm1 = nn.BatchNorm2d(l1_channels, False) # final size bsize x 1 x l1_channels x Nsamples\n\n # Layer 2\n l2_channels = 4\n l2_temp_window = 32\n l2_l1channel_overlap = 2\n self.padding1 = nn.ZeroPad2d((l2_temp_window // 2, l2_temp_window // 2 - 1, l2_l1channel_overlap//2-1, l2_l1channel_overlap//2)) # left, right, top, bottom\n self.conv2 = nn.Conv2d(1, l2_channels, (l2_l1channel_overlap, l2_temp_window)) # does not change size if combined with above padding\n self.batchnorm2 = nn.BatchNorm2d(l2_channels, False)\n self.pooling2 = nn.MaxPool2d((2, 4)) # final size bsize x l2_channels x floor(l1_channels/2) x floor(Nsamples/4)\n\n # Layer 3\n l3_channels = 4\n l3_temp_window = 4\n l3_l2channel_overlap = 8\n self.padding2 = nn.ZeroPad2d((l3_temp_window//2, l3_temp_window//2-1, l3_l2channel_overlap//2, l3_l2channel_overlap//2-1))\n self.conv3 = nn.Conv2d(l2_channels, l3_channels, (l3_l2channel_overlap, l3_temp_window))\n self.batchnorm3 = nn.BatchNorm2d(l3_channels, False)\n self.pooling3 = nn.MaxPool2d((2, 4)) # final size bsize x l3_channels x floor(l1_channels/4) x floor(Nsamples/16)\n\n # FC Layer\n fc_inputs = l3_channels * (l1_channels//4) * (Nsamples//16)\n self.fc1 = nn.Linear(fc_inputs, output_units)","def __init__(self):\n super(Encoder, self).__init__()\n\n self.lconv1 = nn.Sequential(\n nn.Conv1d(4, 64, kernel_size=9, padding=4),\n nn.BatchNorm1d(64),\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\n nn.BatchNorm1d(64),\n )\n\n self.conv1 = nn.Sequential(\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\n nn.BatchNorm1d(64),\n nn.ReLU(inplace=True),\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\n nn.BatchNorm1d(64),\n nn.ReLU(inplace=True),\n )\n\n self.lconv2 = nn.Sequential(\n nn.MaxPool1d(kernel_size=4, stride=4),\n nn.Conv1d(64, 96, kernel_size=9, padding=4),\n nn.BatchNorm1d(96),\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\n nn.BatchNorm1d(96),\n )\n\n self.conv2 = nn.Sequential(\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\n nn.BatchNorm1d(96),\n nn.ReLU(inplace=True),\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\n nn.BatchNorm1d(96),\n nn.ReLU(inplace=True),\n )\n\n self.lconv3 = nn.Sequential(\n nn.MaxPool1d(kernel_size=4, stride=4),\n nn.Conv1d(96, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n )\n\n self.conv3 = nn.Sequential(\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n )\n\n self.lconv4 = nn.Sequential(\n nn.MaxPool1d(kernel_size=5, stride=5),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n )\n\n self.conv4 = nn.Sequential(\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n )\n\n self.lconv5 = nn.Sequential(\n nn.MaxPool1d(kernel_size=5, stride=5),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n )\n\n self.conv5 = nn.Sequential(\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n )\n\n self.lconv6 = nn.Sequential(\n nn.MaxPool1d(kernel_size=5, stride=5),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n )\n\n self.conv6 = nn.Sequential(\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n )\n\n self.lconv7 = nn.Sequential(\n nn.MaxPool1d(kernel_size=2, stride=2),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n )\n\n self.conv7 = nn.Sequential(\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\n nn.BatchNorm1d(128),\n nn.ReLU(inplace=True),\n )","def __generate_output_data(self):\n if not len(self.output_data) == 0:\n return\n try:\n self.output_data = s.load(open('output/output_data.p', 'rb'))\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\n if not self.classes_to_visualise == None:\n self.__filter_output_data(self.classes_to_visualise)\n except:\n self.output_data = generate_output_for_test_data(image_data=self.image_data,\n binary_output=self.binary_output) if self.testing else generate_output_for_train_data(\n image_data=self.image_data, binary_output=self.binary_output)\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\n if not self.classes_to_visualise == None:\n self.__filter_output_data(self.classes_to_visualise)\n s.dump([out.tolist() for out in self.output_data], open('output/output_data.p', 'wb'))\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\n\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))","def call(self, inputs):\n for index,layer in enumerate(self.list_cnn):\n if index == 0:\n out = layer(inputs)\n else:\n if self.residual:\n prev_out = out\n cur_out = layer(out)\n if self.use_batchnorm:\n cur_out = layers.BatchNormalization()(cur_out)\n if self.use_dropout:\n cur_out = layers.Dropout(0.2)(cur_out)\n out = prev_out + cur_out\n else:\n out = layer(out)\n out = self.output_layer(out)\n if self.use_pool:\n out = self.pool(out)\n out = self.flatten(out)\n out = self.classify(out)\n return out","def __init__(self, in_channels, out_channels):\n super(CNN, self).__init__()\n self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=5, padding=1)","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 __call__(self, inputs, output_stages='c5', **kwargs):\n if backend.image_data_format() == 'channels_last':\n bn_axis = 3\n else:\n bn_axis = 1\n\n dilation = self.dilation\n\n x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(inputs)\n x = layers.Conv2D(64, (7, 7),\n strides=(2, 2),\n padding='valid',\n kernel_initializer='he_normal',\n name='conv1')(x)\n x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)\n x = layers.Activation('relu')(x)\n x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)\n x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)\n c1 = x\n\n x = self._conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))\n for i in range(self.params[0]):\n x = self._identity_block(x, 3, [64, 64, 256], stage=2, block=chr(ord('b') + i))\n c2 = x\n\n x = self._conv_block(x, 3, [128, 128, 512], stage=3, block='a')\n for i in range(self.params[1]):\n x = self._identity_block(x, 3, [128, 128, 512], stage=3, block=chr(ord('b') + i))\n c3 = x\n\n x = self._conv_block(x, 3, [256, 256, 1024], stage=4, block='a', dilation=dilation[0])\n for i in range(self.params[2]):\n x = self._identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(ord('b') + i), dilation=dilation[0])\n c4 = x\n\n x = self._conv_block(x, 3, [512, 512, 2048], stage=5, block='a', dilation=dilation[1])\n for i in range(self.params[3]):\n x = self._identity_block(x, 3, [512, 512, 2048], stage=5, block=chr(ord('b') + i), dilation=dilation[1])\n c5 = x\n\n self.outputs = {'c1': c1,\n 'c2': c2,\n 'c3': c3,\n 'c4': c4,\n 'c5': c5}\n\n if type(output_stages) is not list:\n return self.outputs[output_stages]\n else:\n return [self.outputs[ci] for ci in output_stages]","def build_multi_blocks_models(feature_dim, feat_group_start_end_dict, output_scheme=\"regression\", num_classes=num_classes):\n\tdivan_feat_dim = feature_dim\n\tfor k in feat_group_start_end_dict:\n\t\tdivan_feat_dim = divan_feat_dim - feat_group_start_end_dict[k][2]\n\tinput_atac = keras.layers.Input(shape=[feat_group_start_end_dict['atac'][2]], name=\"atac_input\")\n\tinput_rnaseq = keras.layers.Input(shape=[feat_group_start_end_dict['rnaseq'][2]], name=\"rnaseq_input\")\n\tinput_wgbs = keras.layers.Input(shape=[feat_group_start_end_dict['wgbs'][2]], name=\"wgbs_input\")\n\tinput_divan = keras.layers.Input(shape=[divan_feat_dim], name=\"divan_input\")\n\n\thidden_atac = keras.layers.Dense(30, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_atac)\n\thidden_rnaseq = keras.layers.Dense(100, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_rnaseq)\n\thidden_wgbs = keras.layers.Dense(60, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_wgbs)\n\thidden_divan_1 = keras.layers.Dense(800, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(input_divan)\n\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden_divan_1)\n\thidden_divan_2 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\tconcat = keras.layers.concatenate([hidden_atac, hidden_rnaseq, hidden_wgbs, hidden_divan_2])\n\thidden3 = keras.layers.Dense(200, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(dropout1)\n\t# trait-specific network\n\thidden_trait_1 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_2 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_3 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_4 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\thidden_trait_5 = keras.layers.Dense(50, activation='relu', \n\t\tkernel_regularizer=keras.regularizers.l2(0.01), \n\t\tkernel_initializer=\"he_uniform\")(concat)\n\t#bn3 = keras.layers.BatchNormalization()(hidden3)\n\tif (output_scheme==\"regression\"):\n\t\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\n\t\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden_trait_1)\n\t\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden_trait_2)\n\t\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden_trait_3)\n\t\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden_trait_4)\n\t\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden_trait_5)\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tout1 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out1\")(hidden_trait_1)\n\t\tout2 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out2\")(hidden_trait_2)\n\t\tout3 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out3\")(hidden_trait_3)\n\t\tout4 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out4\")(hidden_trait_4)\n\t\tout5 = keras.layers.Dense(num_classes, activation=\"sigmoid\", \n\t\t\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\"he_uniform\", \n\t\t\tname=\"out5\")(hidden_trait_5)\n\tmodel = keras.models.Model(inputs=[input_atac, input_rnaseq, input_wgbs, input_divan],\n\t\t\t\t\t\t\t outputs=[out1, out2, out3, out4, out5])\n\tif (output_scheme == \"regression\"):\n\t\tmodel.compile(loss=\"mse\", \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.0001),\n\t\t\t\t\t metrics=['mae', custom_r2_metric])\n\telif (output_scheme == \"ordinal_clf\"):\n\t\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \n\t\t\t\t\t optimizer=tf.keras.optimizers.Adam(0.001))\n\tprint(model.summary())\n\treturn model","def __init__(self, nfeat, nhid, nclass, dropout, alpha):\n super(GCN, self).__init__()\n self.dropout = dropout\n\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\n \n self.add_module('conv1', self.conv1)\n\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)","def build_bisenet(inputs, num_classes):\n\n ### The spatial path\n ### The number of feature maps for each convolution is not specified in the paper\n ### It was chosen here to be equal to the number of feature maps of a classification\n ### model at each corresponding stage\n # spatial_net = fluid.layers.resize_bilinear(inputs, [Image_Height/8, Image_Width/8])\n # print('spatial_net_1',spatial_net)\n\n ## spatial path\n spatial_net = ConvBlock(inputs, num_filters=64, kernel_size=3, stride=2)\n spatial_net = ConvBlock(spatial_net, num_filters=128, kernel_size=3, stride=2)\n spatial_net = ConvBlock(spatial_net, num_filters=256, kernel_size=3, stride=2)\n # print(\"spatial_net:\", spatial_net)\n\n # spatial_net = fluid.layers.resize_bilinear(spatial_net, [Image_Height/8, Image_Width/8])\n # print('spatial_net_2',spatial_net)\n ### Context path\n model = ResNet(is_test=False)\n # spatial_net = model.bottleneck_block1(inputs)\n end_points_16, end_points_32 = model.net(inputs)\n net_4 = AttentionRefinementModule(end_points_16, num_filters=512)\n net_5 = AttentionRefinementModule(end_points_32, num_filters=1024)\n global_channels = fluid.layers.reduce_mean(net_5, [2, 3], keep_dim=True)\n net_5_scaled = fluid.layers.elementwise_mul(net_5, global_channels, axis=0)\n\n ### Combining the paths\n net_4 = Upsample(net_4, scale=2)\n net_5_scaled = Upsample(net_5_scaled, scale=4)\n # print('net_4, net_5:', [net_4, net_5_scaled])\n # layers_concat = list()\n # layers_concat.append(spatial_net)\n ## layers_concat.append(net_4)\n # layers_concat.append(net_5_scaled)\n context_net = fluid.layers.concat([spatial_net, net_4, net_5_scaled], axis=1) #\n # context_net = fluid.layers.concat(input=layers_concat,axis=1)\n # print('context_net', context_net)\n # context_net = fluid.layers.concat([net_4, net_5_scaled], axis=1)\n # print('context_net', context_net)\n # context_net = fluid.layers.concat([spatial_net,context_net], axis=1)\n # print('context_net2',context_net)\n\n ### FFM\n # net = FeatureFusionModule(input_1=spatial_net, input_2=context_net, num_filters=num_classes)\n net = FeatureFusionModule(inputs=context_net, num_filters=num_classes)\n\n # print('net', net)\n\n ## [batch_zize, num_filters, 128, 64]\n\n ### Final upscaling and finish\n # net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 128])\n # print('conv2d_transpose', net)\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn1')\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[128, 256])\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn2')\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 512])\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn3')\n #net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[512, 1024])\n #net = batch_normalization(net, relu=True, name='conv2d_transpose_bn4')\n # print('net',net)\n net = fluid.layers.image_resize(net, out_shape=[512, 1024], resample='BILINEAR')\n\n net = fluid.layers.conv2d(net, num_classes, 1)\n return net","def TBLCCCNN_Model(pan_image_height_size, pan_image_width_size, ms_to_pan_ratio, n_bands, n1_pan, n2_pan, n3_pan, \r\n n1_ms, n2_ms, n3_ms, dropout_rate, n_classes, l_r):\r\n \r\n if (pan_image_height_size % ms_to_pan_ratio) != 0 or (pan_image_width_size % ms_to_pan_ratio) != 0:\r\n raise ValueError('Please make sure that both pan_image_height_size and pan_image_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\r\n \r\n pan_img_input = Input(shape = (pan_image_height_size, pan_image_width_size, 1))\r\n conv_1_pan = Conv2D(n1_pan, (7, 7), padding = 'same', activation = 'relu')(pan_img_input)\r\n max_pool_1_pan = MaxPooling2D(pool_size = (2, 2))(conv_1_pan)\r\n conv_2_pan = Conv2D(n2_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_1_pan)\r\n max_pool_2_pan = MaxPooling2D(pool_size = (2, 2))(conv_2_pan)\r\n conv_3_pan = Conv2D(n3_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_2_pan)\r\n glob_max_pool_pan = GlobalMaxPooling2D()(conv_3_pan)\r\n glob_max_pool_pan = Dropout(dropout_rate)(glob_max_pool_pan)\r\n \r\n ms_img_input = Input(shape = (int(pan_image_height_size / ms_to_pan_ratio), int(pan_image_width_size / ms_to_pan_ratio), \r\n n_bands))\r\n conv_1_ms = Conv2D(n1_ms, (3, 3), padding = 'same', activation = 'relu')(ms_img_input)\r\n conv_2_ms = Conv2D(n2_ms, (3, 3), padding = 'same', activation = 'relu')(conv_1_ms)\r\n conv_3_ms = Conv2D(n3_ms, (3, 3), padding = 'same', activation = 'relu')(conv_2_ms)\r\n glob_max_pool_ms = GlobalMaxPooling2D()(conv_3_ms)\r\n glob_max_pool_ms = Dropout(dropout_rate)(glob_max_pool_ms)\r\n \r\n all_features = concatenate([glob_max_pool_pan, glob_max_pool_ms])\r\n \r\n pred_layer = Dense(n_classes, activation = 'softmax')(all_features)\r\n \r\n tblcccnn_model = Model(inputs = [ms_img_input, pan_img_input], outputs = pred_layer)\r\n tblcccnn_model.compile(loss = 'categorical_crossentropy', optimizer = Adam(lr = l_r), \r\n metrics = ['categorical_crossentropy'])\r\n \r\n return tblcccnn_model","def build_model(self):\n # Define model inputs for the encoder/decoder stack\n x_enc = Input(shape=(self.seq_len_in, self.input_feature_amount), name=\"x_enc\")\n x_dec = Input(shape=(self.seq_len_out, self.output_feature_amount), name=\"x_dec\")\n\n # Add noise\n x_dec_t = GaussianNoise(0.2)(x_dec)\n\n input_conv2 = Conv1D(filters=64, kernel_size=5, strides=2, activation='relu', padding='same')\n input_conv1 = Conv1D(filters=64, kernel_size=3, strides=2, activation='relu', padding='same', name=\"last_conv_layer\")\n\n input_conv2_out = input_conv2(x_enc)\n input_conv1_out = input_conv1(input_conv2_out)\n\n # Define the encoder GRU, which only has to return a state\n encoder_gru = GRU(self.state_size, return_sequences=True, return_state=True, name=\"encoder_gru\")\n encoder_out, encoder_state = encoder_gru(input_conv1_out)\n\n # Decoder GRU\n decoder_gru = GRU(self.state_size, return_state=True, return_sequences=True,\n name=\"decoder_gru\")\n # Use these definitions to calculate the outputs of out encoder/decoder stack\n dec_intermediates, decoder_state = decoder_gru(x_dec_t, initial_state=encoder_state)\n\n # Define the attention layer\n attn_layer = AttentionLayer(name=\"attention_layer\")\n attn_out, attn_states = attn_layer([encoder_out, dec_intermediates])\n\n # Concatenate decoder and attn out\n decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([dec_intermediates, attn_out])\n\n # Define the dense layer\n dense = Dense(self.output_feature_amount, activation='linear', name='output_layer')\n dense_time = TimeDistributed(dense, name='time_distributed_layer')\n decoder_pred = dense_time(decoder_concat_input)\n\n # Define the encoder/decoder stack model\n encdecmodel = tsModel(inputs=[x_enc, x_dec], outputs=decoder_pred)\n\n # Define the separate encoder model for inferencing\n encoder_inf_inputs = Input(shape=(self.seq_len_in, self.input_feature_amount), name=\"encoder_inf_inputs\")\n\n input_conv2_inf = input_conv2(encoder_inf_inputs)\n input_conv1_inf_out = input_conv1(input_conv2_inf)\n\n encoder_inf_out, encoder_inf_state = encoder_gru(input_conv1_inf_out)\n encoder_model = tsModel(inputs=encoder_inf_inputs, outputs=[encoder_inf_out, encoder_inf_state])\n\n # Define the separate encoder model for inferencing\n decoder_inf_inputs = Input(shape=(1, self.output_feature_amount), name=\"decoder_inputs\")\n encoder_inf_states = Input(shape=(encdecmodel.get_layer('last_conv_layer').output_shape[1], self.state_size), name=\"decoder_inf_states\")\n decoder_init_state = Input(shape=(self.state_size,), name=\"decoder_init\")\n\n decoder_inf_out, decoder_inf_state = decoder_gru(decoder_inf_inputs, initial_state=decoder_init_state)\n attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\n decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_inf_out, attn_inf_out])\n decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\n decoder_model = tsModel(inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\n outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state])\n\n return encoder_model, decoder_model, encdecmodel","def build_model():\n model = models.Sequential()\n\n # # Anti-overfit methods\n # model.add(layers.BatchNormalization())\n # model.add(layers.Dropout(0.5))\n # regularizers.l1_l2(l1=0.01, l2=0.01)\n\n model.add(layers.Conv2D(200, (3, 3), activation='relu',\n input_shape=nnc.INPUT_SHAPE))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.BatchNormalization())\n model.add(layers.Conv2D(200, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.BatchNormalization())\n model.add(layers.Conv2D(150, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.BatchNormalization())\n model.add(layers.Conv2D(100, (3, 3), activation='relu'))\n model.add(layers.MaxPooling2D((2, 2)))\n model.add(layers.BatchNormalization())\n model.add(layers.Flatten())\n model.add(layers.Dense(512, activation='relu',))\n model.add(layers.Dropout(0.5))\n model.add(layers.Dense(256, activation='relu',))\n model.add(layers.Dropout(0.5))\n model.add(layers.Dense(512, activation='relu',))\n model.add(layers.Dropout(0.5))\n model.add(layers.Dense(7, activation='sigmoid'))\n model.compile(optimizer=nnc.OPTIMIZER, loss=nnc.LOSS, metrics=nnc.METRICS)\n\n # # Print the model to the console\n model.summary()\n # # Print the model to a png file\n # utils.plot_model(model, show_shapes=True, to_file=nnc.MODEL_PLOT_PATH)\n # # Turn into multi-gpu model\n # model = utils.multi_gpu_model(model, gpus=2)\n\n return model","def build_model():\n model = keras.Sequential()\n\n model.add(Conv2D(32, (5, 5), activation='relu', input_shape=(32, 32, 1)))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.1))\n\n model.add(Conv2D(64, (5, 5), activation='relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n model.add(Flatten())\n model.add(Dense(128, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(43, activation='softmax'))\n\n model.compile(optimizer=keras.optimizers.Adam(),\n loss='sparse_categorical_crossentropy',\n metrics=['accuracy'])\n\n return model","def build_models(config):\n inputs = Input(shape=(config['patch_height'], config['patch_width'], config['depth'], config['channel']),\n name='patchimg')\n\n kernelinitfun = keras.initializers.RandomNormal(mean=0.0, stddev=0.1, seed=None)\n activationfun = 'relu'\n # kernelinitfun = 'glorot_normal'\n\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv1_1')(inputs)\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv1_2')(x)\n # x = Dropout(0.3)(x)\n x = BatchNormalization(name='bn1')(x)\n x = Activation(activationfun)(x)\n x = MaxPooling3D(name='mp1', strides=(2, 2, 1))(x)\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv2_1')(x)\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv2_2')(x)\n # x = Dropout(0.2)(x)\n x = BatchNormalization(name='bn2')(x)\n x = Activation(activationfun)(x)\n x = MaxPooling3D(name='mp2', strides=(2, 2, 1))(x)\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv3_1')(x)\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv3_2')(x)\n # x = Dropout(0.5)(x)\n x = BatchNormalization(name='bn3')(x)\n x = Activation(activationfun)(x)\n x = MaxPooling3D(name='mp3', strides=(2, 2, 1))(x)\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv4_1')(x)\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv4_2')(x)\n # x = Dropout(0.5)(x)\n x = BatchNormalization(name='bn4')(x)\n x = Activation(activationfun)(x)\n\n x4 = Flatten(name='aux_fx')(x)\n\n source_classifier = Dropout(0.5)(x4)\n source_classifier = Dense(512, activation='softmax', name=\"mo1\")(source_classifier)\n source_classifier = Dropout(0.5)(source_classifier)\n source_classifier = Dense(128, activation='softmax', name=\"mo2\")(source_classifier)\n # source_classifier = Dropout(0.3)(source_classifier)\n source_classifier = Dense(1, name=\"mo\")(source_classifier)\n\n domain_classifier = Dense(32, activation='linear', name=\"do4\")(x4)\n domain_classifier = BatchNormalization(name=\"do5\")(domain_classifier)\n domain_classifier = Activation(\"elu\", name=\"do6\")(domain_classifier)\n domain_classifier = Dropout(0.5)(domain_classifier)\n\n domain_classifier = Dense(2, activation='softmax', name=\"do\")(domain_classifier)\n\n adamop = keras.optimizers.Adam(learning_rate=1e-5, beta_1=0.9, beta_2=0.999, amsgrad=False)\n comb_model = Model(inputs=inputs, outputs=[source_classifier, domain_classifier])\n comb_model.compile(optimizer=adamop,\n loss={'mo': 'mae', 'do': 'categorical_crossentropy'},\n loss_weights={'mo': 1, 'do': 2}, metrics=['accuracy'], )\n\n source_classification_model = Model(inputs=inputs, outputs=[source_classifier])\n source_classification_model.compile(optimizer=adamop,\n loss={'mo': 'mae'}, metrics=['accuracy'], )\n\n domain_classification_model = Model(inputs=inputs, outputs=[domain_classifier])\n domain_classification_model.compile(optimizer=adamop,\n loss={'do': 'categorical_crossentropy'}, metrics=['accuracy'])\n\n embeddings_model = Model(inputs=inputs, outputs=[x4])\n embeddings_model.compile(optimizer=adamop, loss='categorical_crossentropy', metrics=['accuracy'])\n\n return comb_model, source_classification_model, domain_classification_model, embeddings_model"],"string":"[\n \"def build_model(input_classes,output_classes):\\n dimensions = 20\\n inputs = []\\n embedded_outputs = []\\n for i in input_classes:\\n input_layer = Input((1,))\\n inputs.append(input_layer)\\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\\n embedded_layer = embedder(input_layer)\\n embedded_outputs.append(embedded_layer)\\n\\n embedded_concats = Concatenate()(embedded_outputs)\\n flatten_layer = Flatten()\\n\\n dense_layer = Dense(output_classes)\\n\\n flattened_output = flatten_layer(embedded_concats)\\n dense_output = dense_layer(flattened_output)\\n\\n # dense_output = dense_layer(embedded_concats)\\n\\n model = Model(inputs,dense_output)\\n print(model.summary())\\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\\n\\n return model\",\n \"def build_cnn(self):\\n model = Sequential()\\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\\n model.add(Flatten())\\n model.add(Dense(len(ACTIONS), activation = 'linear'))\\n model.compile(loss = 'mse', optimizer = Adam(lr = alpha))\\n\\n return model\",\n \"def buildClassifier(input_shape=(100, 100, 3)):\\n # Initialising the CNN\\n classifier = Sequential()\\n classifier.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape, padding='same'))\\n classifier.add(MaxPooling2D(pool_size=(3, 3), padding='same'))\\n classifier.add(Dropout(0.5)) # added extra Dropout layer\\n classifier.add(Conv2D(64, (3, 3), activation='relu', padding='same'))\\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\\n classifier.add(Conv2D(128, (3, 3), padding='same', activation='relu'))\\n classifier.add(Dropout(0.5)) # added extra dropout layer\\n classifier.add(Conv2D(256, (3, 3), activation='relu', padding='same'))\\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\\n classifier.add(Dropout(0.2)) # antes era 0.25\\n classifier.add(Conv2D(512, (3, 3), padding='same', activation='relu'))\\n classifier.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))\\n classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))\\n classifier.add(Dense(units=1024, activation='relu')) # added new dense layer\\n classifier.add(Dropout(0.2)) # antes era 0.25\\n # Step 3 - Flattening\\n classifier.add(Flatten())\\n classifier.add(Dense(units=1024, activation='relu')) # added new dense layer\\n classifier.add(Dense(units=256, activation='relu')) # added new dense layer\\n # Step 4 - Full connection\\n classifier.add(Dropout(0.2))\\n classifier.add(Dense(units=1, activation='sigmoid'))\\n classifier.summary()\\n\\n # Compiling the CNN\\n classifier.compile(optimizer='adam',\\n loss='binary_crossentropy',\\n metrics=['accuracy'])\\n plot_model(classifier, to_file='model_plot.png', show_shapes=True, show_layer_names=True)\\n return classifier\",\n \"def construct_model():\\n # model = Sequential()\\n # model.add(Dense(units=64, activation='relu', input_dim=100))\\n # model.add(Dense(units=10, activation='softmax'))\\n # model.compile(loss='categorical_crossentropy',\\n # optimizer='sgd',\\n # metrics=['accuracy'])\\n # return model\\n\\n model = Sequential()\\n # Input Layer\\n model.add(Conv2D(64, 3, data_format='channels_last', activation='relu', padding='same',\\n input_shape=(img_width, img_height, 3)))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n # Hidden Layer 1\\n model.add(Conv2D(64, 3, activation='relu', padding='same'))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 2\\n model.add(Conv2D(128, 3, activation='relu', padding='same'))\\n model.add(Conv2D(128, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n # Hidden Layer 3\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same'))\\n model.add(Conv2D(256, 3, activation='relu', padding='same', strides=2))\\n model.add(MaxPool2D(pool_size=2, strides=2))\\n\\n\\n # Fully Connected Layer\\n model.add(Flatten())\\n # 512 Neuron Layer\\n model.add(Dense(512, activation='relu'))\\n model.add(Dropout(0.5))\\n # Output Layer\\n model.add(Dense(num_of_classes))\\n model.add(Activation('softmax'))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n return model\",\n \"def concat_model():\\n x = tf.keras.Input(shape=[10, 10, 3, ])\\n x1 = tf.keras.layers.Conv2D(5, (2, 2))(x)\\n x2 = tf.keras.layers.Conv2D(6, (2, 2))(x)\\n x3 = tf.keras.layers.Conv2D(7, (2, 2))(x)\\n z = tf.keras.layers.concatenate([x2, x1, x3], axis=-1)\\n z1 = tf.keras.layers.Conv2D(10, (2, 2))(z)\\n z2 = tf.keras.layers.Conv2D(10, (2, 2))(z)\\n z = tf.add(z1, z2)\\n z = tf.keras.layers.Flatten()(z)\\n output = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\\\"concat_model\\\")(z)\\n return output\",\n \"def build(self):\\n input_shape_img = (None, None, 3)\\n img_input = Input(shape=input_shape_img)\\n roi_input = Input(shape=(None, 4))\\n shared_layers = self.cnn_model.nn_base(img_input, trainable=True)\\n num_anchors = len(self.C.anchor_scales) * len(self.C.anchor_ratios)\\n \\n output_region_proposal = self.region_proposal_net(shared_layers, num_anchors)\\n output_classifier = self.classifier(shared_layers,\\n self.cnn_model.classifier_layers, \\n roi_input, self.C.num_roi, \\n num_class=len(self.class_count), trainable=True)\\n \\n self.model_region_proposal = Model(img_input, output_region_proposal[:2])\\n self.model_classifier = Model([img_input, roi_input], output_classifier)\\n self.model_all = Model([img_input, roi_input], output_region_proposal[:2] + output_classifier)\\n\\n optimizer = Adam(lr=1e-5)\\n self.model_region_proposal.compile(optimizer=optimizer, \\n loss=[losses.rpn_loss_cls(num_anchors), \\n losses.rpn_loss_regr(num_anchors)])\\n self.model_classifier.compile(optimizer=optimizer, \\n loss=[losses.class_loss_cls, \\n losses.class_loss_regr(len(self.class_count)-1)], \\n metrics={'dense_class_{}'.format(len(self.class_count)): 'accuracy'})\\n self.model_all.compile(optimizer='sgd', loss='mae')\\n\\n # print(self.model_all.summary())\\n plot_model(self.model_region_proposal, show_shapes=True, to_file='./frcnn/images/region_proposal.png')\\n plot_model(self.model_classifier, show_shapes=True, to_file='./frcnn/images/classifier.png')\\n plot_model(self.model_all, show_shapes=True, to_file='./frcnn/images/model_all.png')\",\n \"def multiple_input_model():\\n\\n input1 = tf.keras.Input(name='input1', shape=(10, 10, 3))\\n input2 = tf.keras.Input(name='input2', shape=(12, 12, 3))\\n x1 = tf.keras.layers.Conv2D(8, (1, 1), name='conv1a')(input1)\\n x2 = tf.keras.layers.Conv2D(8, (3, 3), name='conv1b')(input2)\\n x = tf.keras.layers.add([x1, x2])\\n x = tf.keras.layers.Conv2D(4, (1, 1), name='conv2')(x)\\n x = tf.keras.layers.Flatten()(x)\\n outputs = tf.keras.layers.Dense(2, activation=tf.nn.softmax, name=\\\"multiple_input_model\\\")(x)\\n\\n return outputs\",\n \"def __init__(self, n_input_channels=3, n_conv_output_channels=16, k=3, s=1, pad=1, p = 0.5):\\n super(ModelCNN, self).__init__()\\n # 1. Convolutional layers\\n # Single image is in shape: 3x96x96 (CxHxW, H==W), RGB images\\n self.conv1 = nn.Conv2d(in_channels = n_input_channels, out_channels = n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn1 = nn.BatchNorm2d(n_conv_output_channels)\\n self.conv2 = nn.Conv2d(in_channels = n_conv_output_channels, out_channels = 2*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn2 = nn.BatchNorm2d(2*n_conv_output_channels)\\n self.conv3 = nn.Conv2d(in_channels = 2*n_conv_output_channels, out_channels = 4*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn3 = nn.BatchNorm2d(4*n_conv_output_channels)\\n self.conv4 = nn.Conv2d(in_channels = 4*n_conv_output_channels, out_channels = 8*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn4 = nn.BatchNorm2d(8*n_conv_output_channels)\\n self.pool = nn.MaxPool2d(kernel_size = k - 1, stride = 2*s, padding = pad - pad)\\n \\n self.dropout = nn.Dropout(p = p)\\n \\n # 2. FC layers to final output\\n self.fc1 = nn.Linear(in_features = 288*n_conv_output_channels, out_features = 32*n_conv_output_channels)\\n self.fc_bn1 = nn.BatchNorm1d(32*n_conv_output_channels)\\n self.fc2 = nn.Linear(in_features = 32*n_conv_output_channels, out_features = 16*n_conv_output_channels)\\n self.fc_bn2 = nn.BatchNorm1d(16*n_conv_output_channels)\\n self.fc3 = nn.Linear(in_features = 16*n_conv_output_channels, out_features = 8*n_conv_output_channels)\\n self.fc_bn3 = nn.BatchNorm1d(8*n_conv_output_channels)\\n self.fc4 = nn.Linear(in_features = 8*n_conv_output_channels, out_features = 1)\",\n \"def c3d(self):\\n model = Sequential()\\n # 1st layer group\\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv1',\\n subsample=(1, 1, 1),\\n input_shape=self.input_shape))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\\n border_mode='valid', name='pool1'))\\n # 2nd layer group\\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv2',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool2'))\\n # 3rd layer group\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool3'))\\n # 4th layer group\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='valid', name='pool4'))\\n\\n # 5th layer group\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5b',\\n subsample=(1, 1, 1)))\\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\\n # model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n # border_mode='valid', name='pool5', dim_ordering=\\\"tf\\\"))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool5', dim_ordering=\\\"tf\\\"))\\n model.add(Flatten())\\n\\n # FC layers group\\n model.add(Dense(4096, activation='relu', name='fc6'))\\n model.add(Dropout(0.5))\\n model.add(Dense(4096, activation='relu', name='fc7'))\\n model.add(Dropout(0.5))\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n for layer in model.layers:\\n print(layer.output_shape)\\n return model\",\n \"def build(bottom_model, num_classes):\\n\\n top_model = bottom_model.output\\n top_model = GlobalAveragePooling2D()(top_model)\\n top_model = Dense(1024,activation='relu')(top_model)\\n top_model = Dense(1024,activation='relu')(top_model)\\n top_model = Dense(512,activation='relu')(top_model)\\n top_model = Dense(num_classes,activation='softmax')(top_model)\\n return top_model\",\n \"def create_multioutput_model(input_cols, output_cols):\\n # Defining the model\\n characteristics_input = keras.Input(shape=(len(input_cols)), name=\\\"characteristics\\\")\\n x = layers.Dense(35, activation=\\\"relu\\\")(characteristics_input)\\n x = layers.Dropout(0.22)(x)\\n x = layers.Dense(31, activation=\\\"softmax\\\", kernel_constraint=constraints.NonNeg())(x)\\n x = layers.Dropout(0.32)(x)\\n\\n fdc_outputs = []\\n for i, fdc_exceedance_value in enumerate(output_cols):\\n fdc_outputs.append(keras.layers.Dense(1, activation=\\\"linear\\\", kernel_constraint=constraints.NonNeg(),\\n name=fdc_exceedance_value)(x))\\n\\n # Create the model\\n model = keras.Model(\\n inputs=[characteristics_input],\\n outputs=fdc_outputs\\n )\\n\\n # Compiling the model\\n model.compile(\\n loss=keras.losses.MeanAbsoluteError(),\\n optimizer=keras.optimizers.Adam(learning_rate=0.005)\\n )\\n\\n return model\",\n \"def model_build(self):\\n\\n # Define the input placeholder as a tensor with shape input_shape. Think of this as your input image!\\n X_input = Input(self.inputData[0].shape)\\n\\n '''\\n # CONV -> BN -> RELU Block applied to X\\n X = Conv2D(8, (8, 8), name='conv0')(X_input)\\n X = BatchNormalization(name='bn0')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool0')(X)\\n X = Dropout(0.1, name='dropout0')(X)\\n\\n X = Conv2D(16, (16, 16), name='conv1')(X)\\n X = BatchNormalization(name='bn1')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool1')(X)\\n X = Dropout(0.1, name='dropout1')(X)\\n\\n X = Conv2D(16, (32, 32), name='conv2')(X)\\n X = BatchNormalization(name='bn2')(X)\\n X = Activation('relu')(X)\\n X = MaxPooling2D((2, 4), name='max_pool2')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n' '''\\n\\n X = Dense(500, activation='relu', name='fc0')(X_input)\\n X = Dropout(0.1, name='dropout1')(X)\\n X = Dense(500, activation='relu', name='fc1')(X)\\n X = Dropout(0.1, name='dropout2')(X)\\n X = Dense(3, activation='softmax', name='fc2')(X)\\n\\n # Create model. This creates your Keras model instance, you'll use this instance to train/test the model.\\n self.model = Model(inputs=X_input, outputs=X, name='acouModel')\",\n \"def __init__(self,inputSize,outputSize, *args, **kwds):\\n #currently the code is only for 2 hidden layers, apart from in and out\\n self._saveFile = kwds.get('saveFile')\\n self._inputSize = inputSize\\n self._outputSize= outputSize\\n self._layer1 = keras.layers.Dense(128,activation='relu')\\n self._layer2 = keras.layers.Dense(64,activation='relu') \\n self._layer3 = keras.layers.Dense(128,activation='relu')\\n self._piLayer = keras.layers.Dense(self._outputSize-1,activation='softmax')\\n self._zLayer = keras.layers.Dense(1,activation='tanh')\\n self._inputs = keras.Input(shape=(self._inputSize,)) #returns placeholder\\n x = self._layer1(self._inputs)\\n x = self._layer2(x)\\n x = self._layer3(x)\\n self._outPi = self._piLayer(x)\\n self._outZ = self._zLayer(x)\\n self._output = keras.layers.concatenate([self._outPi,self._outZ],axis = -1)\\n self._model = keras.Model(inputs=self._inputs,outputs=self._outPi)\\n# self._model = keras.Model(inputs=self._inputs,outputs=self._outPi)\\n self._model.compile(optimizer=keras.optimizers.Adam(lr=0.001, beta_1=0.99, beta_2=0.999, epsilon=1e-10, decay=0.0001),\\n loss=\\\"categorical_crossentropy\\\",\\n metrics=['accuracy'])\\n self._epochSize = 256\",\n \"def build(self, input_image, num_class):\\n x = build_resnet(101)\\n # add classifier\\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)\",\n \"def __init__(self):\\n super(Decoder_1m, self).__init__()\\n self.lconvtwos = nn.ModuleList(\\n [\\n nn.Sequential(\\n nn.Dropout(p=0.1),\\n nn.Conv2d(128, 32, kernel_size=(3, 3), padding=1),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=1),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n ),\\n ]\\n )\\n\\n self.convtwos = nn.ModuleList(\\n [\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=1),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=1),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=2, dilation=2),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=4, dilation=4),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=8, dilation=8),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=16, dilation=16),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=32, dilation=32),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n nn.Sequential(\\n nn.Conv2d(64, 32, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(32),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(32, 64, kernel_size=(3, 3), padding=64, dilation=64),\\n nn.BatchNorm2d(64),\\n nn.ReLU(inplace=True),\\n ),\\n ]\\n )\\n self.final = nn.Sequential(\\n nn.Conv2d(64, 5, kernel_size=(1, 1), padding=0),\\n nn.BatchNorm2d(5),\\n nn.ReLU(inplace=True),\\n nn.Conv2d(5, 1, kernel_size=(1, 1), padding=0),\\n )\",\n \"def __add_model_tail(model,\\n n_outputs,\\n dropout_rate,\\n max_pool_size,\\n lr=0.001):\\n model.add(Dropout(dropout_rate))\\n model.add(MaxPool1D(pool_size=max_pool_size))\\n model.add(Flatten())\\n model.add(Dense(100, activation='relu'))\\n model.add(Dense(n_outputs, activation='softmax'))\\n adam = Adam(lr)\\n model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['categorical_accuracy'])\\n\\n return model\",\n \"def _build_model(self):\\n \\n #convolutional part\\n conv_inputs = keras.Input(shape = self._state_shape[0])\\n c1 = layers.Conv2D(filters = 4, kernel_size = 2, strides = (2,2), padding = \\\"same\\\", activation = 'relu')(conv_inputs)\\n c2 = layers.Conv2D(filters = 8, kernel_size = 2, strides = (1,1), padding = \\\"same\\\", activation = 'relu')(c1)\\n flat = layers.Flatten()(c2)\\n\\n\\n #current green phase layer\\n # phase_inputs = keras.Input(shape = (self._state_shape[1],))\\n \\n #elapsed green time layer\\n elapsed_time_inputs = keras.Input(shape = (self._state_shape[2],))\\n \\n \\n #combine elapsed time and green time layer\\n # combined_green = layers.concatenate([phase_inputs, elapsed_time_inputs])\\n # green_dense = layers.Dense(10, activation='relu')(elapsed_time_inputs)\\n \\n #combine green layer with conv layer\\n all_combined = layers.concatenate([elapsed_time_inputs, flat])\\n dense = layers.Dense(32, activation='relu')(all_combined)\\n dense = layers.Dense(16, activation='relu')(dense)\\n outputs = layers.Dense(self._output_dim, activation='linear')(dense)\\n \\n model = keras.Model(inputs = [conv_inputs, elapsed_time_inputs], outputs = outputs, name='simple_CNN') \\n model.compile(loss=losses.mean_squared_error, optimizer=Adam(lr=self._learning_rate))\\n \\n return model\",\n \"def __init__(self, args):\\n \\n super(MicroNet, self).__init__()\\n self.conv1 = nn.Conv2d(3, 1, kernel_size=1)\\n self.conv2 = nn.Conv2d(1, 29, kernel_size=5)\\n self.maxpool2 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv3 = nn.Conv2d(29, 59, kernel_size=3)\\n self.maxpool3 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv4 = nn.Conv2d(59, 74, kernel_size=3)\\n self.maxpool4 = nn.MaxPool2d(3, stride=2 , ceil_mode=True)\\n self.conv2_drop = nn.Dropout2d()\\n self.conv3_drop = nn.Dropout2d()\\n self.fc1 = nn.Linear(1184, 300)\\n self.fc2 = nn.Linear(300, args.num_classes)\\n self.conv0_bn = nn.BatchNorm2d(3)\\n self.conv1_bn = nn.BatchNorm2d(1)\\n self.conv2_bn = nn.BatchNorm2d(29)\\n self.conv3_bn = nn.BatchNorm2d(59)\\n self.conv4_bn = nn.BatchNorm2d(74)\\n self.dense1_bn = nn.BatchNorm1d(300)\",\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 build_combined(self, num_classes: int = 10) -> KM.Model:\\n\\n # For decoder number of features in opposite order of encoder\\n decoder_features = self.encoder_features.copy()\\n decoder_features.reverse()\\n\\n # build the encoder model\\n self.encoder_model = self.encoder(\\n features=self.encoder_features, name=\\\"encoder\\\"\\n )\\n\\n # build the decoder model\\n decoder = self.decoder(features=decoder_features, name=\\\"decoder\\\")\\n input_tensor = KL.Input(\\n shape=(32, 32, 3)\\n ) # shape of images for cifar10 dataset\\n\\n # Encode the images\\n encoded_features = self.encoder_model(input_tensor)\\n # Decode the image from the final layer features of Auto-encoder\\n decoded = decoder(encoded_features[-1])\\n contrastive_features = KL.Lambda(lambda x: K.mean(x, [1, 2]), name=\\\"contrast\\\")(\\n encoded_features[-1]\\n )\\n # Calculate class probs from multiple latent representations\\n probs = classifier_block(encoded_features, num_classes=num_classes)\\n\\n return KM.Model(\\n inputs=input_tensor,\\n outputs=[decoded, probs, contrastive_features],\\n name=\\\"combined\\\",\\n )\",\n \"def compile_model_cnn(genome, nb_classes, input_shape):\\n # Get our network parameters.\\n nb_layers = genome.geneparam['nb_layers' ]\\n nb_neurons = genome.nb_neurons()\\n activation = genome.geneparam['activation']\\n optimizer = genome.geneparam['optimizer' ]\\n\\n logging.info(\\\"Architecture:%s,%s,%s,%d\\\" % (str(nb_neurons), activation, optimizer, nb_layers))\\n\\n model = Sequential()\\n\\n # Add each layer.\\n for i in range(0,nb_layers):\\n # Need input shape for first layer.\\n if i == 0:\\n model.add(Conv2D(nb_neurons[i], kernel_size = (3, 3), activation = activation, padding='same', input_shape = input_shape))\\n else:\\n model.add(Conv2D(nb_neurons[i], kernel_size = (3, 3), activation = activation))\\n \\n if i < 2: #otherwise we hit zero\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n \\n model.add(Dropout(0.2))\\n\\n model.add(Flatten())\\n # always use last nb_neurons value for dense layer\\n model.add(Dense(nb_neurons[len(nb_neurons) - 1], activation = activation))\\n model.add(Dropout(0.5))\\n model.add(Dense(nb_classes, activation = 'softmax'))\\n\\n #BAYESIAN CONVOLUTIONAL NEURAL NETWORKS WITH BERNOULLI APPROXIMATE VARIATIONAL INFERENCE\\n #need to read this paper\\n\\n model.compile(loss='categorical_crossentropy',\\n optimizer=optimizer,\\n metrics=['accuracy'])\\n\\n return model\",\n \"def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\\n\\t\\t# We have to match this output size.\\n\\t\\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\\n\\t\\n\\t\\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\\n\\t\\n\\t\\t# Convolutional ops will go here.\\n\\t\\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tconv_output = c5\\n\\t\\n\\t\\t# Transition to FC layers.\\n\\t\\tpre_flat_shape = conv_output.get_shape().as_list()\\n\\t\\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\\n\\t\\n\\t\\t# Dense connections\\n\\t\\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\\n\\t\\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\\n\\t\\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\\n\\t\\tfc_out = fc2\\n\\t\\n\\t\\t# Output point and our encoder mix-in.\\n\\t\\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\\n\\t\\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\\n\\t\\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\\n\\t\\n\\t\\t# More dense connections on the offset.\\n\\t\\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\\n\\t\\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\\n\\t\\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\\n\\t\\n\\t\\t# Expand for more convolutional operations.\\n\\t\\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\\n\\t\\n\\t\\t# More convolutions here.\\n\\t\\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\\n\\t\\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\\n\\t\\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\\n\\t\\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tdeconv_output = dc0\\n\\t\\n\\t\\t# Return result + encoder output\\n\\t\\treturn deconv_output, encoded_output\",\n \"def build_model_mobilenet(num_classes):\",\n \"def set_component_outputs(self):\\n outputs = []\\n\\n text = Text(self.get_data(), self.vocabulary)\\n dp = DataPack(text, usage=self.indices)\\n outputs.append(dp)\\n\\n if self.is_labelled():\\n labels_data = Numeric(self.labels)\\n labels_usage = Labels(self.label_names, self.multilabel)\\n dp = DataPack(labels_data, labels_usage)\\n dp.add_usage(self.indices)\\n outputs.append(dp)\\n if self.targets:\\n # tar = self.train_targets + self.test_targets\\n # dp = DataPack.make(tar, GroundTruth)\\n dp = DataPack.make(self.targets, GroundTruth)\\n dp.add_usage(self.indices)\\n outputs.append(dp)\\n\\n self.data_pool.add_data_packs(outputs, self.name)\",\n \"def buildModel(self, img_shape = 20, num_categories = 10):\\n\\n # Add first convolutional layer and max pooling\\n self.model.add(Conv2D(32, # Number of features detectors (filters)\\n (3, # 3 Row (conv. matrix)\\n 3), # 3 Columns (conv.matrix usually 3x3)\\n input_shape=(img_shape, img_shape, 3), # 3 Channels, img_shape x img_shape images\\n activation='relu', # Activation function to increase nonlinearity of images\\n name = 'FirstConv2DLayer')) # Layer name\\n self.model.add(MaxPooling2D(pool_size=(2, 2))) # Size of pooling matrix (usually 2x2)\\n\\n # Add second convolutional layer and max pooling\\n self.model.add(Conv2D(32, (3, 3), input_shape=(img_shape, img_shape, 3), activation='relu', name ='SecondConv2DLayer'))\\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n # Flattening\\n self.model.add(Flatten())\\n\\n # Full connection\\n self.model.add(Dense(units=128, activation='relu'))\\n\\n # One output for each category we predicted want to predict\\n self.model.add(Dense(units=num_categories, activation='softmax', name='Probabilities')) # Softmax for more than two outcome\\n\\n # Compile the CNN (Gradient descent)\\n self.model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\",\n \"def create_cnn(num_features: int = None) -> models.Model:\\n nclass = num_features or 5\\n inp = Input(shape=(187, 1))\\n img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\\\"valid\\\")(inp)\\n # img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = GlobalMaxPool1D()(img_1)\\n img_1 = Dropout(rate=0.2)(img_1)\\n\\n dense_1 = Dense(64, activation=activations.relu, name=\\\"dense_1\\\")(img_1)\\n dense_1 = Dense(64, activation=activations.relu, name=\\\"dense_2\\\")(dense_1)\\n dense_1 = Dense(nclass, activation=activations.softmax, name=\\\"dense_3_mitbih\\\")(dense_1)\\n\\n model = models.Model(inputs=inp, outputs=dense_1)\\n opt = optimizers.Adam(learning_rate=0.001)\\n\\n model.compile(optimizer=opt,\\n loss=losses.sparse_categorical_crossentropy,\\n metrics=['accuracy'])\\n model.summary()\\n return model\",\n \"def build_outputs(self):\\n with tf.variable_scope(\\\"build_outputs\\\"):\\n\\n self.optical_flow = self.__optical_flow_src2_tgt\\n self.disp = self.baselineNet.disp_tgt\\n self.semantic = self.__semantic\\n self.motion_mask = self.prepare_final_motion_mask()\",\n \"def build(self):\\n\\n # bgr_ = bgr*255.0\\n bgr_= self.X\\n start_time = time.time()\\n print(\\\"build model started\\\")\\n\\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n # blue - VGG_MEAN[0],\\n # green - VGG_MEAN[1],\\n # red - VGG_MEAN[2],\\n\\n red - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n blue - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n\\n\\n\\n print(bgr.shape)\\n\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n\\n\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\\n\\n\\n\\n\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\\n\\n self.fc6 = self.fc_layer(self.pool5, \\\"fc6\\\")\\n assert self.fc6.get_shape().as_list()[1:] == [4096]\\n self.relu6 = tf.nn.relu(self.fc6)\\n\\n self.fc7 = self.fc_layer(self.relu6, \\\"fc7\\\")\\n self.relu7 = tf.nn.relu(self.fc7)\\n\\n self.fc8 = self.fc_layer(self.relu7, \\\"fc8\\\")\\n\\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\\n # self.relu9 = tf.nn.relu(self.fc9)\\n\\n\\n\\n\\n relu8 = tf.nn.relu(self.fc8)\\n fc9 = self.fc_layer(relu8, 'fc9')\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\\n return fc9\\n\\n # self.prob = tf.nn.softmax(self.fc8, name=\\\"prob\\\")\",\n \"def initialize_models(self): \\n state_shape = list(self.env.observation_space.shape)\\n img_height, img_width, n_channels = state_shape\\n num_actions = self.env.action_space.n\\n print(\\\"img_height: \\\", img_height)\\n print(\\\"img_width: \\\", img_width)\\n print(\\\"n_channels: \\\", n_channels)\\n print(\\\"n_actions: \\\", num_actions)\\n\\n ##############################################################\\n ################ YOUR CODE HERE - 25-30 lines lines ################\\n modules = OrderedDict()\\n\\n # def conv_output_shape(h_w, kernel_size=1, stride=1, pad=0, dilation=1): -> h,w \\n pad1 = (3 * img_height - 4 + 8) // 2\\n modules['0'] = nn.Conv2d(n_channels * self.config.state_history, 32, 8, stride=4, padding=pad1)\\n modules['relu1'] = nn.ReLU()\\n out1h, out1w = conv_output_shape((img_height, img_width), kernel_size=8, stride=4, pad=pad1, dilation=1)\\n\\n pad2 = (out1w + 2) // 2\\n modules['2'] = nn.Conv2d(32, 64, 4, stride=2, padding=pad2)\\n modules['relu3'] = nn.ReLU()\\n out2h, out2w = conv_output_shape((out1h, out1w), kernel_size=4, stride=2, pad=pad2, dilation=1)\\n\\n pad3 = 1\\n modules['4'] = nn.Conv2d(64, 64, 3, stride=1, padding=pad3)\\n modules['relu5'] = nn.ReLU()\\n out3h, out3w = conv_output_shape((out2h, out2w), kernel_size=3, stride=1, pad=pad3, dilation=1)\\n\\n modules['flatten'] = nn.Flatten()\\n modules['fc'] = nn.Linear(out3h*out3w*64, num_actions)\\n self.q_network = nn.Sequential(modules)\\n\\n target_modules = OrderedDict()\\n target_modules['t_layer1'] = nn.Conv2d(n_channels * self.config.state_history, 32, 8, stride=4, padding=pad1)\\n target_modules['t_relu1'] = nn.ReLU()\\n target_modules['t_layer2'] = nn.Conv2d(32, 64, 4, stride=2, padding=pad2)\\n target_modules['t_relu2'] = nn.ReLU()\\n target_modules['t_layer3'] = nn.Conv2d(64, 64, 3, stride=1, padding=pad3)\\n target_modules['t_relu3'] = nn.ReLU()\\n target_modules['t_flatten'] = nn.Flatten()\\n target_modules['t_fc'] = nn.Linear(out3h*out3w*64, num_actions)\\n self.target_network = nn.Sequential(target_modules)\\n\\n ##############################################################\\n ######################## END YOUR CODE #######################\",\n \"def build_dc_classifier():\\n # return nn.Sequential(\\n # Unflatten(Batch_size, 1, 28, 28),\\n # nn.Conv2d(1, 32, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(2, stride=2),\\n # nn.Conv2d(32, 64, kernel_size=5, stride=1),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.MaxPool2d(kernel_size=2, stride=2),\\n # Flatten(),\\n # nn.Linear(4 * 4 * 64, 4 * 4 * 64),\\n # nn.LeakyReLU(negative_slope=0.01),\\n # nn.Linear(4 * 4 * 64, 1)\\n # )\\n\\n return nn.Sequential(\\n Unflatten(Batch_size, 1, 128, 128), #28,28,32 #128,128,16\\n nn.Conv2d(1, 16,kernel_size=5, stride=1), #24,24,32 #124,124,16\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(2, stride=2), #12,12,32 #62,62,16\\n nn.Conv2d(16, 32,kernel_size=5, stride=1), # 8, 8,64 #58,58,32\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,64 #29,29,32\\n nn.Conv2d(32, 64, kernel_size=5, stride=1), #25,25,64\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), #12,12,64\\n nn.Conv2d(64, 128, kernel_size=5, stride=1), # 8, 8,128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.MaxPool2d(kernel_size=2, stride=2), # 4, 4,128\\n Flatten(),\\n nn.Linear(4*4*128, 4*4*128), # 4*4*64 # 4*4*128\\n nn.LeakyReLU(negative_slope=0.01),\\n nn.Linear(4*4*128,1) # 4*4*64 # 4*4*128\\n )\",\n \"def build_model_multihead_attention_multiscaleCNN4_covermore(self,\\n dim_attention,headnum,\\n embedding_vec,\\n load_weights=False, weight_dir=None,\\n nb_filters=32,filters_length1=1,\\n filters_length2=5,\\n filters_length3=10,\\n pooling_size=3,\\n drop_input=0,\\n drop_cnn=0.2,\\n drop_flat=0,\\n W1_regularizer=0.005,\\n W2_regularizer=0.005,\\n Att_regularizer_weight=0.0005,\\n BatchNorm=False,\\n fc_dim = 50,\\n fcnum=0,\\n posembed=False,\\n pos_dmodel=40,\\n pos_nwaves = 20,\\n posmod = 'concat',\\n regularfun=1,\\n huber_delta=1,\\n activation='gelu',\\n activationlast='gelu',\\n add_avgpooling = False,\\n poolingmod=1,\\n normalizeatt=False,\\n regressionmodel=False,\\n attmod = \\\"softmax\\\",\\n sharp_beta=1,\\n lr = 0.001 \\n ):\\n ###print('Advanced Masking')\\n def mask_func(x):\\n return x[0] * x[1]\\n \\n ###print(posembed)\\n ###print(posmod)\\n input = Input(shape=(self.max_len,), dtype='int8')\\n input_mask = Input(shape=([int(self.max_len/pooling_size), 1]), dtype='float32')\\n embedding_layer = Embedding(len(embedding_vec), len(embedding_vec[0]), weights=[embedding_vec],\\n input_length=self.max_len,\\n trainable=False)\\n embedding_output = Dropout(drop_input)(embedding_layer(input)) #layer2\\n if 'gelu' in activation:\\n activationfun=gelu\\n else:\\n activationfun = 'relu'\\n \\n if 'gelu' in activationlast:\\n activationlastfun = gelu\\n else:\\n activationlastfun='relu'\\n \\n ###print(activationfun)\\n ###print(activationlastfun)\\n with tf.name_scope('first_cnn'):\\n first_cnn = Convolution1D(nb_filters, filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN1')(embedding_output) #layer3\\n first_cnn2 = Convolution1D(int(nb_filters/2), filters_length1, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(first_cnn) #layer5\\n second_cnn = Convolution1D(nb_filters, filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN2')(embedding_output) #layer4\\n second_cnn2 = Convolution1D(int(nb_filters/2), filters_length2, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(second_cnn)\\n third_cnn = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationfun, use_bias=False,name='CNN3')(embedding_output)\\n \\n third_cnn2 = Convolution1D(int(nb_filters/2), filters_length3, #kernel_regularizer=regularizers.l2(0.0001),\\n border_mode='same', activation=activationlastfun, use_bias=False)(third_cnn)\\n if BatchNorm:\\n first_cnn2 = BatchNormalization()(first_cnn2)\\n second_cnn2 = BatchNormalization()(second_cnn2)\\n third_cnn2 = BatchNormalization()(third_cnn2)\\n \\n if not add_avgpooling:\\n if poolingmod == 1:\\n pooling_layer = MaxPooling1D(pool_length=pooling_size, stride=pooling_size)\\n else:\\n pooling_layer = AveragePooling1D(pool_length=pooling_size, stride=pooling_size)\\n \\n cnn_output1 = Dropout(drop_cnn)(pooling_layer(first_cnn2))\\n cnn_output2 = Dropout(drop_cnn)(pooling_layer(second_cnn2))\\n cnn_output3 = Dropout(drop_cnn)(pooling_layer(third_cnn2))\\n else:\\n first_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\\n first_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(first_cnn2)\\n cnn_output1 = Dropout(drop_cnn)(concatenate([first_cnn2_max,first_cnn2_avg],axis=-1))\\n second_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\\n second_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(second_cnn2)\\n cnn_output2 = Dropout(drop_cnn)(concatenate([second_cnn2_max,second_cnn2_avg],axis=-1))\\n third_cnn2_max=MaxPooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\\n third_cnn2_avg=AveragePooling1D(pool_length=pooling_size, stride=pooling_size)(third_cnn2)\\n cnn_output3 = Dropout(drop_cnn)(concatenate([third_cnn2_max,third_cnn2_avg],axis=-1))\\n \\n \\n \\n if posembed:\\n ##print(posmod)\\n from position_embedding import PositionEmbedding\\n if posmod == 'concat':\\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb1')(cnn_output1)\\n cnn_output1 = concatenate([cnn_output1, pos_emb1], axis=-1)\\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb2')(cnn_output2)\\n cnn_output2 = concatenate([cnn_output2, pos_emb2], axis=-1)\\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=pos_nwaves, d_model=pos_dmodel,name='pos_emb3')(cnn_output3)\\n cnn_output3 = concatenate([cnn_output3, pos_emb3], axis=-1)\\n else:\\n ##print(\\\"yes add posmod\\\")\\n pos_emb1 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output1)[-1]/2), d_model=int_shape(cnn_output1)[-1],name='pos_emb1')(cnn_output1)\\n cnn_output1 = Add()([cnn_output1, pos_emb1])\\n pos_emb2 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output2)[-1]/2), d_model=int_shape(cnn_output2)[-1],name='pos_emb2')(cnn_output2)\\n cnn_output2 = Add()([cnn_output2, pos_emb2])\\n pos_emb3 = PositionEmbedding(max_time=int(self.max_len/pooling_size), n_waves=int(int_shape(cnn_output3)[-1]/2), d_model=int_shape(cnn_output3)[-1],name='pos_emb3')(cnn_output3)\\n cnn_output3 = Add()([cnn_output3, pos_emb3])\\n \\n mask_input1 = []\\n mask_input1.append(cnn_output1)\\n mask_input1.append(input_mask)\\n cnn_mask_output1 = Lambda(mask_func)(mask_input1)\\n del mask_input1\\n mask_input2 = []\\n mask_input2.append(cnn_output2)\\n mask_input2.append(input_mask)\\n cnn_mask_output2 = Lambda(mask_func)(mask_input2)\\n del mask_input2\\n mask_input3 = []\\n mask_input3.append(cnn_output3)\\n mask_input3.append(input_mask)\\n cnn_mask_output3 = Lambda(mask_func)(mask_input3)\\n del mask_input3\\n \\n if regularfun==1:\\n regularizerfunction_W1 = regularizers.l1(W1_regularizer)\\n regularizerfunction_W2 = regularizers.l1(W2_regularizer)\\n elif regularfun==2:\\n regularizerfunction_W1 = regularizers.l2(W1_regularizer)\\n regularizerfunction_W2 = regularizers.l2(W2_regularizer)\\n elif regularfun ==3:\\n regularizerfunction_W1 = smoothL1(W1_regularizer,huber_delta)\\n regularizerfunction_W2 = smoothL1(W2_regularizer,huber_delta)\\n \\n with tf.name_scope('multihead_attention'):\\n att1,att1_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att1\\\")(concatenate([cnn_mask_output1, input_mask]))#-5 layer\\n \\n att2,att2_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att2\\\")(concatenate([cnn_mask_output2, input_mask])) #-4 layer\\n \\n att3,att3_A = Attention_mask(hidden=cnn_output1.get_shape()[-1].value, da=dim_attention, r=headnum, init='glorot_uniform', activation='tanh',\\n W1_regularizer=regularizerfunction_W1,\\n W2_regularizer=regularizerfunction_W2,\\n W1_constraint=None, W2_constraint=None, return_attention=True,\\n attention_regularizer_weight=Att_regularizer_weight,normalize=normalizeatt,attmod=attmod,sharp_beta=sharp_beta,name=\\\"att3\\\")(concatenate([cnn_mask_output3, input_mask])) #-3 layer\\n \\n if BatchNorm:\\n att1 = BatchNormalization()(att1)\\n att2 = BatchNormalization()(att2)\\n att3 = BatchNormalization()(att3)\\n \\n \\n output = Dropout(drop_flat)(Flatten()(concatenate([att1,att2,att3]))) #-2 layer\\n \\n fc = output\\n for _ in range(fcnum):\\n fc = Dense(fc_dim,activation='relu')(fc)\\n fc = Dropout(drop_flat)(fc)\\n \\n with tf.name_scope(''):\\n if regressionmodel:\\n preds = Dense(self.nb_classes,activation='softmax')(fc) #-1 layer\\n else:\\n preds = Dense(self.nb_classes,activation='sigmoid')(fc) #-1 layer\\n \\n self.model = Model(inputs=[input,input_mask], outputs=preds)\\n from keras import optimizers\\n # optim = optimizers.RMSprop()\\n optim = optimizers.Adam(lr=lr, decay=5e-5) #The paper uses a decay rate alpha = alpha/sqrt(t) updted each epoch (t) for the logistic regression demonstration.\\n #optim = optimizers.nadam()\\n #optim = RAdam()\\n if regressionmodel:\\n self.model.compile(loss='kld',optimizer=optim,metrics=['acc'])\\n else:\\n self.model.compile(loss='binary_crossentropy',optimizer=optim,metrics=['binary_accuracy','categorical_accuracy'])\\n \\n \\n \\n if load_weights:\\n self.model.load_weights(weight_dir)\\n \\n self.is_built = True\\n self.bn = False\\n self.model.summary()\",\n \"def MakeModel(self):\\n group1, group2 = self.data\\n self.n, self.m = len(group1), len(group2)\\n self.pool = np.hstack((group1, group2))\",\n \"def MakeModel(self):\\n group1, group2 = self.data\\n self.n, self.m = len(group1), len(group2)\\n self.pool = np.hstack((group1, group2))\",\n \"def build_model_cnn(x_train, n=32, d=0.25, k=5):\\n model = Sequential()\\n model.add(Dropout(rate = d, input_shape = (x_train.shape[1], 1)))\\n model.add(Conv1D(filters=n, kernel_size=(5), strides=1, activation = 'relu', kernel_constraint=max_norm(4)))\\n model.add(Dropout(rate = d))\\n model.add(MaxPooling1D(pool_size=k))\\n model.add(Conv1D(filters=n, kernel_size=(5), strides=1, activation = 'relu', kernel_constraint=max_norm(4)))\\n model.add(Dropout(rate = d))\\n model.add(MaxPooling1D(pool_size=k))\\n model.add(Flatten())\\n model.add(Dense(n, activation ='relu', kernel_constraint=max_norm(4)))\\n model.add(Dense(4, activation = 'softmax')) # eliminated Q label\\n model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['categorical_accuracy'])\\n return model\",\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_CNNflexi_Modular(input):\\n\\n params_3D = input['params']\\n sample_shape = input['sample_shape']\\n inputA = Input(shape=sample_shape[1:])\\n clf = params_3D['clf']\\n\\n # Model head\\n for i_layers in range(0,params_3D['n_layers']):\\n if i_layers == 0:\\n x = conv3D_block(params_3D,inputA)\\n else:\\n x = conv3D_block(params_3D, x)\\n\\n # Classifiers\\n if clf == 'dense':\\n x = Flatten()(x)\\n x = Dense(256, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\\n x = Dense(128, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\\n x = Dense(64, activation='relu', kernel_initializer='he_uniform',activity_regularizer=l1(params_3D['l1_den']))(x)\\n elif clf == 'gap':\\n x = GlobalAveragePooling3D()(x)\\n else:\\n raise('Invalid classifier choice!')\\n\\n\\n model = Model(inputs=inputA, outputs=x)\\n return model\",\n \"def build_network(self):\\n net = self.ccf_data\\n\\n # Reshape [length] -> [length, 1].\\n net = tf.expand_dims(net, -1)\\n\\n # create summary object\\n summary = []\\n\\n for i in self.hparams.conv_block_filters:\\n for _ in range(self.hparams.conv_layers_per_block):\\n input_shape = net.shape.as_list()\\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\\n activation=tf.nn.relu)\\n net = conv_op(net)\\n summary.append(\\\"Conv1D-{}-{}. Input shape: {}. Output shape: {}\\\".format(self.hparams.kernel_size, i, input_shape,\\n net.shape.as_list()))\\n pool_size = 2\\n strides = 2\\n max_pool = tf.keras.layers.MaxPool1D(pool_size=pool_size, strides=strides)\\n net = max_pool(net)\\n summary.append(\\\"MaxPool1D-{}. Pool Size: {}. Strides: {}\\\".format(self.hparams.kernel_size, pool_size, strides))\\n\\n for i in self.hparams.final_conv_num_filters:\\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\\n activation=tf.nn.relu)\\n net = conv_op(net)\\n flatten = tf.keras.layers.Flatten()\\n net = flatten(net)\\n\\n for i in self.hparams.dense_num_layers:\\n dense = tf.keras.layers.Dense(i, activation=tf.nn.relu)\\n net = dense(net)\\n\\n # output layer\\n output = tf.keras.layers.Dense(1)\\n net = tf.squeeze(output(net))\\n\\n self.summary = \\\"\\\\n\\\".join(summary)\\n self.predicted_rv = net\",\n \"def output(self,x=None,h=None,in_features=0,in_features_h=0,reuse=False):\\n assert (x is not None or h is not None)\\n print('re'*10,reuse , self.name)\\n stride=[1, self.cnn_stride, self.cnn_stride, 1]\\n with tf.variable_scope(self.name):\\n Wxi=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Wxi')\\n Whi=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Whi')\\n Wxf=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Wxf')\\n Whf=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Whf')\\n Wxc=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Wxc')\\n Whc=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Whc')\\n Wxo=self._create_weight([self.cnn_size, self.cnn_size, in_features, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Wxo')\\n Who=self._create_weight([self.cnn_size, self.cnn_size, in_features_h, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='conv_Who')\\n Wci=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='ele_Wci')\\n Wcf=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='ele_Wcf')\\n Wco=self._create_weight([1,self.height , self.width, self.out_features], stddev=self.weight_dev,\\n kname=self.weight_init, name='ele_Wco')\\n if not reuse and h is None:\\n print('xr'*20,x.get_shape().as_list(),in_features,self.out_features,in_features_h)\\n h=tf.zeros((1,self.height,self.width,self.out_features))\\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi')+self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf')+self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc')+self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo')+self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\\n else:\\n # print('x'*10,x.shape,'\\\\\\\\n Wxi',Wxi.shape,'\\\\\\\\n h ',h.shape,Whi.shape,'\\\\\\\\n c ',Wci.shape)\\n if h is None:\\n # print('x'*20,x.get_shape().as_list(),in_features,out_features)\\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi',use_bias=True)+Wci*self._cell)\\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf',use_bias=True)+Wcf*self._cell)\\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc',use_bias=True))\\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo',use_bias=True)+Wco*self._cell)\\n elif x is None:\\n # print('h'*20,h.get_shape().as_list(),in_features_h,out_features)\\n self._input=tf.sigmoid(self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\\n self._forget=tf.sigmoid(self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\\n self._output=tf.sigmoid(self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\\n else:\\n # print('xh'*20,x.get_shape().as_list(),in_features,out_features,in_features_h)\\n self._input=tf.sigmoid(self._conv2d(x,Wxi,stride=stride,pre_name='Wxi')+self._conv2d(h,Whi,use_bias=True,stride=stride,pre_name='Whi')+Wci*self._cell)\\n self._forget=tf.sigmoid(self._conv2d(x,Wxf,stride=stride,pre_name='Wxf')+self._conv2d(h,Whf,use_bias=True,stride=stride,pre_name='Whf')+Wcf*self._cell)\\n self._cell=self._forget*self._cell+self._input*tf.tanh(self._conv2d(x,Wxc,stride=stride,pre_name='Wxc')+self._conv2d(h,Whc,stride=stride,use_bias=True,pre_name='Whc'))\\n self._output=tf.sigmoid(self._conv2d(x,Wxo,stride=stride,pre_name='Wxo')+self._conv2d(h,Who,use_bias=True,stride=stride,pre_name='Who')+Wco*self._cell)\\n h=self._output*tf.tanh(self._cell)\\n\\n return h\",\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 SRCNN(input_shape, depth_multiplier=1, multi_output=False):\\n inputs = Input(input_shape, name=\\\"inputs\\\")\\n conv1 = Convolution2D(filters=64*depth_multiplier, kernel_size=9, padding=\\\"same\\\", name=\\\"conv1\\\", activation=\\\"relu\\\")(inputs)\\n #conv1 = BatchNormalization(name='bn_conv1')(conv1)\\n \\n mapping = Convolution2D(filters=32*depth_multiplier, kernel_size=1, padding=\\\"same\\\", name=\\\"mapping\\\", activation=\\\"relu\\\")(conv1)\\n #mapping = BatchNormalization(name='bn_mapping')(mapping)\\n \\n if multi_output:\\n out = Convolution2D(filters=2, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n else:\\n out = Convolution2D(filters=1, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n return Model(inputs, out)\",\n \"def __init__(self):\\n\\n super(ConvModule, self).__init__()\\n\\n self.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=5, stride=[1, 2])\\n self.conv1_bn = nn.BatchNorm2d(64)\\n self.conv2 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5, stride=[1, 2])\\n self.conv2_bn = nn.BatchNorm2d(128)\\n self.pool1 = nn.MaxPool2d(kernel_size=4, stride=2)\\n self.dropout0 = nn.Dropout(p=0.4)\\n\\n self.conv3 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=[1, 2])\\n self.conv3_bn = nn.BatchNorm2d(256)\\n self.conv4 = nn.Conv2d(in_channels=256, out_channels=64, kernel_size=3, stride=[1, 2])\\n self.conv4_bn = nn.BatchNorm2d(64)\\n self.pool2 = nn.MaxPool2d(kernel_size=4, stride=2)\\n #\\n # self.conv5 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=[1, 2])\\n # self.conv5_bn = nn.BatchNorm2d(64)\\n # self.pool3 = nn.MaxPool2d(kernel_size=3, stride=[1, 2])\",\n \"def __init__(self):\\n super(Generator, self).__init__()\\n\\n # output feature map will have the size of 8x8\\n self.first_deconv = TransitionUp(in_channels=3, out_channels=256, stride=2, padding=1, kernel_size=4)\\n self.first_batch_norm = nn.BatchNorm2d(256)\\n\\n # output feature map will have the size of 16x16\\n self.second_deconv = TransitionUp(in_channels=256, out_channels=128, stride=2, padding=1, kernel_size=4)\\n self.second_batch_norm = nn.BatchNorm2d(128)\\n\\n # output feature map will have the size of 32x32\\n self.third_deconv = TransitionUp(in_channels=128, out_channels=32, stride=2, padding=1, kernel_size=4)\\n self.third_batch_norm = nn.BatchNorm2d(32)\\n\\n # output feature map will have the size of 64x64\\n self.fourth_deconv = TransitionUp(in_channels=32, out_channels=16, stride=2, padding=1, kernel_size=4)\\n self.fourth_batch_norm = nn.BatchNorm2d(16)\\n\\n # output feature map will have the size of 128x128\\n self.fifth_deconv = TransitionUp(in_channels=16, out_channels=16, stride=1, padding=1, kernel_size=4)\\n self.fifth_batch_norm = nn.BatchNorm2d(16)\\n\\n # output feature map will have the size of 128x128\\n self.sixth_deconv = TransitionUp(in_channels=16, out_channels=16, stride=1, padding=1, kernel_size=4)\\n self.sixth_batch_norm = nn.BatchNorm2d(16)\\n\\n # output feature map will have the size of 128x128\\n self.seventh_deconv = TransitionUp(in_channels=16, out_channels=3, stride=1, padding=1, kernel_size=4)\",\n \"def c3dLSTM(self):\\n model = Sequential()\\n # 1st layer group\\n model.add(Conv3D(64, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv1',\\n subsample=(1, 1, 1),\\n input_shape=self.input_shape))\\n model.add(MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2),\\n border_mode='same', name='pool1'))\\n # 2nd layer group\\n model.add(Conv3D(128, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv2',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool2'))\\n # 3rd layer group\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(256, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv3b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool3'))\\n # 4th layer groupprint(layer.get_shape())\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv4b',\\n subsample=(1, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool4'))\\n\\n # 5th layer group\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5a',\\n subsample=(1, 1, 1)))\\n model.add(Conv3D(512, 3, 3, 3, activation='relu',\\n border_mode='same', name='conv5b',\\n subsample=(1, 1, 1)))\\n model.add(ZeroPadding3D(padding=(0, 1, 1)))\\n model.add(MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2),\\n border_mode='same', name='pool5'))\\n shaped=model.layers[13].output.get_shape()\\n print(shaped[1], shaped[2], shaped[3])\\n # model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='sigmoid', padding='same', input_shape=[self.seq_length,shaped[1],shaped[2],shaped[3]],\\n # return_sequences=True)) GlobalAveragePooling3D\\n # model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='relu', padding='valid',\\n # input_shape=[1, shaped[1], shaped[2], shaped[3]],\\n # return_sequences=True,kernel_regularizer=l2(0.1),recurrent_dropout=0.5))\\n model.add(ConvLSTM2D(512, kernel_size=(3, 3), activation='relu', padding='valid', return_sequences=True,kernel_regularizer=l2(0.1),recurrent_dropout=0.5))\\n model.add(ConvLSTM2D(640, kernel_size=(3, 3), activation='relu', padding='valid', return_sequences=True,\\n kernel_regularizer=l2(0.1), recurrent_dropout=0.5))\\n model.add(BatchNormalization())\\n model.add(Flatten())\\n #new added two dense\\n model.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.001)))\\n model.add(Dropout(0.5))\\n model.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.001)))\\n model.add(Dropout(0.5))\\n # FC layers group\\n #x = Dense(2048,activation='relu',kernel_regularizer=l2(weight_decay))(x)\\n # x = Dropout(0.5)(x)\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n\\n return model\",\n \"def SRCNNv2(input_shape, depth_multiplier=1, multi_output=False):\\n inputs = Input(input_shape, name=\\\"inputs\\\")\\n conv1 = Convolution2D(filters=64, kernel_size=9, padding=\\\"same\\\", name=\\\"conv1\\\", activation=\\\"relu\\\")(inputs)\\n conv2 = Convolution2D(filters=64, kernel_size=7, padding=\\\"same\\\", name=\\\"conv2\\\", activation=\\\"relu\\\")(conv1)\\n #conv3 = Convolution2D(filters=64, kernel_size=3, padding=\\\"same\\\", name=\\\"conv3\\\", activation=\\\"relu\\\")(conv2)\\n\\n mapping = Convolution2D(filters=32, kernel_size=5, padding=\\\"same\\\", name=\\\"mapping\\\", activation=\\\"relu\\\")(conv2)\\n #mapping2 = Convolution2D(filters=16, kernel_size=7, padding=\\\"same\\\", name=\\\"mapping2\\\", activation=\\\"relu\\\")(mapping)\\n \\n \\n if multi_output:\\n out = Convolution2D(filters=2, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n else:\\n out = Convolution2D(filters=1, kernel_size=5, padding=\\\"same\\\", name=\\\"output\\\", activation=\\\"sigmoid\\\")(mapping)\\n return Model(inputs, out)\",\n \"def compile_model(self, nb_classes, input_shape):\\n\\n # Get our network parameters.\\n number_of_layers = self.network['number_of_layers']\\n neurons_per_layer = self.network['neurons_per_layer']\\n dropout_per_layer = self.network['dropout_per_layer']\\n activation = self.network['activation']\\n optimizer = self.network['optimizer']\\n\\n model = Sequential()\\n\\n if type(neurons_per_layer) is int:\\n self.network['neurons_per_layer'] = [neurons_per_layer]\\n\\n if type(dropout_per_layer) is float:\\n self.network['dropout_per_layer'] = [dropout_per_layer]\\n\\n\\n if number_of_layers != len(self.network['neurons_per_layer']):\\n self.network['neurons_per_layer'] = correct_neurons_per_layer(self.network)\\n\\n if number_of_layers != len(self.network['dropout_per_layer']):\\n self.network['dropout_per_layer'] = correct_dropout_per_layer(self.network)\\n\\n print(\\\"number of layers: \\\" + str(number_of_layers))\\n print(\\\"neurons: \\\" + str(self.network['neurons_per_layer']) + \\\" with \\\" + activation)\\n print(\\\"dropout: \\\" + str(self.network['dropout_per_layer']))\\n\\n # Add each layer.\\n for i in range(len(self.network['neurons_per_layer'])):\\n # Need input shape for first layer.\\n if i == 0:\\n model.add(Dense(self.network['neurons_per_layer'][i], activation=activation, input_shape=input_shape))\\n else:\\n model.add(Dense(self.network['neurons_per_layer'][i], activation=activation))\\n\\n model.add(Dropout(self.network['dropout_per_layer'][i]))\\n\\n # Output layer.\\n model.add(Dense(nb_classes, activation='softmax'))\\n\\n model.compile(loss='categorical_crossentropy', optimizer=optimizer,\\n metrics=['accuracy'])\\n\\n return model\",\n \"def build_all_connected_models(feature_dim, output_scheme=\\\"regression\\\", num_classes=num_classes):\\n\\tinput_layer = keras.layers.Input(shape=[feature_dim])\\n\\thidden1 = keras.layers.Dense(800, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_layer)\\n\\t#bn1 = keras.layers.BatchNormalization()(hidden1)\\n\\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden1)\\n\\t#hidden2 = keras.layers.Dense(500, activation='relu', \\n\\t#\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t#\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\t#bn2 = keras.layers.BatchNormalization()(hidden2)\\n\\t#dropout2 = keras.layers.AlphaDropout(rate=0.5)(hidden2)\\n\\thidden3 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\tdropout3 = keras.layers.AlphaDropout(rate=0.3)(hidden3)\\n\\t# trait-specific network\\n\\thidden4_1 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_2 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_3 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_4 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\thidden4_5 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout3)\\n\\t#bn3 = keras.layers.BatchNormalization()(hidden3)\\n\\tif (output_scheme==\\\"regression\\\"):\\n\\t\\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\\n\\t\\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tout1 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden4_1)\\n\\t\\tout2 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden4_2)\\n\\t\\tout3 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden4_3)\\n\\t\\tout4 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden4_4)\\n\\t\\tout5 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden4_5)\\n\\tmodel = keras.models.Model(inputs=[input_layer],\\n\\t\\t\\t\\t\\t\\t\\t outputs=[out1, out2, out3, out4, out5])\\n\\tif (output_scheme == \\\"regression\\\"):\\n\\t\\tmodel.compile(loss=\\\"mse\\\", \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.0001),\\n\\t\\t\\t\\t\\t metrics=['mae', custom_r2_metric])\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.001))\\n\\tprint(model.summary())\\n\\treturn model\",\n \"def compile_model(self, data):\\n model=Sequential()\\n\\n model.add(Conv2D(self.conv_1_mapnum, \\n (self.filter_width, self.filter_width),\\n input_shape=data.shape[1:], \\n strides=self.strides_len,\\n padding='same', data_format='channels_last',\\n dilation_rate=1, activation=self.acti_1_func, use_bias=True, \\n kernel_initializer='glorot_uniform', bias_initializer='zeros', \\n kernel_regularizer=l2(0.001), bias_regularizer=None, \\n activity_regularizer=None, kernel_constraint=None, \\n bias_constraint=None))\\n\\n if self.batch_norm:\\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \\n center=True, scale=True, \\n beta_initializer='zeros', gamma_initializer='ones',\\n moving_mean_initializer='zeros', \\n moving_variance_initializer='ones',\\n beta_regularizer=None, gamma_regularizer=None,\\n beta_constraint=None, gamma_constraint=None))\\n\\n if self.spatial_drop:\\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\\n\\n if self.pool_method=='mean':\\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n if self.pool_method=='max':\\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n \\n model.add(Conv2D(self.conv_2_mapnum, \\n (self.filter_width, self.filter_width),\\n strides=self.strides_len,\\n padding='same', data_format='channels_last',\\n dilation_rate=1, activation=self.acti_2_func, use_bias=True, \\n kernel_initializer='glorot_uniform', bias_initializer='zeros', \\n kernel_regularizer=l2(0.001), bias_regularizer=None, \\n activity_regularizer=None, kernel_constraint=None, \\n bias_constraint=None))\\n\\n if self.batch_norm:\\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \\n center=True, scale=True, \\n beta_initializer='zeros', gamma_initializer='ones',\\n moving_mean_initializer='zeros', \\n moving_variance_initializer='ones',\\n beta_regularizer=None, gamma_regularizer=None,\\n beta_constraint=None, gamma_constraint=None))\\n\\n if self.spatial_drop:\\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\\n\\n if self.pool_method=='mean':\\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n if self.pool_method=='max':\\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n\\n model.add(Conv2D(self.conv_3_mapnum, \\n (self.filter_width, self.filter_width),\\n strides=self.strides_len,\\n padding='same', data_format='channels_last',\\n dilation_rate=1, activation=self.acti_3_func, use_bias=True, \\n kernel_initializer='glorot_uniform', bias_initializer='zeros', \\n kernel_regularizer=l2(0.001), bias_regularizer=None, \\n activity_regularizer=None, kernel_constraint=None, \\n bias_constraint=None))\\n\\n if self.batch_norm:\\n model.add(BatchNormalization(axis=3, momentum=0.99, epsilon=0.001, \\n center=True, scale=True, \\n beta_initializer='zeros', gamma_initializer='ones',\\n moving_mean_initializer='zeros', \\n moving_variance_initializer='ones',\\n beta_regularizer=None, gamma_regularizer=None,\\n beta_constraint=None, gamma_constraint=None))\\n\\n if self.spatial_drop:\\n model.add(SpatialDropout2D(rate=self.spatial_drop_perc, data_format='channels_last'))\\n\\n if self.pool_method=='mean':\\n model.add(AveragePooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n if self.pool_method=='max':\\n model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='same', \\n data_format='channels_last'))\\n \\n model.add(Flatten())\\n \\n if self.additional_dense:\\n model.add(Dense(units=self.additional_dense_units, activation=self.additional_dense_activation))\\n\\n if self.batch_norm:\\n model.add(BatchNormalization(axis=1, momentum=0.99, epsilon=0.001, \\n center=True, scale=True, \\n beta_initializer='zeros', gamma_initializer='ones',\\n moving_mean_initializer='zeros', \\n moving_variance_initializer='ones',\\n beta_regularizer=None, gamma_regularizer=None,\\n beta_constraint=None, gamma_constraint=None))\\n if self.spatial_drop:\\n model.add(Dropout(rate=self.spatial_drop_perc))\\n \\n model.add(Dense(units=self.denseshape, activation=self.output_activation))\\n\\n model.compile(optimizer=Adam(lr=self.learning_rate), loss=self.loss_func, metrics=['accuracy', 'mean_squared_error', 'mean_absolute_error'])\\n print(model.summary())\\n return model\",\n \"def mgcNetArchCommonCnn(outLayer, l2_val, **kwargs):\\n def_vals = {\\\"input_img_rows\\\" : 72,\\n \\\"input_img_cols\\\" : 72,\\n \\\"channels\\\" : 1,\\n \\\"nb_classes\\\" : 13\\n } # default parameters value\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n input_img_rows = kwargs['input_img_rows']\\n input_img_cols = kwargs['input_img_cols']\\n channels = kwargs['channels']\\n nb_classes = kwargs['nb_classes']\\n\\n \\n # Input: 72 x 72 x 1\\n img_shape = layers.Input(shape = (input_img_rows, input_img_cols, channels))\\n\\n # Layer 1\\n #------------------------\\n conv1 = layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(img_shape)\\n conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)\\n\\n # Layer 2\\n #------------------------\\n conv2 = layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu')(conv1)\\n conv2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)\\n\\n # FC Layer\\n #------------------------\\n out = layers.Flatten()(conv2)\\n out = layers.Dropout(0.5)(out)\\n out = layers.Dense(nb_classes, activation='softmax')(out)\\n \\n # prediction model\\n model = Model(img_shape, out, name = 'common_cnn')\\n\\n return model\",\n \"def get_model(summary=False):\\n\\timage_input=Input(shape=(220,220,5),name='image_input')\\n\\tbranch1_conv1=Conv2D(64, kernel_size=(3, 3), border_mode='same', input_shape=(220,220,5), activation='relu')(image_input)\\n\\tbranch1_conv2=Conv2D(64, kernel_size=(1, 1), border_mode='same', activation='relu')(branch1_conv1)\\t\\n\\tbranch1_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch1_conv1)\\n\\tbranch2_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch1_pool1)\\n\\tbranch2_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch2_conv1)\\t\\n\\tbranch2_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch2_conv2)\\n\\tbranch3_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch2_pool1)\\n\\tbranch3_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch3_conv1)\\t\\n\\tbranch3_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch3_conv2)\\n\\tbranch4_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch3_pool1)\\n\\tbranch4_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch4_conv1)\\t\\n\\tbranch4_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch4_conv2)\\n\\tbranch5_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch4_pool1)\\n\\tbranch5_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch5_conv1)\\t\\n\\tbranch5_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch5_conv2)\\n\\tbranch6_conv1=Conv2D(128, kernel_size=(3, 3), border_mode='same', activation='relu')(branch5_pool1)\\n\\tbranch6_conv2=Conv2D(128, kernel_size=(1, 1), border_mode='same', activation='relu')(branch6_conv1)\\t\\n\\tbranch6_pool1=MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(branch6_conv2)\\n\\tbranch1_flat=Flatten()(branch6_pool1)\\n\\tdrop=Dropout(.3)(branch1_flat)\\n\\t# FC layers group\\n\\tdense1=Dense(512, activation='relu', name='fc1')(drop)\\n\\tdrop1=Dropout(.3)(dense1)\\n\\tdense2=Dense(256, activation='relu', name='fc2')(drop1)\\n\\tdrop3=Dropout(.3)(dense2)\\n\\tout=Dense(2, activation='softmax', name='fc4')(drop3)\\n\\tmodel=Model(inputs=image_input,outputs=out)\\n\\treturn model\",\n \"def build_model(self):\\n self.G = Generator(self.g_conv_dim)\\n self.D = Discriminator(self.d_conv_dim, self.c_dim)\\n self.generator = Generator(self.g_conv_dim).train(False)\\n\\n self.G = nn.DataParallel(self.G)\\n self.D = nn.DataParallel(self.D)\\n\\n # For Adam (Unofficial)\\n # self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr, [self.beta1, self.beta2])\\n # self.d_optimizer = torch.optim.Adam(self.D.parameters(), self.d_lr, [self.beta1, self.beta2])\\n\\n # For RMSprop(Official)\\n self.g_optimizer = torch.optim.RMSprop(self.G.parameters(), lr=0.0001)\\n self.d_optimizer = torch.optim.RMSprop(self.D.parameters(), lr=0.0001)\\n\\n self.accumulate(self.generator, self.G.module, 0)\\n # self.print_network(self.G, 'G')\\n # self.print_network(self.D, 'D')\\n \\n self.G.to(self.device)\\n self.D.to(self.device)\\n self.generator.to(self.device)\\n\\n # weight init\\n self.G.apply(self.weights_init)\\n self.D.apply(self.weights_init)\\n self.generator.apply(self.weights_init)\",\n \"def build_mlp(input_, config):\\n current_input = input_\\n print(current_input)\\n for i in range(len(config['fcc_layers']) - 1):\\n current_input = tf.keras.layers.Dense(\\n units=config['fcc_layers'][i], activation='tanh',\\n name='fcc_layer_{}'.format(i + 1))(current_input)\\n current_input = tf.keras.layers.Dropout(\\n rate=config['dropout'], name='dropout_{}'.format(i + 1))(current_input)\\n cascade_embedding_layer = tf.keras.layers.Dense(\\n units=config['fcc_layers'][-1], activation='tanh',\\n name='cascade_embedding_layer')(current_input)\\n cascade_embedding_layer_do = tf.keras.layers.Dropout(\\n rate=config['dropout'],\\n name='cascade_embedding_dropout')(cascade_embedding_layer)\\n prediction_layer = tf.keras.layers.Dense(\\n units=1, activation='sigmoid',\\n name='prediction_layer')(cascade_embedding_layer_do)\\n return cascade_embedding_layer, prediction_layer\",\n \"def build(self, input_shape):\\n self.embedding = layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN)\\n self.conv_1 = layers.Conv1D(16, kernel_size=5, name=\\\"conv_1\\\", activation=\\\"relu\\\")\\n self.pool_1 = layers.MaxPool1D(name=\\\"pool_1\\\")\\n self.conv_2 = layers.Conv1D(\\n 128, kernel_size=2, name=\\\"conv_2\\\", activation=\\\"relu\\\"\\n )\\n self.pool_2 = layers.MaxPool1D(name=\\\"pool_2\\\")\\n self.flatten = layers.Flatten()\\n self.dense = layers.Dense(1, activation=\\\"sigmoid\\\")\\n super(CnnModel, self).build(input_shape)\",\n \"def compile_model(network, nb_classes, input_shape):\\r\\n nb_layers = network['nb_layers']\\r\\n layer = network['layer']\\r\\n nb_neurons = network['nb_neurons']\\r\\n activation = network['activation']\\r\\n optimizer = network['optimizer']\\r\\n\\r\\n model = Sequential()\\r\\n\\r\\n for i in range(nb_layers):\\r\\n if i == 0:\\r\\n model.add(Conv2D(nb_neurons, activation=activation, input_shape=input_shape))\\r\\n else:\\r\\n model.add(layer(nb_neurons, activation=activation))\\r\\n \\r\\n model.add(Dropout(0.2))\\r\\n\\r\\n model.add(Dense(nb_classes, activation='softmax'))\\r\\n\\r\\n model.compile(loss='categorical_crossentropy', optimizer=optimizer,metrics=['accuracy'])\\r\\n\\r\\n return model\",\n \"def CNN_model():\\n prob = 0.1\\n model = Sequential()\\n # model.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same',\\n # activation ='relu', input_shape = (28,28,1)))\\n # model.add(Conv2D(filters = 64, kernel_size = (5,5),padding = 'Same',\\n # activation ='relu'))\\n # model.add(BatchNormalization())\\n # model.add(MaxPooling2D(pool_size=(2,2)))\\n # model.add(Dropout(0.25))\\n\\n # model.add(Flatten())\\n model.add(Dense(512, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n\\n model.add(Dense(1024, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(2048, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(2048, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(4096, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(2048, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(2048, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n model.add(Dense(1024, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n\\n # model.add(Dense(2048, activation = \\\"relu\\\"))\\n # model.add(Dropout(prob))\\n #\\n # model.add(Dense(2048, activation = \\\"relu\\\"))\\n # model.add(Dropout(prob))\\n\\n model.add(Dense(1024, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n\\n # model.add(BatchNormalization())\\n model.add(Dense(512, activation = \\\"relu\\\"))\\n model.add(Dropout(prob))\\n # model.add(BatchNormalization())\\n # model.add(Dropout(0.5))\\n model.add(Dense(2, activation = \\\"softmax\\\"))\\n\\n return model\",\n \"def _build(self, input_var, name=None):\\n out = input_var\\n for model in self._models:\\n self._last_network = model.build(out, name=name)\\n if self._first_network is None:\\n self._first_network = self._last_network\\n out = self._last_network.outputs\\n\\n return out\",\n \"def build_model(num_classes=43):\\n model = models.Sequential()\\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.Conv2D(64, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.MaxPooling2D((2, 2)))\\n\\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.Conv2D(128, (3, 3), activation='relu',\\n input_shape=(32, 32, 3)))\\n model.add(layers.MaxPooling2D((2, 2)))\\n \\n\\n model.add(layers.Flatten())\\n model.add(layers.Dense(num_classes, activation='softmax'))\\n model.summary()\\n\\n return model\",\n \"def _reshape_output_batch(self, number, output):\\n #tt = cutotime('reshape')\\n #tt.start()\\n output = output.reshape(self.output_shapes[number]) # batch, h, w, 3, (5 + 80)\\n #tt.stop()\\n return output\",\n \"def make_layer(self, out_channels, num_blocks, first_block=False):\\n layers = []\\n for i in range(num_blocks):\\n first_block = first_block if i == 0 else False\\n combine_mode = 'concat' if i == 0 else 'add'\\n layers.append(ShuffleUnit(self.in_channels, out_channels, groups=self.groups, first_block=first_block, combine=combine_mode, conv_cfg=self.conv_cfg, norm_cfg=self.norm_cfg, act_cfg=self.act_cfg, with_cp=self.with_cp))\\n self.in_channels = out_channels\\n return nn.Sequential(*layers)\",\n \"def _init_predictor(self):\\n self.conv_cls_prev = self._init_branch(\\n conv_channels=self.cls_branch,\\n conv_strides=(1, ) * len(self.cls_branch))\\n self.conv_cls = nn.Conv2d(self.cls_branch[-1], self.cls_out_channels,\\n 1)\\n # init regression head\\n self.conv_reg_prevs = nn.ModuleList()\\n # init output head\\n self.conv_regs = nn.ModuleList()\\n # group_reg_dims:\\n # ((4, ), (2, ), (20, ), (3, ), (3, ), (8, 8), (1, ), (1, ))\\n for i in range(len(self.group_reg_dims)):\\n reg_dims = self.group_reg_dims[i]\\n reg_branch_channels = self.reg_branch[i]\\n out_channel = self.out_channels[i]\\n reg_list = nn.ModuleList()\\n if len(reg_branch_channels) > 0:\\n self.conv_reg_prevs.append(\\n self._init_branch(\\n conv_channels=reg_branch_channels,\\n conv_strides=(1, ) * len(reg_branch_channels)))\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(out_channel, reg_dim, 1))\\n self.conv_regs.append(reg_list)\\n else:\\n self.conv_reg_prevs.append(None)\\n for reg_dim in reg_dims:\\n reg_list.append(nn.Conv2d(self.feat_channels, reg_dim, 1))\\n self.conv_regs.append(reg_list)\",\n \"def addExportLayerToCoreml(builder):\\n outputNames = [output.name for output in builder.spec.description.output]\\n\\n for i, outputName in enumerate(outputNames):\\n # formulas: https://github.com/ultralytics/yolov5/issues/471\\n builder.add_activation(\\n name=f\\\"sigmoid_{outputName}\\\",\\n non_linearity=\\\"SIGMOID\\\",\\n input_name=outputName,\\n output_name=f\\\"{outputName}_sigmoid\\\",\\n )\\n\\n ### Coordinates calculation ###\\n # input (1, 3, nC, nC, 85), output (1, 3, nC, nC, 2) -> nC = 640 / strides[i]\\n builder.add_slice(\\n name=f\\\"slice_coordinates_xy_{outputName}\\\",\\n input_name=f\\\"{outputName}_sigmoid\\\",\\n output_name=f\\\"{outputName}_sliced_coordinates_xy\\\",\\n axis=\\\"width\\\",\\n start_index=0,\\n end_index=2,\\n )\\n # x,y * 2\\n builder.add_elementwise(\\n name=f\\\"multiply_xy_by_two_{outputName}\\\",\\n input_names=[f\\\"{outputName}_sliced_coordinates_xy\\\"],\\n output_name=f\\\"{outputName}_multiplied_xy_by_two\\\",\\n mode=\\\"MULTIPLY\\\",\\n alpha=2,\\n )\\n # x,y * 2 - 0.5\\n builder.add_elementwise(\\n name=f\\\"subtract_0_5_from_xy_{outputName}\\\",\\n input_names=[f\\\"{outputName}_multiplied_xy_by_two\\\"],\\n output_name=f\\\"{outputName}_subtracted_0_5_from_xy\\\",\\n mode=\\\"ADD\\\",\\n alpha=-0.5,\\n )\\n grid = make_grid(featureMapDimensions[i], featureMapDimensions[i]).numpy()\\n # x,y * 2 - 0.5 + grid[i]\\n builder.add_bias(\\n name=f\\\"add_grid_from_xy_{outputName}\\\",\\n input_name=f\\\"{outputName}_subtracted_0_5_from_xy\\\",\\n output_name=f\\\"{outputName}_added_grid_xy\\\",\\n b=grid,\\n shape_bias=grid.shape,\\n )\\n # (x,y * 2 - 0.5 + grid[i]) * stride[i]\\n builder.add_elementwise(\\n name=f\\\"multiply_xy_by_stride_{outputName}\\\",\\n input_names=[f\\\"{outputName}_added_grid_xy\\\"],\\n output_name=f\\\"{outputName}_calculated_xy\\\",\\n mode=\\\"MULTIPLY\\\",\\n alpha=strides[i],\\n )\\n\\n # input (1, 3, nC, nC, 85), output (1, 3, nC, nC, 2)\\n builder.add_slice(\\n name=f\\\"slice_coordinates_wh_{outputName}\\\",\\n input_name=f\\\"{outputName}_sigmoid\\\",\\n output_name=f\\\"{outputName}_sliced_coordinates_wh\\\",\\n axis=\\\"width\\\",\\n start_index=2,\\n end_index=4,\\n )\\n # w,h * 2\\n builder.add_elementwise(\\n name=f\\\"multiply_wh_by_two_{outputName}\\\",\\n input_names=[f\\\"{outputName}_sliced_coordinates_wh\\\"],\\n output_name=f\\\"{outputName}_multiplied_wh_by_two\\\",\\n mode=\\\"MULTIPLY\\\",\\n alpha=2,\\n )\\n # (w,h * 2) ** 2\\n builder.add_unary(\\n name=f\\\"power_wh_{outputName}\\\",\\n input_name=f\\\"{outputName}_multiplied_wh_by_two\\\",\\n output_name=f\\\"{outputName}_power_wh\\\",\\n mode=\\\"power\\\",\\n alpha=2,\\n )\\n # (w,h * 2) ** 2 * anchor_grid[i]\\n anchor = (\\n anchorGrid[i]\\n .expand(-1, featureMapDimensions[i], featureMapDimensions[i], -1)\\n .numpy()\\n )\\n builder.add_load_constant_nd(\\n name=f\\\"anchors_{outputName}\\\",\\n output_name=f\\\"{outputName}_anchors\\\",\\n constant_value=anchor,\\n shape=anchor.shape,\\n )\\n builder.add_elementwise(\\n name=f\\\"multiply_wh_with_achors_{outputName}\\\",\\n input_names=[f\\\"{outputName}_power_wh\\\", f\\\"{outputName}_anchors\\\"],\\n output_name=f\\\"{outputName}_calculated_wh\\\",\\n mode=\\\"MULTIPLY\\\",\\n )\\n\\n builder.add_concat_nd(\\n name=f\\\"concat_coordinates_{outputName}\\\",\\n input_names=[f\\\"{outputName}_calculated_xy\\\", f\\\"{outputName}_calculated_wh\\\"],\\n output_name=f\\\"{outputName}_raw_coordinates\\\",\\n axis=-1,\\n )\\n builder.add_scale(\\n name=f\\\"normalize_coordinates_{outputName}\\\",\\n input_name=f\\\"{outputName}_raw_coordinates\\\",\\n output_name=f\\\"{outputName}_raw_normalized_coordinates\\\",\\n W=torch.tensor([1 / 640]).numpy(),\\n b=0,\\n has_bias=False,\\n )\\n\\n ### Confidence calculation ###\\n builder.add_slice(\\n name=f\\\"slice_object_confidence_{outputName}\\\",\\n input_name=f\\\"{outputName}_sigmoid\\\",\\n output_name=f\\\"{outputName}_object_confidence\\\",\\n axis=\\\"width\\\",\\n start_index=4,\\n end_index=5,\\n )\\n builder.add_slice(\\n name=f\\\"slice_label_confidence_{outputName}\\\",\\n input_name=f\\\"{outputName}_sigmoid\\\",\\n output_name=f\\\"{outputName}_label_confidence\\\",\\n axis=\\\"width\\\",\\n start_index=5,\\n end_index=0,\\n )\\n # confidence = object_confidence * label_confidence\\n builder.add_multiply_broadcastable(\\n name=f\\\"multiply_object_label_confidence_{outputName}\\\",\\n input_names=[\\n f\\\"{outputName}_label_confidence\\\",\\n f\\\"{outputName}_object_confidence\\\",\\n ],\\n output_name=f\\\"{outputName}_raw_confidence\\\",\\n )\\n\\n # input: (1, 3, nC, nC, 85), output: (3 * nc^2, 85)\\n builder.add_flatten_to_2d(\\n name=f\\\"flatten_confidence_{outputName}\\\",\\n input_name=f\\\"{outputName}_raw_confidence\\\",\\n output_name=f\\\"{outputName}_flatten_raw_confidence\\\",\\n axis=-1,\\n )\\n builder.add_flatten_to_2d(\\n name=f\\\"flatten_coordinates_{outputName}\\\",\\n input_name=f\\\"{outputName}_raw_normalized_coordinates\\\",\\n output_name=f\\\"{outputName}_flatten_raw_coordinates\\\",\\n axis=-1,\\n )\\n\\n builder.add_concat_nd(\\n name=\\\"concat_confidence\\\",\\n input_names=[\\n f\\\"{outputName}_flatten_raw_confidence\\\" for outputName in outputNames\\n ],\\n output_name=\\\"raw_confidence\\\",\\n axis=-2,\\n )\\n builder.add_concat_nd(\\n name=\\\"concat_coordinates\\\",\\n input_names=[\\n f\\\"{outputName}_flatten_raw_coordinates\\\" for outputName in outputNames\\n ],\\n output_name=\\\"raw_coordinates\\\",\\n axis=-2,\\n )\\n\\n builder.set_output(\\n output_names=[\\\"raw_confidence\\\", \\\"raw_coordinates\\\"],\\n output_dims=[(25200, numberOfClassLabels), (25200, 4)],\\n )\",\n \"def model(self, input_shape=(3, 224, 224), nclasses=3):\\n inputs = Input(input_shape)\\n\\n pad1_1 = ZeroPadding2D(padding=(1, 1))(inputs)\\n conv1_1 = Conv2D(64, 3, 3, activation='relu', name='conv1_1')(pad1_1)\\n pad1_2 = ZeroPadding2D(padding=(1, 1))(conv1_1)\\n conv1_2 = Conv2D(64, 3, 3, activation='relu', name='conv1_2')(pad1_2)\\n pool1 = MaxPooling2D((2, 2), strides=(2, 2))(conv1_2)\\n\\n pad2_1 = ZeroPadding2D((1, 1))(pool1)\\n conv2_1 = Conv2D(128, 3, 3, activation='relu', name='conv2_1')(pad2_1)\\n pad2_2 = ZeroPadding2D((1, 1))(conv2_1)\\n conv2_2 = Conv2D(128, 3, 3, activation='relu', name='conv2_2')(pad2_2)\\n pool2 = MaxPooling2D((2, 2), strides=(2, 2))(conv2_2)\\n\\n pad3_1 = ZeroPadding2D((1, 1))(pool2)\\n conv3_1 = Conv2D(256, 3, 3, activation='relu', name='conv3_1')(pad3_1)\\n pad3_2 = ZeroPadding2D((1, 1))(conv3_1)\\n conv3_2 = Conv2D(256, 3, 3, activation='relu', name='conv3_2')(pad3_2)\\n pad3_3 = ZeroPadding2D((1, 1))(conv3_2)\\n conv3_3 = Conv2D(256, 3, 3, activation='relu', name='conv3_3')(pad3_3)\\n pool3 = MaxPooling2D((2, 2), strides=(2, 2))(conv3_3)\\n\\n pad4_1 = ZeroPadding2D((1, 1))(pool3)\\n conv4_1 = Conv2D(512, 3, 3, activation='relu', name='conv4_1')(pad4_1)\\n pad4_2 = ZeroPadding2D((1, 1))(conv4_1)\\n conv4_2 = Conv2D(512, 3, 3, activation='relu', name='conv4_2')(pad4_2)\\n pad4_3 = ZeroPadding2D((1, 1))(conv4_2)\\n conv4_3 = Conv2D(512, 3, 3, activation='relu', name='conv4_3')(pad4_3)\\n pool4 = MaxPooling2D((2, 2), strides=(2, 2))(conv4_3)\\n\\n pad5_1 = ZeroPadding2D((1, 1))(pool4)\\n conv5_1 = Conv2D(512, 3, 3, activation='relu', name='conv5_1')(pad5_1)\\n pad5_2 = ZeroPadding2D((1, 1))(conv5_1)\\n conv5_2 = Conv2D(512, 3, 3, activation='relu', name='conv5_2')(pad5_2)\\n pad5_3 = ZeroPadding2D((1, 1))(conv5_2)\\n conv5_3 = Conv2D(512, 3, 3, activation='relu', name='conv5_3')(pad5_3)\\n pool5 = MaxPooling2D((2, 2), strides=(2, 2))(conv5_3)\\n\\n # fc5 = base_model.layers[-8].output\\n fc6 = Flatten()(pool5)\\n fc7_1 = Dense(256, activation='relu', name='fc7_1')(fc6)\\n dropout7_1 = Dropout(0.3, name='dropout7_1')(fc7_1)\\n fc7_2 = Dense(128, activation='relu', name='fc7_2')(dropout7_1)\\n # dropout7_2 = Dropout(0.2, name='dropout7_2')(fc7_2)\\n # fc7_3 = Dense(128, activation=\\\"relu\\\", name=\\\"fc7_pre3\\\")(dropout7_2)\\n prediction = Dense(nclasses, activation='softmax')(fc7_2)\\n model = Model(inputs, prediction)\\n model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\\n # model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n return model\",\n \"def genModel():\\n inp = (160, 320, 3) # initial image size\\n oup1 = (160, 320, 1) # gray image size\\n oup2 = (80, 320, 1) # cropped image size\\n\\n model = Sequential()\\n model.add(Lambda(color2gray, input_shape = inp, output_shape= oup1))\\n # crop top 50 pixels, bottom 30 pixels, left/right 0 pixels\\n model.add(Cropping2D(cropping=((50,30), (0,0))))\\n # Preprocess incoming data, centered around zero with small standard deviation \\n model.add(Lambda(lambda x: x/127.5 - 1., output_shape= oup2))\\n model.add(Convolution2D(24,5,5,subsample=(1,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(36,5,5,subsample=(2,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(48,5,5,subsample=(2,2), activation=\\\"relu\\\"))\\n model.add(Convolution2D(64,3,3, activation=\\\"relu\\\"))\\n model.add(Convolution2D(64,3,3, activation=\\\"relu\\\"))\\n model.add(Flatten())\\n model.add(Dropout(0.3))\\n model.add(Dense(180, activation=\\\"relu\\\"))\\n model.add(Dense(60))\\n model.add(Dense(10, activation=\\\"relu\\\"))\\n model.add(Dense(1))\\n # print layer size for each model layers\\n for layer in model.layers:\\n print(layer.get_output_at(0).get_shape().as_list())\\n return model\",\n \"def __init__(self, ):\\n super().__init__()\\n channels = 3\\n\\n # Initial convolution block\\n out_features = 64\\n # encoder\\n self.input = nn.Sequential(\\n nn.ReflectionPad2d(channels),\\n nn.Conv2d(3, out_features, (7, 7)),\\n nn.InstanceNorm2d(out_features),\\n nn.MaxPool2d(2),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.Conv2d(out_features, out_features * 2, (3, 3), stride=(1, 1), padding=(1, 1)),\\n nn.LeakyReLU(0.2, inplace=True),\\n nn.MaxPool2d(2),\\n nn.Conv2d(out_features * 2, out_features * 4, (3, 3), stride=(1, 1), padding=(1, 1)),\\n nn.LeakyReLU(0.2, inplace=True),\\n )\\n\\n self.in0 = nn.InstanceNorm2d(256)\\n self.block0 = blocks()\\n self.block1 = blocks()\\n self.block2 = blocks()\\n self.block3 = blocks()\\n self.block4 = blocks()\\n self.block5 = blocks()\\n self.block6 = blocks()\\n self.block7 = blocks()\\n\\n self.out = nn.Sequential(\\n\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(out_features * 4, out_features * 2, 3, stride=1, padding=1),\\n nn.InstanceNorm2d(out_features * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n nn.Upsample(scale_factor=2),\\n nn.Conv2d(out_features * 2, out_features, 3, stride=1, padding=1),\\n nn.InstanceNorm2d(out_features),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n nn.ReflectionPad2d(channels),\\n nn.Conv2d(out_features, channels, 7),\\n nn.Tanh(),\\n )\",\n \"def define(self, optimizer = Adam(lr=1e-5)): \\n \\n self.optimizer = optimizer\\n\\n model = Sequential()\\n\\n #Layer 1\\n model.add(Conv2D( filters = 96, \\n kernel_size = (11,11), \\n strides = 4, \\n padding = 'same', \\n activation = 'relu', \\n input_shape = (224, 224, 3), \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) # overlapping pooling\\n #Layer 2\\n model.add(Conv2D( filters = 256, \\n kernel_size = (5,5), \\n strides = 1, \\n padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None)) \\n #Layer 3\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', kernel_initializer = 'he_normal'))\\n #Layer 4\\n model.add(Conv2D( filters = 384, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 5\\n model.add(Conv2D( filters = 256, \\n kernel_size = (3,3), \\n strides = 1, padding = 'same', \\n activation = 'relu', \\n kernel_initializer = 'he_normal'))\\n #Layer 6\\n model.add(MaxPooling2D( pool_size = (3,3), \\n strides = (2,2), \\n padding= 'same', \\n data_format = None))\\n \\n #Layer 7\\n model.add(Flatten())\\n \\n #Layer 8\\n model.add(Dense( units = 4096, activation = 'relu'))\\n model.add(Dense( units = 1024, activation = 'relu'))\\n model.add(Dense( units = 512, activation = 'relu'))\\n model.add(Dense( units = 256, activation = 'relu'))\\n model.add(Dense( units = 128, activation = 'relu'))\\n \\n #Layer end\\n model.add(Dense( units = 3, activation = 'softmax'))\\n model.summary()\\n \\n self.model = model\",\n \"def _make_conv_layers(self):\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def _build(self, *args, **kwargs):\\n num_targets = self.get('num_targets', self.config)\\n dropout_rate = self.get('dropout_rate', self.config)\\n input_shape = self.get('input_shape', self.config)\\n\\n inputs = Input(shape=input_shape)\\n block_A = self.reduction_block_I(inputs, 32, scope='Block_A')\\n block_B = self.reduction_block_I(block_A, 64, scope='Block_B')\\n block_C = self.reduction_block_II(block_B, 128, scope='Block_C')\\n block_D = self.reduction_block_II(block_C, 256, scope='Block_D')\\n block_E = self.reduction_block_II(block_D, 256, scope='Block_E')\\n\\n z = self.dense_block(block_E, units=self.get('units', self.config),\\n dropout=dropout_rate, scope='DenseBlock-I')\\n\\n output_tensor = Dense(num_targets, activation='sigmoid', name='output')(z)\\n\\n return [inputs], [output_tensor]\",\n \"def forward(self, inputs):\\n # inputs is (batch, slen)\\n x = self.embed(inputs) # x is (batch, seq, dim_e)\\n x = x.transpose(1, 2) # x is (batch, dim_e, slen)\\n # because conv1d requires (batch, channels_in=dim_e, slen)\\n # to produce an output (batch, channels_out, slen - k + 1)\\n # we then pool1d (kernel=slen-k) over the output of conv1d\\n # since 1d works along time (i.e. sequence) this means\\n # we get (batch, channels_out=cshannels_outs_k, 1) which we squeeze\\n conv_blocks_out = [self.conv_blocks[n](x).squeeze(-1)\\n for n in range(self.nk)]\\n # and finally we concatenate all our conv1ds with different kernel\\n # sizes together to get (batch, sum_k(channels_outs_k))\\n # i.e. we concat the channels_out (i.e. featutres)\\n x = torch.cat(conv_blocks_out, dim=1)\\n\\n # and do some dropout\\n x = self.dropout(x)\\n\\n # squeeze into hidden\\n if self.hidden_size > 0:\\n x = self.fc(x)\\n x = self.dropout2(x)\\n x = self.fc_act(x)\\n\\n # map to classes and return\\n x = self.output(x)\\n return x\",\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 forward(self, inputs):\\n x, meta = inputs\\n features = self.arch(x)\\n if self.n_meta_features:\\n meta_features = self.meta(meta)\\n features = torch.cat((cnn_features, meta_features), dim=1)\\n return self.ouput(features)\",\n \"def __init__(\\n self,\\n num_frames = 2,\\n dim = 64,\\n channels = 3,\\n stages = 4,\\n num_blocks = 2,\\n dim_head = 64,\\n window_size = 16,\\n heads = 8,\\n ff_mult = 4,\\n input_channels = None,\\n output_channels = None,\\n device = None,\\n skip_type = 'ConcatCross'\\n ):\\n super().__init__()\\n input_channels = channels if input_channels is None else input_channels\\n output_channels = channels if output_channels is None else output_channels\\n\\n self.project_in = nn.Sequential(\\n nn.Conv3d(input_channels, dim, kernel_size = (1, 3, 3), padding = (0, 1, 1)),\\n nn.GELU()\\n )\\n\\n self.project_out = nn.Sequential(\\n nn.Conv3d(dim, output_channels, kernel_size = (1, 3, 3), padding = (0, 1, 1))\\n )\\n\\n self.downs = nn.ModuleList([])\\n self.ups = nn.ModuleList([])\\n\\n # render each hyperparam a tuple so that we can iterate thru them\\n heads, window_size, dim_head, num_blocks = map(partial(cast_tuple, depth = stages), (heads, window_size, dim_head, num_blocks))\\n\\n for ind, heads, window_size, dim_head, num_blocks in zip(range(stages), heads, window_size, dim_head, num_blocks):\\n is_last = ind == (stages - 1)\\n\\n self.downs.append(nn.ModuleList([ # need 3d version of this\\n Block(dim, depth = num_blocks, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size, device = device),\\n nn.Conv3d(dim, dim * 2, kernel_size = (1, 4, 4), stride = (1, 2, 2), padding = (0, 1, 1))\\n ]))\\n\\n self.ups.append(nn.ModuleList([\\n nn.ConvTranspose3d(dim * 2, dim, (1, 2, 2), stride = (1, 2, 2)),\\n Block(dim, depth = num_blocks, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size, device = device, skip_type = skip_type)\\n ]))\\n\\n dim *= 2\\n if is_last:\\n self.mid = nn.Sequential(\\n Rearrange('b c f h w -> b (c f) 1 h w'),\\n Block(dim = dim*num_frames, depth = 1, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size),\\n nn.Conv3d(dim*num_frames, dim, kernel_size = (1, 3, 3), padding = (0, 1, 1)),\\n Block(dim = dim, depth = 2, dim_head = dim_head, heads = heads, ff_mult = ff_mult, window_size = window_size),\\n )\",\n \"def build_model(self):\\n\\n input_placeholder = Input(shape = self.input_shape)\\n x = ZeroPadding2D((3, 3))(input_placeholder)\\n\\n # Stage 1\\n x = self.main_path_block(x, 64, (7, 7), 'valid', 'conv1', 'bn_conv1', 'relu', (2, 2))\\n x = MaxPooling2D((3, 3), strides = (2, 2))(x)\\n\\n # Stage 2\\n x = self.convolutional_block(x, 3, [64, 64, 256], 2, 'a', 1)\\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'b')\\n x = self.identity_block(x, 3, [64, 64, 256], 2, 'c')\\n\\n # Stage 3\\n x = self.convolutional_block(x, 3, [128, 128, 512], 3, 'a', 2)\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'b')\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'c')\\n x = self.identity_block(x, 3, [128, 128, 512], 3, 'd')\\n\\n # Stage 4\\n x = self.convolutional_block(x, 3, [256, 256, 1024], 4, 'a', 2)\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'b')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'c')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'd')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'e')\\n x = self.identity_block(x, 3, [256, 256, 1024], 4, 'f')\\n\\n # Stage 5\\n x = self.convolutional_block(x, 3, [512, 512, 2048], 5, 'a', 2)\\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'b')\\n x = self.identity_block(x, 3, [512, 512, 2048], 5, 'c')\\n \\n # Average Pooling Layer\\n x = AveragePooling2D((2, 2), name = 'avg_pool')(x)\\n \\n # Fully Connected Layer\\n x = Flatten()(x)\\n x = Dense(\\n self.classes,\\n activation = 'softmax',\\n name = 'fc_' + str(self.classes),\\n kernel_initializer = glorot_uniform(seed = 0)\\n )(x)\\n\\n self.model = Model(input_placeholder, x, name = 'Resnet50')\",\n \"def __init__(self):\\n self.model = Sequential()\\n self.model.add(AveragePooling2D(pool_size=(4, 4), input_shape=(224, 224, 3)))\\n self.model.add(Conv2D(16, (9, 9)))\\n self.model.add(Activation('relu'))\\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\\n self.model.add(Conv2D(16, (5, 5)))\\n self.model.add(Activation('relu'))\\n self.model.add(MaxPooling2D(pool_size=(2, 2)))\\n self.model.add(Flatten())\\n self.model.add(Dropout(0.5))\\n self.model.add(Dense(1, activation='sigmoid'))\\n self.model.compile(loss=binary_crossentropy,\\n optimizer=keras.optimizers.Adadelta(),\\n metrics=['accuracy'])\",\n \"def sub_model_net(self):\\r\\n # define input\\r\\n x = keras.Input(shape=(960,), name='input')\\r\\n fc_2 = keras.layers.Dense(160, name='fc_2')(x)\\r\\n add_1 = keras.layers.Activation('relu')(fc_2)\\r\\n drop = keras.layers.Dropout(0.5)\\r\\n # output\\r\\n y_hat = keras.layers.Dense(1283, activation='softmax', name='output')(add_1)\\r\\n model = keras.Model(inputs=x, outputs=y_hat)\\r\\n\\r\\n return model\",\n \"def build(self, hp):\\n\\n model = Sequential()\\n model.add(Conv2D(filters=hp.Choice('num_filters_0', values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_0', values=[3, 4, 5]),\\n activation=hp.Choice('activation_0', values=['relu', 'tanh']),\\n input_shape=self.input_shape))\\n\\n for i in range(hp.Int('num_layers', 1, 3)):\\n model.add(Conv2D(filters=hp.Choice('num_filters_%d' % (i + 1), values=[8, 16, 32, 64]),\\n kernel_size=hp.Choice('kernel_size_%d' % (i + 1), values=[3, 4, 5]),\\n activation=hp.Choice('activation_%d' % (i + 1), values=['relu', 'tanh'])))\\n model.add(Flatten())\\n model.add(Dense(N_zern))\\n model.summary()\\n\\n model.compile(optimizer=keras.optimizers.Adam(hp.Choice('learning_rate', values=[1e-3, 5e-4, 1e-4])),\\n loss='mean_squared_error')\\n return model\",\n \"def output(self, input, in_features, out_features,reuse=False):\\n # with tf.variable_scope(self.name):\\n # print('f'*20,input.get_shape().as_list(),in_features,out_features)\\n w=self._create_weight([self.cnn_size,self.cnn_size,in_features,out_features],name='Wfn')\\n out=self._conv2d(input,w,[1, self.cnn_stride, self.cnn_stride, 1],pre_name='convfn')\\n return out\",\n \"def modelbuilder():\\n model = Sequential()\\n # Add a convolution layer with with a sigmoid activation function\\n model.add(layers.Conv2D(1, (2, 2), strides=(1, 1), activation='sigmoid', padding='same', input_shape=(256, 256, 3)))\\n model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\\n model.summary()\\n return model\",\n \"def sweep_image_model():\\n for c1 in [4, 8, 16]:\\n for c2 in [2, 4]:\\n for c3 in [2, 4]:\\n for c4 in [1, 2]:\\n flags = flag_reader.read_flag()\\n print(c1)\\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\\n print('channel list = ', flags.channel_list)\\n flags.last_dim = flags.channel_list[-1]\\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\\\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\\\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\\n print(flags.model_name)\\n training_from_flag(flags)\",\n \"def __init__(self):\\n # def __init__(self, embed_size, input_channels):\\n super(EncoderCNN, self).__init__()\\n self.off_model = OffsetCNN()\\n self.sig_model = SignificanceCNN()\\n self.sigmoid = nn.Sigmoid()\\n self.W = nn.Conv3d(1, 1, (5, 1, 1))\",\n \"def _build_output_layer(self,\\n answer_modeling,\\n answer_modeling_mask):\\n answer_start_dropout = self.hyperparams.model_output_answer_start_dropout if self.mode == \\\"train\\\" else 0.0\\n answer_start_trainable = self.hyperparams.model_output_answer_start_trainable\\n answer_end_dropout = self.hyperparams.model_output_answer_end_dropout if self.mode == \\\"train\\\" else 0.0\\n answer_end_trainable = self.hyperparams.model_output_answer_end_trainable\\n \\n with tf.variable_scope(\\\"output\\\", reuse=tf.AUTO_REUSE):\\n self.logger.log_print(\\\"# build answer output layer\\\")\\n answer_output_list = []\\n answer_output_mask_list = []\\n \\n with tf.variable_scope(\\\"start\\\", reuse=tf.AUTO_REUSE):\\n answer_start_list = [answer_modeling[0], answer_modeling[1]]\\n answer_start_mask_list = [answer_modeling_mask[0], answer_modeling_mask[1]]\\n (answer_start,\\n answer_start_mask) = self._build_fusion_result(answer_start_list,\\n answer_start_mask_list, None)\\n \\n answer_ouput_start_layer = create_dense_layer(\\\"single\\\", 1, 1, 1, None,\\n [answer_start_dropout], None, False, False, False, self.num_gpus, self.default_gpu_id,\\n self.regularizer, self.random_seed, answer_start_trainable)\\n answer_output_start, answer_output_start_mask = answer_ouput_start_layer(answer_start, answer_start_mask)\\n answer_output_list.append(answer_output_start)\\n answer_output_mask_list.append(answer_output_start_mask)\\n \\n with tf.variable_scope(\\\"end\\\", reuse=tf.AUTO_REUSE):\\n answer_end_list = [answer_modeling[0], answer_modeling[2]]\\n answer_end_mask_list = [answer_modeling_mask[0], answer_modeling_mask[2]]\\n (answer_end,\\n answer_end_mask) = self._build_fusion_result(answer_end_list,\\n answer_end_mask_list, None)\\n \\n answer_output_end_layer = create_dense_layer(\\\"single\\\", 1, 1, 1, None,\\n [answer_end_dropout], None, False, False, False, self.num_gpus, self.default_gpu_id,\\n self.regularizer, self.random_seed, answer_end_trainable)\\n answer_output_end, answer_output_end_mask = answer_output_end_layer(answer_end, answer_end_mask)\\n answer_output_list.append(answer_output_end)\\n answer_output_mask_list.append(answer_output_end_mask)\\n \\n return answer_output_list, answer_output_mask_list\",\n \"def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\\\"sigmoid\\\"):\\n\\n # inizializzo il modello come sequenziale\\n model = Sequential()\\n inputShape = (imageHeight, imageWidth, imageDepth)\\n chanDim = -1\\n\\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\\n # Utilizzo 32 filtri 3*3\\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\\\"same\\\", input_shape=inputShape))\\n # con attivazione Rectified Linear Unit\\n model.add(Activation(\\\"relu\\\"))\\n # applico una batch normalization\\n model.add(BatchNormalization(axis=chanDim))\\n # un MaxPooling 3*3\\n model.add(MaxPooling2D(pool_size=(3, 3)))\\n # ed un 25% di dropout per ridurre overfitting\\n model.add(Dropout(0.25))\\n\\n # Secondo blocco\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Terzo blocco\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Passo ai Fully Connected Layers\\n # Trasformo il modello in un vettore\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Activation(\\\"sigmoid\\\"))\\n model.add(BatchNormalization())\\n model.add(Dropout(0.5))\\n\\n # Infine utilizzo l'attivazione per la rete\\n model.add(Dense(classesNumber))\\n model.add(Activation(finalAct))\\n\\n return model\",\n \"def input_output_network(self, X):\\n layer_wise_output = [[] for i in range(len(self.layers) + 1)]\\n # if X contains only one data\\n if len(X.shape) == 1:\\n X = X.reshape(1, -1)\\n # for every data in X\\n for x in X:\\n for l in range(len(self.layers)):\\n p_h = self.layers[l].input_output(x)\\n layer_wise_output[l].append(p_h)\\n x = (np.random.random_sample(self.layers[l].output_size) <\\n p_h) * 1\\n # last layer --> softmax\\n layer_wise_output[-1].append(self.softmax(self.classif_RBM, x))\\n\\n # just reshape\\n layer_wise_output = [[\\n layer_wise_output[i][j].reshape(1, -1)\\n for j in range(len(layer_wise_output[i]))\\n ] for i in range(len(layer_wise_output))]\\n # concat results for each layers for each sample\\n layer_wise_output = [\\n np.concatenate(layer_wise_output[i])\\n for i in range(len(layer_wise_output))\\n ]\\n return layer_wise_output\",\n \"def CNN_ClassModel(input_shape=(1, 72, 72),n_class=3,lr=0.001):\\n model=Sequential()\\n model.add(Convolution2D(filters=16,nb_row=5,nb_col=5, \\n # kernel_size=5,strides=1,\\n padding='same',data_format='channels_first',\\n input_shape=input_shape))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2),padding='same',data_format='channels_first'))\\n model.add(Dropout(0.9))\\n model.add(Flatten())\\n model.add(Dense(200))\\n model.add(Activation('relu'))\\n\\n model.add(Dense(n_class))\\n model.add(Activation('softmax'))\\n\\n adam=Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-6, amsgrad=False)\\n model.compile(optimizer=adam,\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n return model\",\n \"def __init__(self, n_in_channels: int = 1, n_hidden_layers: int = 3, n_kernels: int = 32, kernel_size: int = 7):\\n super(SimpleCNN, self).__init__()\\n \\n cnn = []\\n for i in range(n_hidden_layers):\\n cnn.append(torch.nn.Conv2d(in_channels=n_in_channels, out_channels=n_kernels, kernel_size=kernel_size,\\n bias=True, padding=int(kernel_size/2)))\\n cnn.append(torch.nn.ReLU())\\n n_in_channels = n_kernels\\n self.hidden_layers = torch.nn.Sequential(*cnn)\\n self.output_layer = torch.nn.Conv2d(in_channels=n_in_channels, out_channels=1,\\n kernel_size=kernel_size, bias=True, padding=int(kernel_size/2))\",\n \"def build_cut_model(self):\\n model = None\\n if self.model_name == 'vgg16':\\n model = vgg16(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'resnet':\\n model = ResNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'densenet':\\n model = DenseNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'mobilenet':\\n model = MobileNet(img_dim=(self.ex_input_size, self.ex_input_size, self.ex_channels), num_classes=num_classes).create()\\n elif self.model_name == 'efficientnet':\\n model = efficientnet(input_shape=(self.ex_input_size, self.ex_input_size, self.ex_channels))\\n elif self.model_name == 'vit':\\n model = VisionTransformer(image_size=self.ex_input_size,\\n patch_size=vit_settings['patch_size'],\\n num_layers=vit_settings['num_layers'],\\n num_classes=num_classes,\\n d_model=vit_settings['d_model'],\\n num_heads=vit_settings['num_heads'],\\n mlp_dim=vit_settings['mlp_dim'],\\n channels=self.ex_channels,\\n dropout=vit_settings['dropout']).build_VisionTransformer()\\n model.load_weights(self.path_to_weights)\\n model = Model(model.input, model.get_layer(self.ex_last_conv_layer_name2).output)\\n model.summary()\\n return model\",\n \"def generator_model():\\n\\n Generator = Sequential(name='Generator')\\n\\n # Fully Connected layer --> 512 activation maps of 2x2 \\n Generator.add(Dense(units=512 * 2 * 2, input_shape=GENERATOR_INPUT, kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\\n Generator.add(Reshape((2, 2, 512)))\\n Generator.add(BatchNormalization(momentum=MOMENTUM))\\n Generator.add(ReLU())\\n\\n # Upsampling : 2x2x512 --> 4x4x256 \\n Generator.add(Conv2DTranspose(filters=256, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\\n Generator.add(BatchNormalization(momentum=MOMENTUM))\\n Generator.add(ReLU())\\n\\n # Upsampling : 4x4x256 --> 8x8x128 \\n Generator.add(Conv2DTranspose(filters=256, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\\n Generator.add(BatchNormalization(momentum=MOMENTUM))\\n Generator.add(ReLU())\\n\\n # Upsampling : 8x8x128 --> 16x16x64\\n Generator.add(Conv2DTranspose(filters=128, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD)))\\n Generator.add(BatchNormalization(momentum=MOMENTUM))\\n Generator.add(ReLU())\\n\\n # Upsampling : 16x16x63 --> 32x32x3 \\n Generator.add(Conv2DTranspose(filters=3, kernel_size=(5, 5), strides=2, padding='same', kernel_initializer=RandomNormal(stddev=GAUSS_SD), activation='tanh'))\\n\\n return Generator\",\n \"def get_model_2(parameters):\\n # Parameters\\n BANDS = parameters['num_features']\\n CLASSES = parameters['num_classes']\\n \\n # Sequential model\\n model = keras.models.Sequential()\\n \\n # Add convolution (1)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, 9, BANDS, 1)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(9, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh',\\n input_shape=(9, BANDS,1)))\\n \\n # Add convolution (2)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 15, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Add convolution (3)\\n # -------------------\\n # Input_shape (batch, rows, cols, channels) = (-, BANDS - 30, 1, 32)\\n # Output_shape (batch, rows, cols, channels) = (-, BANDS - 45, 1, 32)\\n model.add(keras.layers.Conv2D(filters=32,\\n kernel_size=(1, 16),\\n padding='same',\\n data_format=\\\"channels_last\\\",\\n activation='tanh'))\\n \\n # Flatten before dense layer\\n model.add(keras.layers.Flatten())\\n \\n # Add fully connected (4)\\n # -----------------------\\n # Intput_shape (batch, rows, cols, channels) = (-, (BANDS - 45) x 1 x 32)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='tanh'))\\n \\n # Add fully connected (5)\\n # -----------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, 800)\\n model.add(keras.layers.Dense(units=800,\\n activation='softmax'))\\n \\n # Add fully connected to reduce to number of categories\\n # -----------------------------------------------------\\n # Intput_shape (batch, dim) = (-, 800)\\n # Output_shape (batch, dim) = (-, CLASSES)\\n model.add(keras.layers.Dense(units=CLASSES,\\n activation='softmax'))\\n \\n # Compile model\\n model.compile(optimizer='adam',\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n \\n # Print the model summary to output file\\n # To print to stdout: model.summary()\\n with open(OUTPUT_FILE, 'a') as f:\\n # Pass the file handle in as a lambda function to make it callable\\n model.summary(print_fn=lambda x: f.write(x + '\\\\n'))\\n \\n # Return the model\\n return model\",\n \"def __init__(self, Nchannels, Nsamples, output_units):\\n super(conv2DNet_1, self).__init__()\\n # Layer 1\\n l1_channels = 16 \\n self.conv1 = nn.Conv2d(1, l1_channels, (Nchannels, 1), padding = 0)\\n self.batchnorm1 = nn.BatchNorm2d(l1_channels, False) # final size bsize x 1 x l1_channels x Nsamples\\n\\n # Layer 2\\n l2_channels = 4\\n l2_temp_window = 32\\n l2_l1channel_overlap = 2\\n self.padding1 = nn.ZeroPad2d((l2_temp_window // 2, l2_temp_window // 2 - 1, l2_l1channel_overlap//2-1, l2_l1channel_overlap//2)) # left, right, top, bottom\\n self.conv2 = nn.Conv2d(1, l2_channels, (l2_l1channel_overlap, l2_temp_window)) # does not change size if combined with above padding\\n self.batchnorm2 = nn.BatchNorm2d(l2_channels, False)\\n self.pooling2 = nn.MaxPool2d((2, 4)) # final size bsize x l2_channels x floor(l1_channels/2) x floor(Nsamples/4)\\n\\n # Layer 3\\n l3_channels = 4\\n l3_temp_window = 4\\n l3_l2channel_overlap = 8\\n self.padding2 = nn.ZeroPad2d((l3_temp_window//2, l3_temp_window//2-1, l3_l2channel_overlap//2, l3_l2channel_overlap//2-1))\\n self.conv3 = nn.Conv2d(l2_channels, l3_channels, (l3_l2channel_overlap, l3_temp_window))\\n self.batchnorm3 = nn.BatchNorm2d(l3_channels, False)\\n self.pooling3 = nn.MaxPool2d((2, 4)) # final size bsize x l3_channels x floor(l1_channels/4) x floor(Nsamples/16)\\n\\n # FC Layer\\n fc_inputs = l3_channels * (l1_channels//4) * (Nsamples//16)\\n self.fc1 = nn.Linear(fc_inputs, output_units)\",\n \"def __init__(self):\\n super(Encoder, self).__init__()\\n\\n self.lconv1 = nn.Sequential(\\n nn.Conv1d(4, 64, kernel_size=9, padding=4),\\n nn.BatchNorm1d(64),\\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\\n nn.BatchNorm1d(64),\\n )\\n\\n self.conv1 = nn.Sequential(\\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\\n nn.BatchNorm1d(64),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(64, 64, kernel_size=9, padding=4),\\n nn.BatchNorm1d(64),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv2 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=4, stride=4),\\n nn.Conv1d(64, 96, kernel_size=9, padding=4),\\n nn.BatchNorm1d(96),\\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\\n nn.BatchNorm1d(96),\\n )\\n\\n self.conv2 = nn.Sequential(\\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\\n nn.BatchNorm1d(96),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(96, 96, kernel_size=9, padding=4),\\n nn.BatchNorm1d(96),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv3 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=4, stride=4),\\n nn.Conv1d(96, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n )\\n\\n self.conv3 = nn.Sequential(\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv4 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=5, stride=5),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n )\\n\\n self.conv4 = nn.Sequential(\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv5 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=5, stride=5),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n )\\n\\n self.conv5 = nn.Sequential(\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv6 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=5, stride=5),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n )\\n\\n self.conv6 = nn.Sequential(\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.lconv7 = nn.Sequential(\\n nn.MaxPool1d(kernel_size=2, stride=2),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n )\\n\\n self.conv7 = nn.Sequential(\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n nn.Conv1d(128, 128, kernel_size=9, padding=4),\\n nn.BatchNorm1d(128),\\n nn.ReLU(inplace=True),\\n )\",\n \"def __generate_output_data(self):\\n if not len(self.output_data) == 0:\\n return\\n try:\\n self.output_data = s.load(open('output/output_data.p', 'rb'))\\n self.class_indices = s.load(open('output/class_indices.p', 'rb'))\\n if not self.classes_to_visualise == None:\\n self.__filter_output_data(self.classes_to_visualise)\\n except:\\n self.output_data = generate_output_for_test_data(image_data=self.image_data,\\n binary_output=self.binary_output) if self.testing else generate_output_for_train_data(\\n image_data=self.image_data, binary_output=self.binary_output)\\n self.class_indices = get_all_class_indices(training=False) if self.testing else get_all_class_indices()\\n if not self.classes_to_visualise == None:\\n self.__filter_output_data(self.classes_to_visualise)\\n s.dump([out.tolist() for out in self.output_data], open('output/output_data.p', 'wb'))\\n s.dump(self.class_indices, open('output/class_indices.p', 'wb'))\\n\\n self.legend = get_class_names_for_class_indices(list(set(sorted(self.class_indices))))\",\n \"def call(self, inputs):\\n for index,layer in enumerate(self.list_cnn):\\n if index == 0:\\n out = layer(inputs)\\n else:\\n if self.residual:\\n prev_out = out\\n cur_out = layer(out)\\n if self.use_batchnorm:\\n cur_out = layers.BatchNormalization()(cur_out)\\n if self.use_dropout:\\n cur_out = layers.Dropout(0.2)(cur_out)\\n out = prev_out + cur_out\\n else:\\n out = layer(out)\\n out = self.output_layer(out)\\n if self.use_pool:\\n out = self.pool(out)\\n out = self.flatten(out)\\n out = self.classify(out)\\n return out\",\n \"def __init__(self, in_channels, out_channels):\\n super(CNN, self).__init__()\\n self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=5, padding=1)\",\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 __call__(self, inputs, output_stages='c5', **kwargs):\\n if backend.image_data_format() == 'channels_last':\\n bn_axis = 3\\n else:\\n bn_axis = 1\\n\\n dilation = self.dilation\\n\\n x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(inputs)\\n x = layers.Conv2D(64, (7, 7),\\n strides=(2, 2),\\n padding='valid',\\n kernel_initializer='he_normal',\\n name='conv1')(x)\\n x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)\\n x = layers.Activation('relu')(x)\\n x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)\\n x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)\\n c1 = x\\n\\n x = self._conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))\\n for i in range(self.params[0]):\\n x = self._identity_block(x, 3, [64, 64, 256], stage=2, block=chr(ord('b') + i))\\n c2 = x\\n\\n x = self._conv_block(x, 3, [128, 128, 512], stage=3, block='a')\\n for i in range(self.params[1]):\\n x = self._identity_block(x, 3, [128, 128, 512], stage=3, block=chr(ord('b') + i))\\n c3 = x\\n\\n x = self._conv_block(x, 3, [256, 256, 1024], stage=4, block='a', dilation=dilation[0])\\n for i in range(self.params[2]):\\n x = self._identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(ord('b') + i), dilation=dilation[0])\\n c4 = x\\n\\n x = self._conv_block(x, 3, [512, 512, 2048], stage=5, block='a', dilation=dilation[1])\\n for i in range(self.params[3]):\\n x = self._identity_block(x, 3, [512, 512, 2048], stage=5, block=chr(ord('b') + i), dilation=dilation[1])\\n c5 = x\\n\\n self.outputs = {'c1': c1,\\n 'c2': c2,\\n 'c3': c3,\\n 'c4': c4,\\n 'c5': c5}\\n\\n if type(output_stages) is not list:\\n return self.outputs[output_stages]\\n else:\\n return [self.outputs[ci] for ci in output_stages]\",\n \"def build_multi_blocks_models(feature_dim, feat_group_start_end_dict, output_scheme=\\\"regression\\\", num_classes=num_classes):\\n\\tdivan_feat_dim = feature_dim\\n\\tfor k in feat_group_start_end_dict:\\n\\t\\tdivan_feat_dim = divan_feat_dim - feat_group_start_end_dict[k][2]\\n\\tinput_atac = keras.layers.Input(shape=[feat_group_start_end_dict['atac'][2]], name=\\\"atac_input\\\")\\n\\tinput_rnaseq = keras.layers.Input(shape=[feat_group_start_end_dict['rnaseq'][2]], name=\\\"rnaseq_input\\\")\\n\\tinput_wgbs = keras.layers.Input(shape=[feat_group_start_end_dict['wgbs'][2]], name=\\\"wgbs_input\\\")\\n\\tinput_divan = keras.layers.Input(shape=[divan_feat_dim], name=\\\"divan_input\\\")\\n\\n\\thidden_atac = keras.layers.Dense(30, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_atac)\\n\\thidden_rnaseq = keras.layers.Dense(100, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_rnaseq)\\n\\thidden_wgbs = keras.layers.Dense(60, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_wgbs)\\n\\thidden_divan_1 = keras.layers.Dense(800, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(input_divan)\\n\\tdropout1 = keras.layers.AlphaDropout(rate=0.5)(hidden_divan_1)\\n\\thidden_divan_2 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\tconcat = keras.layers.concatenate([hidden_atac, hidden_rnaseq, hidden_wgbs, hidden_divan_2])\\n\\thidden3 = keras.layers.Dense(200, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(dropout1)\\n\\t# trait-specific network\\n\\thidden_trait_1 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_2 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_3 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_4 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\thidden_trait_5 = keras.layers.Dense(50, activation='relu', \\n\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), \\n\\t\\tkernel_initializer=\\\"he_uniform\\\")(concat)\\n\\t#bn3 = keras.layers.BatchNormalization()(hidden3)\\n\\tif (output_scheme==\\\"regression\\\"):\\n\\t\\t#outputs = [keras.layers.Dense(1, hidden3) for i in range(5)] #\\n\\t\\tout1 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden_trait_1)\\n\\t\\tout2 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden_trait_2)\\n\\t\\tout3 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden_trait_3)\\n\\t\\tout4 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden_trait_4)\\n\\t\\tout5 = keras.layers.Dense(1, activation=lambda x: keras.activations.relu(x, max_value=num_classes-1.0), \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden_trait_5)\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tout1 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out1\\\")(hidden_trait_1)\\n\\t\\tout2 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out2\\\")(hidden_trait_2)\\n\\t\\tout3 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out3\\\")(hidden_trait_3)\\n\\t\\tout4 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out4\\\")(hidden_trait_4)\\n\\t\\tout5 = keras.layers.Dense(num_classes, activation=\\\"sigmoid\\\", \\n\\t\\t\\tkernel_regularizer=keras.regularizers.l2(0.01), kernel_initializer=\\\"he_uniform\\\", \\n\\t\\t\\tname=\\\"out5\\\")(hidden_trait_5)\\n\\tmodel = keras.models.Model(inputs=[input_atac, input_rnaseq, input_wgbs, input_divan],\\n\\t\\t\\t\\t\\t\\t\\t outputs=[out1, out2, out3, out4, out5])\\n\\tif (output_scheme == \\\"regression\\\"):\\n\\t\\tmodel.compile(loss=\\\"mse\\\", \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.0001),\\n\\t\\t\\t\\t\\t metrics=['mae', custom_r2_metric])\\n\\telif (output_scheme == \\\"ordinal_clf\\\"):\\n\\t\\tmodel.compile(loss=tf.keras.losses.CategoricalCrossentropy(), \\n\\t\\t\\t\\t\\t optimizer=tf.keras.optimizers.Adam(0.001))\\n\\tprint(model.summary())\\n\\treturn model\",\n \"def __init__(self, nfeat, nhid, nclass, dropout, alpha):\\n super(GCN, self).__init__()\\n self.dropout = dropout\\n\\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\\n \\n self.add_module('conv1', self.conv1)\\n\\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)\",\n \"def build_bisenet(inputs, num_classes):\\n\\n ### The spatial path\\n ### The number of feature maps for each convolution is not specified in the paper\\n ### It was chosen here to be equal to the number of feature maps of a classification\\n ### model at each corresponding stage\\n # spatial_net = fluid.layers.resize_bilinear(inputs, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_1',spatial_net)\\n\\n ## spatial path\\n spatial_net = ConvBlock(inputs, num_filters=64, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=128, kernel_size=3, stride=2)\\n spatial_net = ConvBlock(spatial_net, num_filters=256, kernel_size=3, stride=2)\\n # print(\\\"spatial_net:\\\", spatial_net)\\n\\n # spatial_net = fluid.layers.resize_bilinear(spatial_net, [Image_Height/8, Image_Width/8])\\n # print('spatial_net_2',spatial_net)\\n ### Context path\\n model = ResNet(is_test=False)\\n # spatial_net = model.bottleneck_block1(inputs)\\n end_points_16, end_points_32 = model.net(inputs)\\n net_4 = AttentionRefinementModule(end_points_16, num_filters=512)\\n net_5 = AttentionRefinementModule(end_points_32, num_filters=1024)\\n global_channels = fluid.layers.reduce_mean(net_5, [2, 3], keep_dim=True)\\n net_5_scaled = fluid.layers.elementwise_mul(net_5, global_channels, axis=0)\\n\\n ### Combining the paths\\n net_4 = Upsample(net_4, scale=2)\\n net_5_scaled = Upsample(net_5_scaled, scale=4)\\n # print('net_4, net_5:', [net_4, net_5_scaled])\\n # layers_concat = list()\\n # layers_concat.append(spatial_net)\\n ## layers_concat.append(net_4)\\n # layers_concat.append(net_5_scaled)\\n context_net = fluid.layers.concat([spatial_net, net_4, net_5_scaled], axis=1) #\\n # context_net = fluid.layers.concat(input=layers_concat,axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([net_4, net_5_scaled], axis=1)\\n # print('context_net', context_net)\\n # context_net = fluid.layers.concat([spatial_net,context_net], axis=1)\\n # print('context_net2',context_net)\\n\\n ### FFM\\n # net = FeatureFusionModule(input_1=spatial_net, input_2=context_net, num_filters=num_classes)\\n net = FeatureFusionModule(inputs=context_net, num_filters=num_classes)\\n\\n # print('net', net)\\n\\n ## [batch_zize, num_filters, 128, 64]\\n\\n ### Final upscaling and finish\\n # net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 128])\\n # print('conv2d_transpose', net)\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn1')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[128, 256])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn2')\\n net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[256, 512])\\n net = batch_normalization(net, relu=True, name='conv2d_transpose_bn3')\\n #net = fluid.layers.conv2d_transpose(input=net, num_filters=num_classes, output_size=[512, 1024])\\n #net = batch_normalization(net, relu=True, name='conv2d_transpose_bn4')\\n # print('net',net)\\n net = fluid.layers.image_resize(net, out_shape=[512, 1024], resample='BILINEAR')\\n\\n net = fluid.layers.conv2d(net, num_classes, 1)\\n return net\",\n \"def TBLCCCNN_Model(pan_image_height_size, pan_image_width_size, ms_to_pan_ratio, n_bands, n1_pan, n2_pan, n3_pan, \\r\\n n1_ms, n2_ms, n3_ms, dropout_rate, n_classes, l_r):\\r\\n \\r\\n if (pan_image_height_size % ms_to_pan_ratio) != 0 or (pan_image_width_size % ms_to_pan_ratio) != 0:\\r\\n raise ValueError('Please make sure that both pan_image_height_size and pan_image_width_size can be divided by {}'.format(int(ms_to_pan_ratio)))\\r\\n \\r\\n pan_img_input = Input(shape = (pan_image_height_size, pan_image_width_size, 1))\\r\\n conv_1_pan = Conv2D(n1_pan, (7, 7), padding = 'same', activation = 'relu')(pan_img_input)\\r\\n max_pool_1_pan = MaxPooling2D(pool_size = (2, 2))(conv_1_pan)\\r\\n conv_2_pan = Conv2D(n2_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_1_pan)\\r\\n max_pool_2_pan = MaxPooling2D(pool_size = (2, 2))(conv_2_pan)\\r\\n conv_3_pan = Conv2D(n3_pan, (3, 3), padding = 'same', activation = 'relu')(max_pool_2_pan)\\r\\n glob_max_pool_pan = GlobalMaxPooling2D()(conv_3_pan)\\r\\n glob_max_pool_pan = Dropout(dropout_rate)(glob_max_pool_pan)\\r\\n \\r\\n ms_img_input = Input(shape = (int(pan_image_height_size / ms_to_pan_ratio), int(pan_image_width_size / ms_to_pan_ratio), \\r\\n n_bands))\\r\\n conv_1_ms = Conv2D(n1_ms, (3, 3), padding = 'same', activation = 'relu')(ms_img_input)\\r\\n conv_2_ms = Conv2D(n2_ms, (3, 3), padding = 'same', activation = 'relu')(conv_1_ms)\\r\\n conv_3_ms = Conv2D(n3_ms, (3, 3), padding = 'same', activation = 'relu')(conv_2_ms)\\r\\n glob_max_pool_ms = GlobalMaxPooling2D()(conv_3_ms)\\r\\n glob_max_pool_ms = Dropout(dropout_rate)(glob_max_pool_ms)\\r\\n \\r\\n all_features = concatenate([glob_max_pool_pan, glob_max_pool_ms])\\r\\n \\r\\n pred_layer = Dense(n_classes, activation = 'softmax')(all_features)\\r\\n \\r\\n tblcccnn_model = Model(inputs = [ms_img_input, pan_img_input], outputs = pred_layer)\\r\\n tblcccnn_model.compile(loss = 'categorical_crossentropy', optimizer = Adam(lr = l_r), \\r\\n metrics = ['categorical_crossentropy'])\\r\\n \\r\\n return tblcccnn_model\",\n \"def build_model(self):\\n # Define model inputs for the encoder/decoder stack\\n x_enc = Input(shape=(self.seq_len_in, self.input_feature_amount), name=\\\"x_enc\\\")\\n x_dec = Input(shape=(self.seq_len_out, self.output_feature_amount), name=\\\"x_dec\\\")\\n\\n # Add noise\\n x_dec_t = GaussianNoise(0.2)(x_dec)\\n\\n input_conv2 = Conv1D(filters=64, kernel_size=5, strides=2, activation='relu', padding='same')\\n input_conv1 = Conv1D(filters=64, kernel_size=3, strides=2, activation='relu', padding='same', name=\\\"last_conv_layer\\\")\\n\\n input_conv2_out = input_conv2(x_enc)\\n input_conv1_out = input_conv1(input_conv2_out)\\n\\n # Define the encoder GRU, which only has to return a state\\n encoder_gru = GRU(self.state_size, return_sequences=True, return_state=True, name=\\\"encoder_gru\\\")\\n encoder_out, encoder_state = encoder_gru(input_conv1_out)\\n\\n # Decoder GRU\\n decoder_gru = GRU(self.state_size, return_state=True, return_sequences=True,\\n name=\\\"decoder_gru\\\")\\n # Use these definitions to calculate the outputs of out encoder/decoder stack\\n dec_intermediates, decoder_state = decoder_gru(x_dec_t, initial_state=encoder_state)\\n\\n # Define the attention layer\\n attn_layer = AttentionLayer(name=\\\"attention_layer\\\")\\n attn_out, attn_states = attn_layer([encoder_out, dec_intermediates])\\n\\n # Concatenate decoder and attn out\\n decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([dec_intermediates, attn_out])\\n\\n # Define the dense layer\\n dense = Dense(self.output_feature_amount, activation='linear', name='output_layer')\\n dense_time = TimeDistributed(dense, name='time_distributed_layer')\\n decoder_pred = dense_time(decoder_concat_input)\\n\\n # Define the encoder/decoder stack model\\n encdecmodel = tsModel(inputs=[x_enc, x_dec], outputs=decoder_pred)\\n\\n # Define the separate encoder model for inferencing\\n encoder_inf_inputs = Input(shape=(self.seq_len_in, self.input_feature_amount), name=\\\"encoder_inf_inputs\\\")\\n\\n input_conv2_inf = input_conv2(encoder_inf_inputs)\\n input_conv1_inf_out = input_conv1(input_conv2_inf)\\n\\n encoder_inf_out, encoder_inf_state = encoder_gru(input_conv1_inf_out)\\n encoder_model = tsModel(inputs=encoder_inf_inputs, outputs=[encoder_inf_out, encoder_inf_state])\\n\\n # Define the separate encoder model for inferencing\\n decoder_inf_inputs = Input(shape=(1, self.output_feature_amount), name=\\\"decoder_inputs\\\")\\n encoder_inf_states = Input(shape=(encdecmodel.get_layer('last_conv_layer').output_shape[1], self.state_size), name=\\\"decoder_inf_states\\\")\\n decoder_init_state = Input(shape=(self.state_size,), name=\\\"decoder_init\\\")\\n\\n decoder_inf_out, decoder_inf_state = decoder_gru(decoder_inf_inputs, initial_state=decoder_init_state)\\n attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])\\n decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_inf_out, attn_inf_out])\\n decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)\\n decoder_model = tsModel(inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],\\n outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state])\\n\\n return encoder_model, decoder_model, encdecmodel\",\n \"def build_model():\\n model = models.Sequential()\\n\\n # # Anti-overfit methods\\n # model.add(layers.BatchNormalization())\\n # model.add(layers.Dropout(0.5))\\n # regularizers.l1_l2(l1=0.01, l2=0.01)\\n\\n model.add(layers.Conv2D(200, (3, 3), activation='relu',\\n input_shape=nnc.INPUT_SHAPE))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.BatchNormalization())\\n model.add(layers.Conv2D(200, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.BatchNormalization())\\n model.add(layers.Conv2D(150, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.BatchNormalization())\\n model.add(layers.Conv2D(100, (3, 3), activation='relu'))\\n model.add(layers.MaxPooling2D((2, 2)))\\n model.add(layers.BatchNormalization())\\n model.add(layers.Flatten())\\n model.add(layers.Dense(512, activation='relu',))\\n model.add(layers.Dropout(0.5))\\n model.add(layers.Dense(256, activation='relu',))\\n model.add(layers.Dropout(0.5))\\n model.add(layers.Dense(512, activation='relu',))\\n model.add(layers.Dropout(0.5))\\n model.add(layers.Dense(7, activation='sigmoid'))\\n model.compile(optimizer=nnc.OPTIMIZER, loss=nnc.LOSS, metrics=nnc.METRICS)\\n\\n # # Print the model to the console\\n model.summary()\\n # # Print the model to a png file\\n # utils.plot_model(model, show_shapes=True, to_file=nnc.MODEL_PLOT_PATH)\\n # # Turn into multi-gpu model\\n # model = utils.multi_gpu_model(model, gpus=2)\\n\\n return model\",\n \"def build_model():\\n model = keras.Sequential()\\n\\n model.add(Conv2D(32, (5, 5), activation='relu', input_shape=(32, 32, 1)))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.1))\\n\\n model.add(Conv2D(64, (5, 5), activation='relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n model.add(Flatten())\\n model.add(Dense(128, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(43, activation='softmax'))\\n\\n model.compile(optimizer=keras.optimizers.Adam(),\\n loss='sparse_categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n return model\",\n \"def build_models(config):\\n inputs = Input(shape=(config['patch_height'], config['patch_width'], config['depth'], config['channel']),\\n name='patchimg')\\n\\n kernelinitfun = keras.initializers.RandomNormal(mean=0.0, stddev=0.1, seed=None)\\n activationfun = 'relu'\\n # kernelinitfun = 'glorot_normal'\\n\\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv1_1')(inputs)\\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv1_2')(x)\\n # x = Dropout(0.3)(x)\\n x = BatchNormalization(name='bn1')(x)\\n x = Activation(activationfun)(x)\\n x = MaxPooling3D(name='mp1', strides=(2, 2, 1))(x)\\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv2_1')(x)\\n x = Conv3D(32, (3, 3, 3), padding='same', kernel_initializer=kernelinitfun, name='conv2_2')(x)\\n # x = Dropout(0.2)(x)\\n x = BatchNormalization(name='bn2')(x)\\n x = Activation(activationfun)(x)\\n x = MaxPooling3D(name='mp2', strides=(2, 2, 1))(x)\\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv3_1')(x)\\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv3_2')(x)\\n # x = Dropout(0.5)(x)\\n x = BatchNormalization(name='bn3')(x)\\n x = Activation(activationfun)(x)\\n x = MaxPooling3D(name='mp3', strides=(2, 2, 1))(x)\\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv4_1')(x)\\n x = Conv3D(32, (3, 3, 3), strides=(1, 1, 1), padding='same', kernel_initializer=kernelinitfun, name='conv4_2')(x)\\n # x = Dropout(0.5)(x)\\n x = BatchNormalization(name='bn4')(x)\\n x = Activation(activationfun)(x)\\n\\n x4 = Flatten(name='aux_fx')(x)\\n\\n source_classifier = Dropout(0.5)(x4)\\n source_classifier = Dense(512, activation='softmax', name=\\\"mo1\\\")(source_classifier)\\n source_classifier = Dropout(0.5)(source_classifier)\\n source_classifier = Dense(128, activation='softmax', name=\\\"mo2\\\")(source_classifier)\\n # source_classifier = Dropout(0.3)(source_classifier)\\n source_classifier = Dense(1, name=\\\"mo\\\")(source_classifier)\\n\\n domain_classifier = Dense(32, activation='linear', name=\\\"do4\\\")(x4)\\n domain_classifier = BatchNormalization(name=\\\"do5\\\")(domain_classifier)\\n domain_classifier = Activation(\\\"elu\\\", name=\\\"do6\\\")(domain_classifier)\\n domain_classifier = Dropout(0.5)(domain_classifier)\\n\\n domain_classifier = Dense(2, activation='softmax', name=\\\"do\\\")(domain_classifier)\\n\\n adamop = keras.optimizers.Adam(learning_rate=1e-5, beta_1=0.9, beta_2=0.999, amsgrad=False)\\n comb_model = Model(inputs=inputs, outputs=[source_classifier, domain_classifier])\\n comb_model.compile(optimizer=adamop,\\n loss={'mo': 'mae', 'do': 'categorical_crossentropy'},\\n loss_weights={'mo': 1, 'do': 2}, metrics=['accuracy'], )\\n\\n source_classification_model = Model(inputs=inputs, outputs=[source_classifier])\\n source_classification_model.compile(optimizer=adamop,\\n loss={'mo': 'mae'}, metrics=['accuracy'], )\\n\\n domain_classification_model = Model(inputs=inputs, outputs=[domain_classifier])\\n domain_classification_model.compile(optimizer=adamop,\\n loss={'do': 'categorical_crossentropy'}, metrics=['accuracy'])\\n\\n embeddings_model = Model(inputs=inputs, outputs=[x4])\\n embeddings_model.compile(optimizer=adamop, loss='categorical_crossentropy', metrics=['accuracy'])\\n\\n return comb_model, source_classification_model, domain_classification_model, embeddings_model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67610925","0.6492056","0.6454665","0.644587","0.6413437","0.6320915","0.62863666","0.6275258","0.6252421","0.6248297","0.6241189","0.6237258","0.6234287","0.615311","0.6143814","0.61404675","0.6138519","0.61306256","0.6123763","0.6122863","0.61180544","0.61154467","0.6109723","0.6103555","0.61031455","0.6092535","0.6084878","0.6078706","0.6063557","0.6060361","0.6057333","0.6038668","0.6038668","0.6034947","0.60304606","0.6026154","0.60259366","0.60250914","0.6023096","0.6009951","0.6009836","0.6001061","0.5996308","0.59936076","0.59918755","0.5986838","0.5984119","0.59712046","0.5962252","0.5954557","0.5951423","0.5949623","0.59462655","0.5943636","0.593797","0.59297144","0.5929276","0.59279794","0.59276426","0.5924939","0.5922403","0.5918525","0.59141964","0.5909902","0.5909311","0.5901681","0.58978564","0.5897588","0.5892363","0.58910125","0.58875054","0.5887192","0.5884602","0.5882385","0.5880605","0.58780235","0.58692545","0.58640283","0.5861442","0.5860673","0.5857903","0.5848535","0.5838026","0.5830233","0.58275646","0.58257306","0.5820593","0.5818641","0.58158803","0.58153915","0.5814128","0.58130103","0.58013433","0.58012015","0.5801088","0.5800715","0.5790668","0.57894576","0.57886755","0.57860106","0.57831514"],"string":"[\n \"0.67610925\",\n \"0.6492056\",\n \"0.6454665\",\n \"0.644587\",\n \"0.6413437\",\n \"0.6320915\",\n \"0.62863666\",\n \"0.6275258\",\n \"0.6252421\",\n \"0.6248297\",\n \"0.6241189\",\n \"0.6237258\",\n \"0.6234287\",\n \"0.615311\",\n \"0.6143814\",\n \"0.61404675\",\n \"0.6138519\",\n \"0.61306256\",\n \"0.6123763\",\n \"0.6122863\",\n \"0.61180544\",\n \"0.61154467\",\n \"0.6109723\",\n \"0.6103555\",\n \"0.61031455\",\n \"0.6092535\",\n \"0.6084878\",\n \"0.6078706\",\n \"0.6063557\",\n \"0.6060361\",\n \"0.6057333\",\n \"0.6038668\",\n \"0.6038668\",\n \"0.6034947\",\n \"0.60304606\",\n \"0.6026154\",\n \"0.60259366\",\n \"0.60250914\",\n \"0.6023096\",\n \"0.6009951\",\n \"0.6009836\",\n \"0.6001061\",\n \"0.5996308\",\n \"0.59936076\",\n \"0.59918755\",\n \"0.5986838\",\n \"0.5984119\",\n \"0.59712046\",\n \"0.5962252\",\n \"0.5954557\",\n \"0.5951423\",\n \"0.5949623\",\n \"0.59462655\",\n \"0.5943636\",\n \"0.593797\",\n \"0.59297144\",\n \"0.5929276\",\n \"0.59279794\",\n \"0.59276426\",\n \"0.5924939\",\n \"0.5922403\",\n \"0.5918525\",\n \"0.59141964\",\n \"0.5909902\",\n \"0.5909311\",\n \"0.5901681\",\n \"0.58978564\",\n \"0.5897588\",\n \"0.5892363\",\n \"0.58910125\",\n \"0.58875054\",\n \"0.5887192\",\n \"0.5884602\",\n \"0.5882385\",\n \"0.5880605\",\n \"0.58780235\",\n \"0.58692545\",\n \"0.58640283\",\n \"0.5861442\",\n \"0.5860673\",\n \"0.5857903\",\n \"0.5848535\",\n \"0.5838026\",\n \"0.5830233\",\n \"0.58275646\",\n \"0.58257306\",\n \"0.5820593\",\n \"0.5818641\",\n \"0.58158803\",\n \"0.58153915\",\n \"0.5814128\",\n \"0.58130103\",\n \"0.58013433\",\n \"0.58012015\",\n \"0.5801088\",\n \"0.5800715\",\n \"0.5790668\",\n \"0.57894576\",\n \"0.57886755\",\n \"0.57860106\",\n \"0.57831514\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17079,"cells":{"query":{"kind":"string","value":"Computer perimeter for the rectangle"},"document":{"kind":"string","value":"def perimRect(length, width):\n return 2 * (length + width)"},"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 perimeter(self):","def perimeter(self):\n\t\treturn 2 * (self.width + self.height)","def calculateperimeter(self):\r\n return (self.width * 2) + (self.height * 2)","def perimeter(self):\r\n return (2*self.width) + (2*self.height)","def perimeter(self):\n return 2 * (self.height + self.width)","def perimeter(self):\n return self.sidelength1 + self.sidelength2 + self.baselength1 + self.baselength2","def perimeter(self):\n\t\treturn self.height * 4","def perimeter(self):\n return (\n self.side_1_length +\n self.side_2_length +\n self.side_3_length +\n self.side_4_length\n )","def perimeter(self):\n perimeter = (2 * self.__length) + (2 * self.__width)\n\n return perimeter","def perimeter(self):\r\n\r\n return 2*math.pi*self.__radius","def findArea(self):\n\n a, b = self.sides\n area = a * b\n print(f\"Are of rectangle is: {area}\")","def perimeter(self):\n return sum([s.length for s in self.segments])","def getPerimeter(self):\n return 2 * math.pi * self.__radius","def perimeter(a:float, b:float, c:float):\n return a + b + c","def perimeter(self):\n return sum(seg.length for seg in self.segments) + \\\n sum([p.perimeter for p in self.subs])","def perimeter(cnt):\n\treturn cv2.arcLength(cnt, True)","def get_perimeter_formula(cls):\n pass","def perimeter(self):\n return sum(self._lengths)","def perimeter(self):\n return sum(self._lengths)","def rectangle_area(side1, side2):\n return float(side1) * float(side2)","def regular_polygon_area(perimeter, apothem):\n return (perimeter * apothem) / 2","def island_perimeter(grid):\n \"\"\"island_perimeter - perimeter of the island\n Parameter\n ---------\n grid:\n list\n Return\n ------\n int\n \"\"\"\n total = 0\n\n rows = len(grid)\n columns = len(grid[0])\n\n for row in range(rows):\n for col in range(columns):\n array = grid[row][col]\n if array == 1:\n total += 4\n if row != 0 and grid[row-1][col] == 1:\n total -= 1\n if col != 0 and grid[row][col-1] == 1:\n total -= 1\n if row + 1 != rows and grid[row + 1][col] == 1:\n total -= 1\n if col + 1 != columns and grid[row][col + 1] == 1:\n total -= 1\n\n return total","def perimeter(points):\n return sum(get_distances(points))","def rect(l, b):\n print(\"Area of rectangle is\", l * b)","def __CalculatePerimeter(self, curve):\r\n return cv2.arcLength(curve, True)","def get_rect_perimeter(length, width):\n length = (str)(length)\n width = (str)(width)\n if((length.isnumeric()) and (length.isnumeric())):\n length = (float)(length)\n width = (float)(width)\n perimeter = 2 * (length + width)\n else:\n perimeter = \"Invalid input, length and width must be numeric value\"\n return perimeter","def square_area(side):\n return side**2","def island_perimeter(grid):\n w = len(grid[0])\n h = len(grid)\n perimeter = 0\n\n for i, col in enumerate(grid):\n for j, row in enumerate(col):\n if row == 1:\n perimeter += 4\n if grid[i][j-1] == 1:\n perimeter -= 1\n if grid[i][(j+1) % w] == 1:\n perimeter -= 1\n if grid[(i+1) % h][j] == 1:\n perimeter -= 1\n if grid[i-1][j] == 1:\n perimeter -= 1\n return perimeter","def island_perimeter(grid):\n cx, cy = 0, 0\n len_grid = len(grid)\n for x in range(len_grid):\n for y in range(len(grid[x])):\n if grid[x][y] == 1:\n cx += 1\n if (y != len(grid[x]) - 1 and grid[x][y + 1] == 1):\n cy += 1\n if (x != len(grid) - 1 and grid[x + 1][y] == 1):\n cy += 1\n return 4 * cx - 2 * cy","def rect_area(rect):\n return rect[2] * rect[3]","def area_rect(w, h):\n return w * h","def test_triangle_get_perimeter(self):\n triangle = Triangle(0, 9, 10, 11)\n self.assertEqual(triangle.get_perimeter(), 30)","def island_perimeter(grid):\n perimeter = 0\n for j in range(len(grid)):\n for i in range(len(grid[j])):\n if grid[j][i] == 1:\n perimeter += 4\n if i is not 0 and grid[j][i - 1] is 1:\n perimeter -= 1\n if j is not 0 and grid[j - 1][i] is 1:\n perimeter -= 1\n if j + 1 < len(grid) and grid[j + 1][i] is 1:\n perimeter -= 1\n if i + 1 < len(grid[j]) and grid[j][i + 1] is 1:\n perimeter -= 1\n return perimeter","def test_rectangle(self):\n result = shape_area.rectangle_area(6,7)\n self.assertEqual(result,26)","def area(self):\n return (self.baselength1 + self.baselength2)*self.height/2","def island_perimeter(grid):\n perimeter = 0\n for x in range(len(grid)):\n for y in range(len(grid[x])):\n if grid[x][y] == 1:\n if x == 0:\n perimeter += 1\n elif grid[x - 1][y] == 0:\n perimeter += 1\n if y == 0:\n perimeter += 1\n elif grid[x][y - 1] == 0:\n perimeter += 1\n if x == len(grid) - 1:\n perimeter += 1\n elif grid[x + 1][y] == 0:\n perimeter += 1\n if y == len(grid[0]) - 1:\n perimeter += 1\n elif grid[x][y + 1] == 0:\n perimeter += 1\n return perimeter","def rectangle_area(width : number, height : number) ->number:\n area = width*height\n #print(\"The area of rectangle is =\", area, \"sq. units\")\n return area","def island_perimeter(grid):\n c = 0\n length = len(grid) - 1\n width = len(grid[0]) - 1\n\n for i, r in enumerate(grid):\n for j, n in enumerate(r):\n if n == 1:\n if i == 0 or grid[i - 1][j] != 1:\n c += 1\n if j == 0 or grid[i][j - 1] != 1:\n c += 1\n if j == width or grid[i][j + 1] != 1:\n c += 1\n if i == length or grid[i + 1][j] != 1:\n c += 1\n return c","def perimeter(self) -> ir.FloatingValue:\n return ops.GeoPerimeter(self).to_expr()","def calculate_perimeter_ratio(gt_perimeter, perf_perimeter):\n return min(gt_perimeter, perf_perimeter) / max(gt_perimeter, perf_perimeter)","def area(self):\r\n return self.width * self.height","def rectangle_area(base, height):\n return (base * height)","def island_perimeter(grid):\n perimeter, connections = 0, 0\n\n for i in range(len(grid)):\n for j in range(len(grid[i])):\n if grid[i][j] == 1:\n perimeter += 4\n\n if i != 0 and grid[i-1][j] == 1:\n connections += 1\n if j != 0 and grid[i][j-1] == 1:\n connections += 1\n\n return(perimeter - (2 * connections))","def area(self):\n\t\treturn self.width * self.height","def area(self):\n\t\treturn self.width() * self.height()","def island_perimeter(grid):\n perimeter = 0\n for row in grid + list(map(list, zip(*grid))):\n for i, j in zip([0] + row, row + [0]):\n perimeter += int(i != j)\n return perimeter","def calculatearea(self):\r\n return self.width * self.height","def rectangle_circumference(a,b):\n return (2*(a+b))","def get_perimeter_formula(cls):\n dict_perimieter = {'circle':\"2πr\", 'square':'2a+2b', 'rectangle':'2a+2b',\n 'triangle':'3a',\"equilateral triangle\":'a+b+c',\n 'regular pentagon':\"5a\"}\n for k,v in dict_perimieter.items():\n if cls.__name__ == k:\n return v","def area(self):\n return(self.__width * self.__height)","def island_perimeter(grid):\n\n count = 0\n\n for i in range(len(grid)):\n for j in range(len(grid[0])):\n mul = 4\n if grid[i][j] == 1:\n if j < len(grid[0]) - 1:\n if grid[i][j + 1] == 1:\n mul -= 1\n if grid[i][j - 1] == 1 and j > 0:\n mul -= 1\n if i < len(grid) - 1:\n if grid[i + 1][j] == 1:\n mul -= 1\n if grid[i - 1][j] == 1 and i > 0:\n mul -= 1\n else:\n continue\n count += mul\n return count","def area(self):\n return self.width*self.height","def rectArea(base, height):\n return base * height","def PolyPerimeter(Coords):\n peri = 0.0\n for i in range(np.shape(Coords)[0]-1):\n # next point coord - current point coord\n peri = peri + ( (Coords[i+1,0] - Coords[i,0])**2 + (Coords[i+1,1] - Coords[i,1])**2 )**0.5\n\n return peri","def island_perimeter(grid):\n total = 0\n for x in range(0, len(grid)):\n for y in range(0, len(grid[0])):\n if grid[x][y] == 1:\n if x == 0 or grid[x - 1][y] == 0:\n total += 1\n if x == len(grid) - 1 or grid[x + 1][y] == 0:\n total += 1\n if y == len(grid[0]) - 1 or grid[x][y + 1] == 0:\n total += 1\n if y == 0 or grid[x][y - 1] == 0:\n total += 1\n return total","def add_perimeter(self, pt):\n nn = [\n (pt[0] + i, pt[1] + j)\n for i, j in zip([1, -1, 0, 0], [0, 0, 1, -1])\n ]\n for p in nn:\n if (\n p not in self.cluster\n and p not in self.perimeter\n and p not in self.dead\n ):\n self.perimeter.add(p)","def island_perimeter(grid):\n perimeter = 0\n for row in range(len(grid)):\n for idx in range(len(grid[0])):\n if grid[row][idx] == 1:\n \"\"\"if 1 encountered check all sides for 0\"\"\"\n top = row - 1\n bottom = row + 1\n left = idx - 1\n right = idx + 1\n\n \"\"\"check top index value\"\"\"\n if top < 0:\n perimeter += 1\n elif grid[row - 1][idx] != 1:\n perimeter += 1\n\n \"\"\"check bottom index value\"\"\"\n if bottom >= len(grid):\n perimeter += 1\n elif grid[row + 1][idx] != 1:\n perimeter += 1\n\n \"\"\"check left index value\"\"\"\n if left < 0:\n perimeter += 1\n elif grid[row][idx - 1] != 1:\n perimeter += 1\n\n \"\"\"check right index value\"\"\"\n if right >= len(grid[0]):\n perimeter += 1\n elif grid[row][idx + 1] != 1:\n perimeter += 1\n return perimeter","def area(self):\n return self.length*self.length","def area(self):\n return (self.width * self.height)","def area(width, height):\n return width * height","def area(self):\n return self.__size ** 2","def area_rectangle():\n side_a = float(input(\"Enter the first side:\\n\"))\n side_b = float(input(\"Enter the second side\\n\"))\n return side_a * side_b","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def island_perimeter(grid):\n LAND = 1\n WATER = 0\n perimeter = 0\n for y, row in enumerate(grid):\n for x, cell in enumerate(row):\n if cell == LAND:\n # print(\"land in [x= {:d} y= {:d}]\".format(x, y))\n # left\n if y == 0 or grid[y - 1][x] == WATER:\n perimeter += 1\n # right\n if y == len(grid) - 1 or grid[y + 1][x] == WATER:\n perimeter += 1\n # up\n if x == 0 or grid[y][x - 1] == WATER:\n perimeter += 1\n # down\n if x == len(row) - 1 or grid[y][x + 1] == WATER:\n perimeter += 1\n return perimeter","def area(self):\n return self.width() * self.height()","def area_equilat(side):\n\treturn side/2 * math.sqrt(side**2 - (side/2)**2)","def area(self):\n\t\treturn self.height * self.height","def calculate(perimeter):\n for a in range(1, perimeter):\n if a > perimeter:\n break\n for b in range(1, perimeter):\n if a + b > perimeter:\n break\n for c in range(1, perimeter):\n if a + b + c > perimeter:\n break\n if a + b + c == perimeter and a ** 2 + b ** 2 == c ** 2:\n answer = a * b * c\n return answer","def area(self):\n return (self.__width * self.__height)","def area(self):\n return (self.__width * self.__height)","def ask_perimeter(self):\n\n print(\"controller - ask_perimeter!\")\n img_cv2_mask = self.pressure_img.mask\n if self.pressure_img.perimetre_done:\n self.view.popupmsg(\"El perímetre ja ha estat seleccionat\")\n else:\n self.pressure_img.roi_crop(img_cv2_mask, \"Perimeter\")","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__height * self.__width","def area(self):\n return self.__height * self.__width","def area(self):\n return self.__height * self.__width","def area_rectangulo(b,h):\n area = b*h\n print \"El area es: \",area","def square(side):\n rectangle(side,side)","def get_perimeter(self, radius: int = 1) -> set:\n return self.get_neighbourhood(radius) - self.get_neighbourhood(radius - 1)","def areaRect(length, width):\n return length * width","def rectangle_surface_area(a,b):\n return (a*b)","def area(self):\n return self._width * self._height","def test_area(self):\r\n rect = Rectangle(30, 50, 130, 60)\r\n assert rect.area == 100 * 10\r\n\r\n rect = Rectangle(10.5, 20.7, 11.2, 50.6)\r\n assert abs(rect.area - 20.93) < 1e-10\r\n\r\n rect = Rectangle(-10, -20, 10, 60)\r\n assert rect.area == 20 * 80","def area(self):\n area = self.__size * self.__size\n return area","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(self):\n return math.pi * self._r ** 2","def island_perimeter(grid):\n perimeter = 0\n if not grid:\n return 0\n if not all(type(arr) == list for arr in grid):\n return 0\n al = len(grid[0])\n if not all(len(arr) == al for arr in grid):\n return 0\n al = al - 1\n gl = len(grid) - 1\n for cell, arr in enumerate(grid):\n for element, val in enumerate(arr):\n if (val == 1):\n if element == 0 or arr[element - 1] == 0:\n perimeter += 1\n if element == al or arr[element + 1] == 0:\n perimeter += 1\n if cell == 0 or grid[cell - 1][element] == 0:\n perimeter += 1\n if cell == gl or grid[cell + 1][element] == 0:\n perimeter += 1\n return perimeter"],"string":"[\n \"def perimeter(self):\",\n \"def perimeter(self):\\n\\t\\treturn 2 * (self.width + self.height)\",\n \"def calculateperimeter(self):\\r\\n return (self.width * 2) + (self.height * 2)\",\n \"def perimeter(self):\\r\\n return (2*self.width) + (2*self.height)\",\n \"def perimeter(self):\\n return 2 * (self.height + self.width)\",\n \"def perimeter(self):\\n return self.sidelength1 + self.sidelength2 + self.baselength1 + self.baselength2\",\n \"def perimeter(self):\\n\\t\\treturn self.height * 4\",\n \"def perimeter(self):\\n return (\\n self.side_1_length +\\n self.side_2_length +\\n self.side_3_length +\\n self.side_4_length\\n )\",\n \"def perimeter(self):\\n perimeter = (2 * self.__length) + (2 * self.__width)\\n\\n return perimeter\",\n \"def perimeter(self):\\r\\n\\r\\n return 2*math.pi*self.__radius\",\n \"def findArea(self):\\n\\n a, b = self.sides\\n area = a * b\\n print(f\\\"Are of rectangle is: {area}\\\")\",\n \"def perimeter(self):\\n return sum([s.length for s in self.segments])\",\n \"def getPerimeter(self):\\n return 2 * math.pi * self.__radius\",\n \"def perimeter(a:float, b:float, c:float):\\n return a + b + c\",\n \"def perimeter(self):\\n return sum(seg.length for seg in self.segments) + \\\\\\n sum([p.perimeter for p in self.subs])\",\n \"def perimeter(cnt):\\n\\treturn cv2.arcLength(cnt, True)\",\n \"def get_perimeter_formula(cls):\\n pass\",\n \"def perimeter(self):\\n return sum(self._lengths)\",\n \"def perimeter(self):\\n return sum(self._lengths)\",\n \"def rectangle_area(side1, side2):\\n return float(side1) * float(side2)\",\n \"def regular_polygon_area(perimeter, apothem):\\n return (perimeter * apothem) / 2\",\n \"def island_perimeter(grid):\\n \\\"\\\"\\\"island_perimeter - perimeter of the island\\n Parameter\\n ---------\\n grid:\\n list\\n Return\\n ------\\n int\\n \\\"\\\"\\\"\\n total = 0\\n\\n rows = len(grid)\\n columns = len(grid[0])\\n\\n for row in range(rows):\\n for col in range(columns):\\n array = grid[row][col]\\n if array == 1:\\n total += 4\\n if row != 0 and grid[row-1][col] == 1:\\n total -= 1\\n if col != 0 and grid[row][col-1] == 1:\\n total -= 1\\n if row + 1 != rows and grid[row + 1][col] == 1:\\n total -= 1\\n if col + 1 != columns and grid[row][col + 1] == 1:\\n total -= 1\\n\\n return total\",\n \"def perimeter(points):\\n return sum(get_distances(points))\",\n \"def rect(l, b):\\n print(\\\"Area of rectangle is\\\", l * b)\",\n \"def __CalculatePerimeter(self, curve):\\r\\n return cv2.arcLength(curve, True)\",\n \"def get_rect_perimeter(length, width):\\n length = (str)(length)\\n width = (str)(width)\\n if((length.isnumeric()) and (length.isnumeric())):\\n length = (float)(length)\\n width = (float)(width)\\n perimeter = 2 * (length + width)\\n else:\\n perimeter = \\\"Invalid input, length and width must be numeric value\\\"\\n return perimeter\",\n \"def square_area(side):\\n return side**2\",\n \"def island_perimeter(grid):\\n w = len(grid[0])\\n h = len(grid)\\n perimeter = 0\\n\\n for i, col in enumerate(grid):\\n for j, row in enumerate(col):\\n if row == 1:\\n perimeter += 4\\n if grid[i][j-1] == 1:\\n perimeter -= 1\\n if grid[i][(j+1) % w] == 1:\\n perimeter -= 1\\n if grid[(i+1) % h][j] == 1:\\n perimeter -= 1\\n if grid[i-1][j] == 1:\\n perimeter -= 1\\n return perimeter\",\n \"def island_perimeter(grid):\\n cx, cy = 0, 0\\n len_grid = len(grid)\\n for x in range(len_grid):\\n for y in range(len(grid[x])):\\n if grid[x][y] == 1:\\n cx += 1\\n if (y != len(grid[x]) - 1 and grid[x][y + 1] == 1):\\n cy += 1\\n if (x != len(grid) - 1 and grid[x + 1][y] == 1):\\n cy += 1\\n return 4 * cx - 2 * cy\",\n \"def rect_area(rect):\\n return rect[2] * rect[3]\",\n \"def area_rect(w, h):\\n return w * h\",\n \"def test_triangle_get_perimeter(self):\\n triangle = Triangle(0, 9, 10, 11)\\n self.assertEqual(triangle.get_perimeter(), 30)\",\n \"def island_perimeter(grid):\\n perimeter = 0\\n for j in range(len(grid)):\\n for i in range(len(grid[j])):\\n if grid[j][i] == 1:\\n perimeter += 4\\n if i is not 0 and grid[j][i - 1] is 1:\\n perimeter -= 1\\n if j is not 0 and grid[j - 1][i] is 1:\\n perimeter -= 1\\n if j + 1 < len(grid) and grid[j + 1][i] is 1:\\n perimeter -= 1\\n if i + 1 < len(grid[j]) and grid[j][i + 1] is 1:\\n perimeter -= 1\\n return perimeter\",\n \"def test_rectangle(self):\\n result = shape_area.rectangle_area(6,7)\\n self.assertEqual(result,26)\",\n \"def area(self):\\n return (self.baselength1 + self.baselength2)*self.height/2\",\n \"def island_perimeter(grid):\\n perimeter = 0\\n for x in range(len(grid)):\\n for y in range(len(grid[x])):\\n if grid[x][y] == 1:\\n if x == 0:\\n perimeter += 1\\n elif grid[x - 1][y] == 0:\\n perimeter += 1\\n if y == 0:\\n perimeter += 1\\n elif grid[x][y - 1] == 0:\\n perimeter += 1\\n if x == len(grid) - 1:\\n perimeter += 1\\n elif grid[x + 1][y] == 0:\\n perimeter += 1\\n if y == len(grid[0]) - 1:\\n perimeter += 1\\n elif grid[x][y + 1] == 0:\\n perimeter += 1\\n return perimeter\",\n \"def rectangle_area(width : number, height : number) ->number:\\n area = width*height\\n #print(\\\"The area of rectangle is =\\\", area, \\\"sq. units\\\")\\n return area\",\n \"def island_perimeter(grid):\\n c = 0\\n length = len(grid) - 1\\n width = len(grid[0]) - 1\\n\\n for i, r in enumerate(grid):\\n for j, n in enumerate(r):\\n if n == 1:\\n if i == 0 or grid[i - 1][j] != 1:\\n c += 1\\n if j == 0 or grid[i][j - 1] != 1:\\n c += 1\\n if j == width or grid[i][j + 1] != 1:\\n c += 1\\n if i == length or grid[i + 1][j] != 1:\\n c += 1\\n return c\",\n \"def perimeter(self) -> ir.FloatingValue:\\n return ops.GeoPerimeter(self).to_expr()\",\n \"def calculate_perimeter_ratio(gt_perimeter, perf_perimeter):\\n return min(gt_perimeter, perf_perimeter) / max(gt_perimeter, perf_perimeter)\",\n \"def area(self):\\r\\n return self.width * self.height\",\n \"def rectangle_area(base, height):\\n return (base * height)\",\n \"def island_perimeter(grid):\\n perimeter, connections = 0, 0\\n\\n for i in range(len(grid)):\\n for j in range(len(grid[i])):\\n if grid[i][j] == 1:\\n perimeter += 4\\n\\n if i != 0 and grid[i-1][j] == 1:\\n connections += 1\\n if j != 0 and grid[i][j-1] == 1:\\n connections += 1\\n\\n return(perimeter - (2 * connections))\",\n \"def area(self):\\n\\t\\treturn self.width * self.height\",\n \"def area(self):\\n\\t\\treturn self.width() * self.height()\",\n \"def island_perimeter(grid):\\n perimeter = 0\\n for row in grid + list(map(list, zip(*grid))):\\n for i, j in zip([0] + row, row + [0]):\\n perimeter += int(i != j)\\n return perimeter\",\n \"def calculatearea(self):\\r\\n return self.width * self.height\",\n \"def rectangle_circumference(a,b):\\n return (2*(a+b))\",\n \"def get_perimeter_formula(cls):\\n dict_perimieter = {'circle':\\\"2πr\\\", 'square':'2a+2b', 'rectangle':'2a+2b',\\n 'triangle':'3a',\\\"equilateral triangle\\\":'a+b+c',\\n 'regular pentagon':\\\"5a\\\"}\\n for k,v in dict_perimieter.items():\\n if cls.__name__ == k:\\n return v\",\n \"def area(self):\\n return(self.__width * self.__height)\",\n \"def island_perimeter(grid):\\n\\n count = 0\\n\\n for i in range(len(grid)):\\n for j in range(len(grid[0])):\\n mul = 4\\n if grid[i][j] == 1:\\n if j < len(grid[0]) - 1:\\n if grid[i][j + 1] == 1:\\n mul -= 1\\n if grid[i][j - 1] == 1 and j > 0:\\n mul -= 1\\n if i < len(grid) - 1:\\n if grid[i + 1][j] == 1:\\n mul -= 1\\n if grid[i - 1][j] == 1 and i > 0:\\n mul -= 1\\n else:\\n continue\\n count += mul\\n return count\",\n \"def area(self):\\n return self.width*self.height\",\n \"def rectArea(base, height):\\n return base * height\",\n \"def PolyPerimeter(Coords):\\n peri = 0.0\\n for i in range(np.shape(Coords)[0]-1):\\n # next point coord - current point coord\\n peri = peri + ( (Coords[i+1,0] - Coords[i,0])**2 + (Coords[i+1,1] - Coords[i,1])**2 )**0.5\\n\\n return peri\",\n \"def island_perimeter(grid):\\n total = 0\\n for x in range(0, len(grid)):\\n for y in range(0, len(grid[0])):\\n if grid[x][y] == 1:\\n if x == 0 or grid[x - 1][y] == 0:\\n total += 1\\n if x == len(grid) - 1 or grid[x + 1][y] == 0:\\n total += 1\\n if y == len(grid[0]) - 1 or grid[x][y + 1] == 0:\\n total += 1\\n if y == 0 or grid[x][y - 1] == 0:\\n total += 1\\n return total\",\n \"def add_perimeter(self, pt):\\n nn = [\\n (pt[0] + i, pt[1] + j)\\n for i, j in zip([1, -1, 0, 0], [0, 0, 1, -1])\\n ]\\n for p in nn:\\n if (\\n p not in self.cluster\\n and p not in self.perimeter\\n and p not in self.dead\\n ):\\n self.perimeter.add(p)\",\n \"def island_perimeter(grid):\\n perimeter = 0\\n for row in range(len(grid)):\\n for idx in range(len(grid[0])):\\n if grid[row][idx] == 1:\\n \\\"\\\"\\\"if 1 encountered check all sides for 0\\\"\\\"\\\"\\n top = row - 1\\n bottom = row + 1\\n left = idx - 1\\n right = idx + 1\\n\\n \\\"\\\"\\\"check top index value\\\"\\\"\\\"\\n if top < 0:\\n perimeter += 1\\n elif grid[row - 1][idx] != 1:\\n perimeter += 1\\n\\n \\\"\\\"\\\"check bottom index value\\\"\\\"\\\"\\n if bottom >= len(grid):\\n perimeter += 1\\n elif grid[row + 1][idx] != 1:\\n perimeter += 1\\n\\n \\\"\\\"\\\"check left index value\\\"\\\"\\\"\\n if left < 0:\\n perimeter += 1\\n elif grid[row][idx - 1] != 1:\\n perimeter += 1\\n\\n \\\"\\\"\\\"check right index value\\\"\\\"\\\"\\n if right >= len(grid[0]):\\n perimeter += 1\\n elif grid[row][idx + 1] != 1:\\n perimeter += 1\\n return perimeter\",\n \"def area(self):\\n return self.length*self.length\",\n \"def area(self):\\n return (self.width * self.height)\",\n \"def area(width, height):\\n return width * height\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def area_rectangle():\\n side_a = float(input(\\\"Enter the first side:\\\\n\\\"))\\n side_b = float(input(\\\"Enter the second side\\\\n\\\"))\\n return side_a * side_b\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def island_perimeter(grid):\\n LAND = 1\\n WATER = 0\\n perimeter = 0\\n for y, row in enumerate(grid):\\n for x, cell in enumerate(row):\\n if cell == LAND:\\n # print(\\\"land in [x= {:d} y= {:d}]\\\".format(x, y))\\n # left\\n if y == 0 or grid[y - 1][x] == WATER:\\n perimeter += 1\\n # right\\n if y == len(grid) - 1 or grid[y + 1][x] == WATER:\\n perimeter += 1\\n # up\\n if x == 0 or grid[y][x - 1] == WATER:\\n perimeter += 1\\n # down\\n if x == len(row) - 1 or grid[y][x + 1] == WATER:\\n perimeter += 1\\n return perimeter\",\n \"def area(self):\\n return self.width() * self.height()\",\n \"def area_equilat(side):\\n\\treturn side/2 * math.sqrt(side**2 - (side/2)**2)\",\n \"def area(self):\\n\\t\\treturn self.height * self.height\",\n \"def calculate(perimeter):\\n for a in range(1, perimeter):\\n if a > perimeter:\\n break\\n for b in range(1, perimeter):\\n if a + b > perimeter:\\n break\\n for c in range(1, perimeter):\\n if a + b + c > perimeter:\\n break\\n if a + b + c == perimeter and a ** 2 + b ** 2 == c ** 2:\\n answer = a * b * c\\n return answer\",\n \"def area(self):\\n return (self.__width * self.__height)\",\n \"def area(self):\\n return (self.__width * self.__height)\",\n \"def ask_perimeter(self):\\n\\n print(\\\"controller - ask_perimeter!\\\")\\n img_cv2_mask = self.pressure_img.mask\\n if self.pressure_img.perimetre_done:\\n self.view.popupmsg(\\\"El perímetre ja ha estat seleccionat\\\")\\n else:\\n self.pressure_img.roi_crop(img_cv2_mask, \\\"Perimeter\\\")\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area_rectangulo(b,h):\\n area = b*h\\n print \\\"El area es: \\\",area\",\n \"def square(side):\\n rectangle(side,side)\",\n \"def get_perimeter(self, radius: int = 1) -> set:\\n return self.get_neighbourhood(radius) - self.get_neighbourhood(radius - 1)\",\n \"def areaRect(length, width):\\n return length * width\",\n \"def rectangle_surface_area(a,b):\\n return (a*b)\",\n \"def area(self):\\n return self._width * self._height\",\n \"def test_area(self):\\r\\n rect = Rectangle(30, 50, 130, 60)\\r\\n assert rect.area == 100 * 10\\r\\n\\r\\n rect = Rectangle(10.5, 20.7, 11.2, 50.6)\\r\\n assert abs(rect.area - 20.93) < 1e-10\\r\\n\\r\\n rect = Rectangle(-10, -20, 10, 60)\\r\\n assert rect.area == 20 * 80\",\n \"def area(self):\\n area = self.__size * self.__size\\n return area\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return math.pi * self._r ** 2\",\n \"def island_perimeter(grid):\\n perimeter = 0\\n if not grid:\\n return 0\\n if not all(type(arr) == list for arr in grid):\\n return 0\\n al = len(grid[0])\\n if not all(len(arr) == al for arr in grid):\\n return 0\\n al = al - 1\\n gl = len(grid) - 1\\n for cell, arr in enumerate(grid):\\n for element, val in enumerate(arr):\\n if (val == 1):\\n if element == 0 or arr[element - 1] == 0:\\n perimeter += 1\\n if element == al or arr[element + 1] == 0:\\n perimeter += 1\\n if cell == 0 or grid[cell - 1][element] == 0:\\n perimeter += 1\\n if cell == gl or grid[cell + 1][element] == 0:\\n perimeter += 1\\n return perimeter\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8430252","0.83806247","0.83072674","0.8281285","0.8204777","0.81401604","0.805963","0.7651174","0.74341273","0.7422448","0.73345184","0.72595495","0.721846","0.7185834","0.7158701","0.7130895","0.7089875","0.70687634","0.70687634","0.6887997","0.6867396","0.6841587","0.6821271","0.6799287","0.67850417","0.6735902","0.67335665","0.6718945","0.66894716","0.66620463","0.6651936","0.664338","0.66277206","0.6607339","0.65728176","0.65588367","0.6551501","0.6499839","0.6498561","0.6483381","0.6481909","0.6468838","0.6456492","0.6452721","0.644101","0.6418482","0.64159656","0.64138204","0.64060366","0.6403498","0.6403341","0.640311","0.63799864","0.6376881","0.6375294","0.63734317","0.6356725","0.6334572","0.63339233","0.6328203","0.6327917","0.63267976","0.6296638","0.6296638","0.6296638","0.6296638","0.6296638","0.6296638","0.6296638","0.6296638","0.62921506","0.6289832","0.6287583","0.6275781","0.6274686","0.62742984","0.62742984","0.6269708","0.62500685","0.62500685","0.62500685","0.62500685","0.62500685","0.6247256","0.6247256","0.6247256","0.62390965","0.6229571","0.6225472","0.6223904","0.62098676","0.62062097","0.6206156","0.6195208","0.61926395","0.61926395","0.61926395","0.61926395","0.6189532","0.61895037"],"string":"[\n \"0.8430252\",\n \"0.83806247\",\n \"0.83072674\",\n \"0.8281285\",\n \"0.8204777\",\n \"0.81401604\",\n \"0.805963\",\n \"0.7651174\",\n \"0.74341273\",\n \"0.7422448\",\n \"0.73345184\",\n \"0.72595495\",\n \"0.721846\",\n \"0.7185834\",\n \"0.7158701\",\n \"0.7130895\",\n \"0.7089875\",\n \"0.70687634\",\n \"0.70687634\",\n \"0.6887997\",\n \"0.6867396\",\n \"0.6841587\",\n \"0.6821271\",\n \"0.6799287\",\n \"0.67850417\",\n \"0.6735902\",\n \"0.67335665\",\n \"0.6718945\",\n \"0.66894716\",\n \"0.66620463\",\n \"0.6651936\",\n \"0.664338\",\n \"0.66277206\",\n \"0.6607339\",\n \"0.65728176\",\n \"0.65588367\",\n \"0.6551501\",\n \"0.6499839\",\n \"0.6498561\",\n \"0.6483381\",\n \"0.6481909\",\n \"0.6468838\",\n \"0.6456492\",\n \"0.6452721\",\n \"0.644101\",\n \"0.6418482\",\n \"0.64159656\",\n \"0.64138204\",\n \"0.64060366\",\n \"0.6403498\",\n \"0.6403341\",\n \"0.640311\",\n \"0.63799864\",\n \"0.6376881\",\n \"0.6375294\",\n \"0.63734317\",\n \"0.6356725\",\n \"0.6334572\",\n \"0.63339233\",\n \"0.6328203\",\n \"0.6327917\",\n \"0.63267976\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.6296638\",\n \"0.62921506\",\n \"0.6289832\",\n \"0.6287583\",\n \"0.6275781\",\n \"0.6274686\",\n \"0.62742984\",\n \"0.62742984\",\n \"0.6269708\",\n \"0.62500685\",\n \"0.62500685\",\n \"0.62500685\",\n \"0.62500685\",\n \"0.62500685\",\n \"0.6247256\",\n \"0.6247256\",\n \"0.6247256\",\n \"0.62390965\",\n \"0.6229571\",\n \"0.6225472\",\n \"0.6223904\",\n \"0.62098676\",\n \"0.62062097\",\n \"0.6206156\",\n \"0.6195208\",\n \"0.61926395\",\n \"0.61926395\",\n \"0.61926395\",\n \"0.61926395\",\n \"0.6189532\",\n \"0.61895037\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6235728"},"document_rank":{"kind":"string","value":"87"}}},{"rowIdx":17080,"cells":{"query":{"kind":"string","value":"Compute area for the rectangle"},"document":{"kind":"string","value":"def areaRect(length, width):\n return length * width"},"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 rect_area(rect):\n return rect[2] * rect[3]","def area_rect(w, h):\n return w * h","def _area(bounds):\n return (bounds[0, 1] - bounds[0, 0]) * (bounds[1, 1] - bounds[1, 0])","def area(self):\n num_rows = self.row_end - self.row_start\n num_cols = self.col_end - self.col_start\n area = num_rows*num_cols\n return area","def rectangle_area(base, height):\n return (base * height)","def rectangle_area(coordinates):\n return (coordinates[2] - coordinates[0]) * (coordinates[3] - coordinates[1])","def findArea(self):\n\n a, b = self.sides\n area = a * b\n print(f\"Are of rectangle is: {area}\")","def area(self):\n if isinstance(self.crs, GeographicalCRS):\n major_axis = self.crs.ellipsoid.a\n minor_axis = self.crs.ellipsoid.b\n\n area = 0.0\n if major_axis == minor_axis: # Sphere\n for seg in self.segment_tuples:\n x1, y1 = seg[0]\n x2, y2 = seg[1]\n area += geodesy.spherical_area(major_axis, x1, y1, x2, y2)\n\n else:\n for seg in self.segment_tuples:\n x1, y1 = seg[0]\n x2, y2 = seg[1]\n area += geodesy.ellipsoidal_area(major_axis, minor_axis,\n x1, y1, x2, y2)\n\n else:\n # Cartesian coordinate systems\n x, y = self.coordinates\n x0 = np.min(x)\n area = (0.5*(x[0] + x[-1]) - x0) * (y[0] - y[-1])\n area += sum((0.5*(x[i+1]+x[i]) - x0) * (y[i+1] - y[i]) for i in range(len(x)-1))\n return abs(area) - sum(sub.area for sub in self.subs)","def calculatearea(self):\r\n return self.width * self.height","def rectangle_area(width : number, height : number) ->number:\n area = width*height\n #print(\"The area of rectangle is =\", area, \"sq. units\")\n return area","def area(self):\n return (self.baselength1 + self.baselength2)*self.height/2","def area(width, height):\n return width * height","def area(self):\n area = self.__width * self.__height\n return area","def area(self):\n return(self.__width * self.__height)","def area(self):\n return 0.5*np.abs(np.dot(self.x,np.roll(self.y,1))-np.dot(self.y,np.roll(self.x,1)))","def total_area(self):\n return numpy.prod([r[1] - r[0] for r in self.range_])","def rectangle_area(side1, side2):\n return float(side1) * float(side2)","def area(self):\n\n return (self.x1 - self.x0) * (self.y1 - self.y0)","def area(self):\n return self.__height * self.__width","def area(self):\n return self.__height * self.__width","def area(self):\n return self.__height * self.__width","def area(self):\n area = self.__size * self.__size\n return area","def area(x, y):\n return x*y/2","def area(self):\n\t\treturn self.width * self.height","def rectArea(base, height):\n return base * height","def area(base, height):\n\n return base * height","def area(self):\n area = self.__length * self.__width\n\n return area","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n return self.__width * self.__height","def area(self):\n\t\treturn self.height * self.height","def area(self):\n return self.width*self.height","def area(self):\r\n return self.width * self.height","def area(self):\n return (self.__width * self.__height)","def area(self):\n return (self.__width * self.__height)","def area(self):\n\t\treturn self.width() * self.height()","def area(self):\n area = self.__size * self.__size\n return(area)","def area(self) -> float:\n raise NotImplementedError","def area(self):\n return self._width * self._height","def area(self):\n return (self.width * self.height)","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n return self.width * self.height","def area(self):\n area = 0\n\n for room in self.rooms:\n area += room.polygon.area()\n\n for wall in self.walls:\n area += wall.polygon.area()\n\n return area","def area(self):\n return self.width() * self.height()","def area(self):\n area = 0\n last = self._coordinates[-1]\n for c in self._coordinates:\n area += (last[0] * c[1] - last[1] * c[0])\n last = c\n return float(\"{:.2f}\".format(abs(area) * 0.5))","def area(self):\n\n return self.__width * self.__height","def area(self):\n\n return self.__width * self.__height","def area(self):\n\n return self.__width * self.__height","def area(self):\n return self.length*self.length","def area(self) -> torch.Tensor:\n box = self.tensor\n area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])\n return area","def area(self, boxes):\n with tf.name_scope('area'):\n ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1)\n return (ymax - ymin) * (xmax - xmin)","def area_of(self, left_top, right_bottom):\n hw = np.clip(right_bottom - left_top, 0.0, None)\n return hw[..., 0] * hw[..., 1]","def area(self):\n return self._ned_shape.area","def areaOfQuadrilateral(rect):\n rect = np.array(rect)\n A = rect[..., 0, :]\n B = rect[..., 1, :]\n C = rect[..., 2, :]\n D = rect[..., 3, :]\n return 0.5 * np.abs((A[..., 1] - C[..., 1]) * (D[..., 0] - B[..., 0]) + (B[..., 1] - D[..., 1]) * (A[..., 0] - C[..., 0]))","def area(self):\n return numpy.prod(\n numpy.meshgrid(*self.binwidths, indexing='ij'), axis=0)","def area(self):\n if len(self.exterior) < 3:\n raise Exception(\"Cannot compute the polygon's area because it contains less than three points.\")\n poly = self.to_shapely_polygon()\n return poly.area","def test_rectangle_area(self):\n self.assertEqual(12, rectangle_area(\n self.values['base'], self.values['height']))","def test_area(self):\r\n rect = Rectangle(30, 50, 130, 60)\r\n assert rect.area == 100 * 10\r\n\r\n rect = Rectangle(10.5, 20.7, 11.2, 50.6)\r\n assert abs(rect.area - 20.93) < 1e-10\r\n\r\n rect = Rectangle(-10, -20, 10, 60)\r\n assert rect.area == 20 * 80","def area(self):\n\n bbox = self.bbox\n area = Box.calculate_bbox_area(bbox, bbox_type=self.bbox_type)\n\n return area","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(self):\n return self.__size * self.__size","def area(boxes):\n y_min, x_min, y_max, x_max = np.split(boxes, 4, axis=-1)\n return np.squeeze((y_max - y_min) * (x_max - x_min), [1])","def calculate_area(length: int, width: int) -> int:\n\n # process\n area = length * width\n\n # output\n return area","def box_area(box):\n x1, y1, x2, y2 = box\n w = x2 - x1\n h = y2 - y1\n return float(w) * h","def test_rectangle(self):\n result = shape_area.rectangle_area(6,7)\n self.assertEqual(result,26)","def area(self):\n return (self.__size * self.__size)","def area(self):\n return (self.__size * self.__size)","def area(self):\n return (self.__size * self.__size)","def area(symbol):\n return (symbol.bounding_box.vertices[2].x - symbol.bounding_box.vertices[0].x) * (\n symbol.bounding_box.vertices[2].y - symbol.bounding_box[0].y)","def area(self):\n return _property_op(arctern.ST_Area, self)","def area(\n self):\n pi = numpy.pi\n area0 = 4.0 * pi / 8.0\n areadiv = 4.0 ** self.depth\n area = area0 / areadiv * (180.0 / pi) ** 2\n return area","def area(self):\n return self.__size ** 2","def area(x1, y1, x2, y2, x3, y3):\n return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0)","def area(self):\n area = self._lengths[0] * self._lengths[1] * math.sin(math.radians(self._angles[0]))\n area += self._lengths[2] * self._lengths[3] * math.sin(math.radians(self._angles[0]))\n return float('{:.2f}'.format(area * 0.5))","def area(self):\n return self.__size ** 2","def area(self):\n return self.__size ** 2","def area(self):\n return self.__size ** 2","def area(self):\n return self.__size ** 2","def compute_area(self):\r\n\r\n \"\"\"Косое произведение векторов\r\n A = (x2-x1; y2-y1; z2-z1)\r\n B = (x3-x1; y3-y1; z3-z1)\r\n S = 0.5*sqrt((Ay*Bz - Az*By)^2 + (Az*Bx - Ax*Bz)^2 + (Ax*By - Ay*Bx)^2 )\r\n \"\"\"\r\n a_x = self.x2 - self.x1\r\n a_y = self.y2 - self.y1\r\n a_z = self.z2 - self.z1\r\n\r\n b_x = self.x3 - self.x1\r\n b_y = self.y3 - self.y1\r\n b_z = self.z3 - self.z1\r\n\r\n self.area = 0.5 * math.sqrt((a_y * b_z - a_z * b_y) ** 2 + (a_z * b_x - a_x * b_z) ** 2 + (a_x * b_y - a_y * b_x) ** 2)\r\n\r\n \"\"\"По теореме Герона\"\"\"\r\n # a = math.sqrt((self.x1-self.x2)**2 + (self.y1-self.y2)**2 + (self.z1-self.z2)**2)\r\n # b = math.sqrt((self.x1-self.x3)**2 + (self.y1-self.y3)**2 + (self.z1-self.z3)**2)\r\n # c = math.sqrt((self.x2-self.x3)**2 + (self.y2-self.y3)**2 + (self.z2-self.z3)**2)\r\n # p = 0.5 * (a + b + c)\r\n # self.area = math.sqrt(p * (p - a) * (p - b) * (p - c))\r","def area(boxes):\n return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])","def area(self) -> float:\n return cross3(self.b.position - self.a.position,\n self.c.position - self.a.position).length() / 2.0","def area_rectangulo(b,h):\n area = b*h\n print \"El area es: \",area","def area(boxes):\n return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])","def area_of(left_top, right_bottom):\n hw = np.clip(right_bottom - left_top, 0.0, None)\n return hw[..., 0] * hw[..., 1]","def area_of(left_top, right_bottom):\n hw = np.clip(right_bottom - left_top, 0.0, None)\n return hw[..., 0] * hw[..., 1]","def compute_area(boxes):\n area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\n\n return area","def area(self):\n return int(self.__size) * int(self.__size)","def area(self):\n return (self.__size ** 2)","def area(self):\n return (self.__size ** 2)","def area(self):\n return (self.__size ** 2)"],"string":"[\n \"def rect_area(rect):\\n return rect[2] * rect[3]\",\n \"def area_rect(w, h):\\n return w * h\",\n \"def _area(bounds):\\n return (bounds[0, 1] - bounds[0, 0]) * (bounds[1, 1] - bounds[1, 0])\",\n \"def area(self):\\n num_rows = self.row_end - self.row_start\\n num_cols = self.col_end - self.col_start\\n area = num_rows*num_cols\\n return area\",\n \"def rectangle_area(base, height):\\n return (base * height)\",\n \"def rectangle_area(coordinates):\\n return (coordinates[2] - coordinates[0]) * (coordinates[3] - coordinates[1])\",\n \"def findArea(self):\\n\\n a, b = self.sides\\n area = a * b\\n print(f\\\"Are of rectangle is: {area}\\\")\",\n \"def area(self):\\n if isinstance(self.crs, GeographicalCRS):\\n major_axis = self.crs.ellipsoid.a\\n minor_axis = self.crs.ellipsoid.b\\n\\n area = 0.0\\n if major_axis == minor_axis: # Sphere\\n for seg in self.segment_tuples:\\n x1, y1 = seg[0]\\n x2, y2 = seg[1]\\n area += geodesy.spherical_area(major_axis, x1, y1, x2, y2)\\n\\n else:\\n for seg in self.segment_tuples:\\n x1, y1 = seg[0]\\n x2, y2 = seg[1]\\n area += geodesy.ellipsoidal_area(major_axis, minor_axis,\\n x1, y1, x2, y2)\\n\\n else:\\n # Cartesian coordinate systems\\n x, y = self.coordinates\\n x0 = np.min(x)\\n area = (0.5*(x[0] + x[-1]) - x0) * (y[0] - y[-1])\\n area += sum((0.5*(x[i+1]+x[i]) - x0) * (y[i+1] - y[i]) for i in range(len(x)-1))\\n return abs(area) - sum(sub.area for sub in self.subs)\",\n \"def calculatearea(self):\\r\\n return self.width * self.height\",\n \"def rectangle_area(width : number, height : number) ->number:\\n area = width*height\\n #print(\\\"The area of rectangle is =\\\", area, \\\"sq. units\\\")\\n return area\",\n \"def area(self):\\n return (self.baselength1 + self.baselength2)*self.height/2\",\n \"def area(width, height):\\n return width * height\",\n \"def area(self):\\n area = self.__width * self.__height\\n return area\",\n \"def area(self):\\n return(self.__width * self.__height)\",\n \"def area(self):\\n return 0.5*np.abs(np.dot(self.x,np.roll(self.y,1))-np.dot(self.y,np.roll(self.x,1)))\",\n \"def total_area(self):\\n return numpy.prod([r[1] - r[0] for r in self.range_])\",\n \"def rectangle_area(side1, side2):\\n return float(side1) * float(side2)\",\n \"def area(self):\\n\\n return (self.x1 - self.x0) * (self.y1 - self.y0)\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area(self):\\n return self.__height * self.__width\",\n \"def area(self):\\n area = self.__size * self.__size\\n return area\",\n \"def area(x, y):\\n return x*y/2\",\n \"def area(self):\\n\\t\\treturn self.width * self.height\",\n \"def rectArea(base, height):\\n return base * height\",\n \"def area(base, height):\\n\\n return base * height\",\n \"def area(self):\\n area = self.__length * self.__width\\n\\n return area\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.__width * self.__height\",\n \"def area(self):\\n\\t\\treturn self.height * self.height\",\n \"def area(self):\\n return self.width*self.height\",\n \"def area(self):\\r\\n return self.width * self.height\",\n \"def area(self):\\n return (self.__width * self.__height)\",\n \"def area(self):\\n return (self.__width * self.__height)\",\n \"def area(self):\\n\\t\\treturn self.width() * self.height()\",\n \"def area(self):\\n area = self.__size * self.__size\\n return(area)\",\n \"def area(self) -> float:\\n raise NotImplementedError\",\n \"def area(self):\\n return self._width * self._height\",\n \"def area(self):\\n return (self.width * self.height)\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n return self.width * self.height\",\n \"def area(self):\\n area = 0\\n\\n for room in self.rooms:\\n area += room.polygon.area()\\n\\n for wall in self.walls:\\n area += wall.polygon.area()\\n\\n return area\",\n \"def area(self):\\n return self.width() * self.height()\",\n \"def area(self):\\n area = 0\\n last = self._coordinates[-1]\\n for c in self._coordinates:\\n area += (last[0] * c[1] - last[1] * c[0])\\n last = c\\n return float(\\\"{:.2f}\\\".format(abs(area) * 0.5))\",\n \"def area(self):\\n\\n return self.__width * self.__height\",\n \"def area(self):\\n\\n return self.__width * self.__height\",\n \"def area(self):\\n\\n return self.__width * self.__height\",\n \"def area(self):\\n return self.length*self.length\",\n \"def area(self) -> torch.Tensor:\\n box = self.tensor\\n area = (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])\\n return area\",\n \"def area(self, boxes):\\n with tf.name_scope('area'):\\n ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1)\\n return (ymax - ymin) * (xmax - xmin)\",\n \"def area_of(self, left_top, right_bottom):\\n hw = np.clip(right_bottom - left_top, 0.0, None)\\n return hw[..., 0] * hw[..., 1]\",\n \"def area(self):\\n return self._ned_shape.area\",\n \"def areaOfQuadrilateral(rect):\\n rect = np.array(rect)\\n A = rect[..., 0, :]\\n B = rect[..., 1, :]\\n C = rect[..., 2, :]\\n D = rect[..., 3, :]\\n return 0.5 * np.abs((A[..., 1] - C[..., 1]) * (D[..., 0] - B[..., 0]) + (B[..., 1] - D[..., 1]) * (A[..., 0] - C[..., 0]))\",\n \"def area(self):\\n return numpy.prod(\\n numpy.meshgrid(*self.binwidths, indexing='ij'), axis=0)\",\n \"def area(self):\\n if len(self.exterior) < 3:\\n raise Exception(\\\"Cannot compute the polygon's area because it contains less than three points.\\\")\\n poly = self.to_shapely_polygon()\\n return poly.area\",\n \"def test_rectangle_area(self):\\n self.assertEqual(12, rectangle_area(\\n self.values['base'], self.values['height']))\",\n \"def test_area(self):\\r\\n rect = Rectangle(30, 50, 130, 60)\\r\\n assert rect.area == 100 * 10\\r\\n\\r\\n rect = Rectangle(10.5, 20.7, 11.2, 50.6)\\r\\n assert abs(rect.area - 20.93) < 1e-10\\r\\n\\r\\n rect = Rectangle(-10, -20, 10, 60)\\r\\n assert rect.area == 20 * 80\",\n \"def area(self):\\n\\n bbox = self.bbox\\n area = Box.calculate_bbox_area(bbox, bbox_type=self.bbox_type)\\n\\n return area\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(self):\\n return self.__size * self.__size\",\n \"def area(boxes):\\n y_min, x_min, y_max, x_max = np.split(boxes, 4, axis=-1)\\n return np.squeeze((y_max - y_min) * (x_max - x_min), [1])\",\n \"def calculate_area(length: int, width: int) -> int:\\n\\n # process\\n area = length * width\\n\\n # output\\n return area\",\n \"def box_area(box):\\n x1, y1, x2, y2 = box\\n w = x2 - x1\\n h = y2 - y1\\n return float(w) * h\",\n \"def test_rectangle(self):\\n result = shape_area.rectangle_area(6,7)\\n self.assertEqual(result,26)\",\n \"def area(self):\\n return (self.__size * self.__size)\",\n \"def area(self):\\n return (self.__size * self.__size)\",\n \"def area(self):\\n return (self.__size * self.__size)\",\n \"def area(symbol):\\n return (symbol.bounding_box.vertices[2].x - symbol.bounding_box.vertices[0].x) * (\\n symbol.bounding_box.vertices[2].y - symbol.bounding_box[0].y)\",\n \"def area(self):\\n return _property_op(arctern.ST_Area, self)\",\n \"def area(\\n self):\\n pi = numpy.pi\\n area0 = 4.0 * pi / 8.0\\n areadiv = 4.0 ** self.depth\\n area = area0 / areadiv * (180.0 / pi) ** 2\\n return area\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def area(x1, y1, x2, y2, x3, y3):\\n return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0)\",\n \"def area(self):\\n area = self._lengths[0] * self._lengths[1] * math.sin(math.radians(self._angles[0]))\\n area += self._lengths[2] * self._lengths[3] * math.sin(math.radians(self._angles[0]))\\n return float('{:.2f}'.format(area * 0.5))\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def area(self):\\n return self.__size ** 2\",\n \"def compute_area(self):\\r\\n\\r\\n \\\"\\\"\\\"Косое произведение векторов\\r\\n A = (x2-x1; y2-y1; z2-z1)\\r\\n B = (x3-x1; y3-y1; z3-z1)\\r\\n S = 0.5*sqrt((Ay*Bz - Az*By)^2 + (Az*Bx - Ax*Bz)^2 + (Ax*By - Ay*Bx)^2 )\\r\\n \\\"\\\"\\\"\\r\\n a_x = self.x2 - self.x1\\r\\n a_y = self.y2 - self.y1\\r\\n a_z = self.z2 - self.z1\\r\\n\\r\\n b_x = self.x3 - self.x1\\r\\n b_y = self.y3 - self.y1\\r\\n b_z = self.z3 - self.z1\\r\\n\\r\\n self.area = 0.5 * math.sqrt((a_y * b_z - a_z * b_y) ** 2 + (a_z * b_x - a_x * b_z) ** 2 + (a_x * b_y - a_y * b_x) ** 2)\\r\\n\\r\\n \\\"\\\"\\\"По теореме Герона\\\"\\\"\\\"\\r\\n # a = math.sqrt((self.x1-self.x2)**2 + (self.y1-self.y2)**2 + (self.z1-self.z2)**2)\\r\\n # b = math.sqrt((self.x1-self.x3)**2 + (self.y1-self.y3)**2 + (self.z1-self.z3)**2)\\r\\n # c = math.sqrt((self.x2-self.x3)**2 + (self.y2-self.y3)**2 + (self.z2-self.z3)**2)\\r\\n # p = 0.5 * (a + b + c)\\r\\n # self.area = math.sqrt(p * (p - a) * (p - b) * (p - c))\\r\",\n \"def area(boxes):\\n return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\",\n \"def area(self) -> float:\\n return cross3(self.b.position - self.a.position,\\n self.c.position - self.a.position).length() / 2.0\",\n \"def area_rectangulo(b,h):\\n area = b*h\\n print \\\"El area es: \\\",area\",\n \"def area(boxes):\\n return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\",\n \"def area_of(left_top, right_bottom):\\n hw = np.clip(right_bottom - left_top, 0.0, None)\\n return hw[..., 0] * hw[..., 1]\",\n \"def area_of(left_top, right_bottom):\\n hw = np.clip(right_bottom - left_top, 0.0, None)\\n return hw[..., 0] * hw[..., 1]\",\n \"def compute_area(boxes):\\n area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\\n\\n return area\",\n \"def area(self):\\n return int(self.__size) * int(self.__size)\",\n \"def area(self):\\n return (self.__size ** 2)\",\n \"def area(self):\\n return (self.__size ** 2)\",\n \"def area(self):\\n return (self.__size ** 2)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8253932","0.8153468","0.8056531","0.80223805","0.79693747","0.79442996","0.7873636","0.7872711","0.78698665","0.786057","0.784172","0.7819327","0.7814251","0.7764691","0.7752274","0.77518463","0.7743629","0.77320397","0.77025086","0.77025086","0.77025086","0.76791716","0.7669599","0.7650863","0.76463825","0.763407","0.7632357","0.76227623","0.76227623","0.76227623","0.76227623","0.76227623","0.7616197","0.7615017","0.7608396","0.7603979","0.7603979","0.7598873","0.75958395","0.7593582","0.7591159","0.7590689","0.756445","0.756445","0.756445","0.756445","0.756445","0.756445","0.756445","0.756445","0.7551354","0.7527621","0.75078803","0.7506018","0.7506018","0.7506018","0.7490153","0.74900407","0.7480523","0.7479202","0.74677557","0.7439648","0.7423124","0.7409045","0.74014974","0.739192","0.737114","0.73630697","0.73630697","0.73630697","0.73630697","0.735864","0.73417014","0.7327066","0.7315502","0.7276896","0.7276896","0.7276896","0.7269495","0.7268617","0.72604847","0.7259033","0.72582984","0.72456336","0.7233892","0.7233892","0.7233892","0.7233892","0.7233472","0.7221193","0.72147447","0.72123873","0.71943253","0.71789545","0.71789545","0.7175298","0.71703726","0.7168502","0.7168502","0.7168502"],"string":"[\n \"0.8253932\",\n \"0.8153468\",\n \"0.8056531\",\n \"0.80223805\",\n \"0.79693747\",\n \"0.79442996\",\n \"0.7873636\",\n \"0.7872711\",\n \"0.78698665\",\n \"0.786057\",\n \"0.784172\",\n \"0.7819327\",\n \"0.7814251\",\n \"0.7764691\",\n \"0.7752274\",\n \"0.77518463\",\n \"0.7743629\",\n \"0.77320397\",\n \"0.77025086\",\n \"0.77025086\",\n \"0.77025086\",\n \"0.76791716\",\n \"0.7669599\",\n \"0.7650863\",\n \"0.76463825\",\n \"0.763407\",\n \"0.7632357\",\n \"0.76227623\",\n \"0.76227623\",\n \"0.76227623\",\n \"0.76227623\",\n \"0.76227623\",\n \"0.7616197\",\n \"0.7615017\",\n \"0.7608396\",\n \"0.7603979\",\n \"0.7603979\",\n \"0.7598873\",\n \"0.75958395\",\n \"0.7593582\",\n \"0.7591159\",\n \"0.7590689\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.756445\",\n \"0.7551354\",\n \"0.7527621\",\n \"0.75078803\",\n \"0.7506018\",\n \"0.7506018\",\n \"0.7506018\",\n \"0.7490153\",\n \"0.74900407\",\n \"0.7480523\",\n \"0.7479202\",\n \"0.74677557\",\n \"0.7439648\",\n \"0.7423124\",\n \"0.7409045\",\n \"0.74014974\",\n \"0.739192\",\n \"0.737114\",\n \"0.73630697\",\n \"0.73630697\",\n \"0.73630697\",\n \"0.73630697\",\n \"0.735864\",\n \"0.73417014\",\n \"0.7327066\",\n \"0.7315502\",\n \"0.7276896\",\n \"0.7276896\",\n \"0.7276896\",\n \"0.7269495\",\n \"0.7268617\",\n \"0.72604847\",\n \"0.7259033\",\n \"0.72582984\",\n \"0.72456336\",\n \"0.7233892\",\n \"0.7233892\",\n \"0.7233892\",\n \"0.7233892\",\n \"0.7233472\",\n \"0.7221193\",\n \"0.72147447\",\n \"0.72123873\",\n \"0.71943253\",\n \"0.71789545\",\n \"0.71789545\",\n \"0.7175298\",\n \"0.71703726\",\n \"0.7168502\",\n \"0.7168502\",\n \"0.7168502\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77284664"},"document_rank":{"kind":"string","value":"18"}}},{"rowIdx":17081,"cells":{"query":{"kind":"string","value":"Global variables available in all templates"},"document":{"kind":"string","value":"def global_variables(request):\n data = {\n 'DEBUG': settings.DEBUG,\n }\n return data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def global_variables():\n item_catalog_app.jinja_env.globals[\"ALL_CATEGORIES\"] = act.all_categories()\n __logged_in_user__ = act.user(\n pointer=login_session.get(\"user_id\")\n )\n item_catalog_app.jinja_env.globals[\"USER\"] = __logged_in_user__\n g.USER = __logged_in_user__","def inject_dict_for_all_templates():\n global_vars = {\"settings\": settings}\n\n if is_authenticated():\n global_vars[\"user\"] = get_authenticated_user()\n\n return global_vars","def get_global_vars(self) -> str:\n return templates.GLOBAL_STATEMENTS","def test_with_global(self):\n t = Template(\n '{% load djblets_utils %}'\n '{% block main %}'\n '{% block inner %}'\n '{% definevar \"myvar\" global %}{{num}}{% enddefinevar %}'\n '{% endblock %}'\n '{% endblock %}'\n '[{{myvar}}]')\n\n self.assertEqual(\n t.render(Context({\n 'num': 123,\n })),\n '[123]')","def template_context(request):\n context = {\n 'application_version': settings.APPLICATION_VERSION,\n }\n context.update(settings.STATIC_CONTEXT_VARS)\n return context","def settings(request):\n return {\"SETTINGS\": django_settings, \"GLOBAL_DEFINITIONS\": global_definitions}","def set_jinja_globals():\n\n # The resource keys will not be present.\n ufo.app.logger.info('Start setting resources into jinja globals.\\n'\n 'Current jinja globals: %s' %\n ufo.app.jinja_env.globals.keys())\n\n ufo.app.jinja_env.globals['resources'] = json.dumps(_get_resources())\n\n # The resource keys should be present if set.\n ufo.app.logger.info('Finished setting resources into jinja globals.\\n'\n 'Current jinja globals: %s' %\n ufo.app.jinja_env.globals.keys())","def __context(self):\r\n # TODO: do we need to include anything else?\r\n # TODO: do this with the django-settings-context-processor\r\n return {\r\n \"FEATURES\": settings.FEATURES,\r\n \"THEME_NAME\" : getattr(settings, \"THEME_NAME\", None),\r\n }","def set_jinja_before_request():\n resource_provider.set_jinja_globals()","def add_renderer_globals(event):\n request = event.get('request')\n # add globals for i18n\n event['_'] = request.translate\n event['localizer'] = request.localizer\n # add application globals from the config file\n settings = request.registry.settings\n event['brand_name'] = settings['anuket.brand_name']","def setup_templates(self):\n self.libs[\"template\"] = (\"#libs/templates/include\", None, \"\")\n self[\"CPPPATH\"].append(\"#libs/templates/include\")","def set_vars():\n return dict()","def extra_context(self):\n from django.conf import settings\n\n return {\n \"site_name\": (lambda r: settings.LEONARDO_SITE_NAME\n if getattr(settings, 'LEONARDO_SITE_NAME', '') != ''\n else settings.SITE_NAME),\n \"debug\": lambda r: settings.TEMPLATE_DEBUG\n }","def init_locals(self):\n pass","def add_renderer_globals(event):\n request = event.get('request')\n if request is None:\n request = get_current_request()\n globs = {\n 'url': route_url,\n 'h': None,\n 'a_url': request.application_url,\n 'user': authenticated_userid(request),\n 'repo': Repo(request.registry.settings.get('git_repo', '.'))\n }\n if request is not None:\n tmpl_context = request.tmpl_context\n globs['c'] = tmpl_context\n globs['tmpl_context'] = tmpl_context\n try:\n globs['session'] = request.session\n except ConfigurationError:\n pass\n event.update(globs)","def __init__(self, *args, **kwargs):\r\n if not kwargs.get('no_django', False):\r\n overrides = {k: getattr(edxmako, k, None) for k in DJANGO_VARIABLES}\r\n overrides['lookup'] = edxmako.LOOKUP['main']\r\n kwargs.update(overrides)\r\n super(Template, self).__init__(*args, **kwargs)","def template_extra_functions(self):\n\t\treturn []","def global_jinja_env():\n return _ENV","def settings(request):\n from django.conf import settings\n return {\n 'exhibitBaseTemplate': settings.EXHIBIT_TEMPLATE,\n 'thumbnailUrl': settings.THUMBNAIL_URL,\n 'calisphere': settings.CALISPHERE\n }","def inject_global():\n return {\n 'user': 'Pythonista'\n }","def T(request):\n\treturn all_templates[request.param]","def load_jinja_fns(self):\n\n\t\t# Function for jinja, to remove duplicates from flashed messages\n\t\tdef remove_duplicates(msgs):\n\t\t\tuniq_msgs = []\n\t\t\tfor msg in msgs:\n\t\t\t\tif msg not in uniq_msgs:\n\t\t\t\t\tuniq_msgs.append(msg)\n\n\t\t\treturn uniq_msgs\n\n\t\tcurrent_app.jinja_env.globals.update(remove_duplicates=remove_duplicates)","def renderer_globals_factory(system):\n return {'current_language': get_localizer(system['request']).locale_name,}","def common_vars(environ):\n fields = getFields(environ)\n tooltips = getTooltips()\n usersign = environ['tiddlyweb.usersign']\n if not 'fields' in usersign:\n usersign['fields'] = {'name': ''}\n captcha = process_captcha(environ)\n query = environ['tiddlyweb.query']\n\n return {'fields':fields, 'tooltips':tooltips, 'usersign':usersign, 'captcha':captcha, 'query':query}","def all_common_variables(request):\n articles = Article.objects.all()\n random_article = Article.objects.order_by('?')[0:4]\n return {\n 'articles':articles,\n 'random_article':random_article,\n }","def defaultTemplateParameter(self):\n self.tplparam['BODY'] = self.content\n self.tplparam['FLASH'] = (self.flash or '').replace('\"', r'\\\"')\n self.tplparam['PYMFRAMEVERSION'] = self.pymframeversion\n self.tplparam['USER'] = self.session.getAttribute(self.settings.authenvar)\n self.tplparam['RIGHTS'] = repr(self.session.getAttribute('rights'))\n self.tplparam['MENU'] = self.routing.getMenu(self.path,self.checkRights)\n self.tplparam['PATH'] = self.path","def standard_variables(self):\n\t\tstd_vars = {\n\t\t\t'time': {\n\t\t\t\t'local': datetime.datetime.now(),\n\t\t\t\t'utc': datetime.datetime.utcnow()\n\t\t\t}\n\t\t}\n\t\treturn std_vars","def default_context_setup(context):\n context['href'] = href\n context['static'] = static\n context['session'] = session\n context['flash_message'] = flash_message\n context['debug'] = application.debug\n context['Markup'] = genshi.Markup","def _globals(self):\n return self.__globals","def init_vars():\n\tda_vinci.base.usepackage(\"pgfkeys\")\n\tda_vinci.base.add_preamble(setup_script)","def add_renderer_globals(event):\r\n request = event['request']\r\n event['_'] = request.translate\r\n event['ungettext'] = request.ungettext\r\n event['localizer'] = request.localizer","def init_vars(self):\n # type: () -> None\n raise NotImplementedError","def global_values(self):\n return self.globals.values()","def set_global_vars():\n global_vars = {\"status\": False}\n try:\n global_vars[\"Owner\"] = \"Mystique\"\n global_vars[\"Environment\"] = \"Prod\"\n global_vars[\"aws_region\"] = \"us-east-1\"\n global_vars[\"tag_name\"] = \"serverless_cloudwatch_logs_exporter\"\n global_vars[\"retention_days\"] = 35\n global_vars[\"cw_logs_to_export\"] = [\"/aws/lambda/trending_news\"]\n #global_vars[\"cw_logs_to_export\"] = os.environ.get(\"cw_logs_to_export\").split(\",\")\n global_vars[\"log_dest_bkt\"] = \"cw-log-exports-01\"\n global_vars[\"time_out\"] = 300\n global_vars[\"tsk_back_off\"] = 2\n global_vars[\"status\"] = True\n except Exception as e:\n logger.error(\"Unable to set Global Environment variables. Exiting\")\n global_vars[\"error_message\"] = str(e)\n return global_vars","def global_var(name: str) -> SetupVal:\n return GlobalVarVal(name)","def common_context(request):\n c = {\n 'lessons': get_lesson_numbers(),\n }\n return c","def _var(self, name=None, context=None):\n\t\tif name is None: name = None\n\t\tif context is None: context = self.context\n\t\tif (not name):\n\t\t\treturn context.getVariables().keys()\n\t\telif True:\n\t\t\treturn context.getVariables().get(name)","def variables(self):\n return self._.vars","def test_basic_usage(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" %}\\n'\n 'test{{num}}\\n'\n '{% enddefinevar %}'\n '{{myvar}}')\n\n self.assertEqual(\n t.render(Context({\n 'num': 123,\n })),\n '\\ntest123\\n')","def variables_declared (self) :\r\n\t\treturn {}","def _init_vars(self):\n if not self._has(\"vars\"):\n if self._has(\"p\"):\n self._.vars = self._.p.variables()\n elif self._has(\"q\"):\n self._.vars = self._.q.variables()\n elif self._has(\"P\"):\n self._.vars = variables(self._.P)\n elif self._has(\"Q\"):\n self._.vars = variables(self._.Q)\n self._.vars_ordered = len(self._.vars) <= 1","def _init_tkvars(self,PO):\n for name,param in PO.params().items():\n self._create_tkvar(PO,name,param)","def _get_test_variables():\n if __name__ == \"__main__\":\n return _MOCKUP_TEST_VARIABLES\n else:\n return BuiltIn().get_variables()","def is_global(self, key):\n return key in dir(django_global_settings)","def angular_js_tests(request):\n return locals()","def _load_settings_to_jinja_env(self) :\n\t\t# Load filters if exists\n\t\tif hasattr(self.settings, 'FILTERS') :\n\t\t\tfor name, cls in utils.load_module(self.settings.FILTERS).__dict__.items() :\n\t\t\t\tself.jinja_env.filters[name] = cls\n\n\n\t\t# Load globals if exists\n\t\tif hasattr(self.settings, 'GLOBALS') :\n\t\t\tfor name, cls in utils.load_module(self.settings.GLOBALS).__dict__.items() :\n\t\t\t\tself.jinja_env.globals[name] = cls","def _globals(self):\n return self.dicts[0]._globals()","def __init__(self, template_env):\r\n self._template_env = template_env\r\n self._pythons = []","def request_vars(self):","def initGlobals():\n libxml2mod.xmlInitGlobals()","def environment(request):\n context = {\n 'COMPRESS_ENABLED': settings.COMPRESS_ENABLED,\n 'GOOGLE_ANALYTICS_CODE': getattr(settings, 'GOOGLE_ANALYTICS_CODE', None),\n 'GOOGLE_ANALYTICS_ADDRESS': getattr(settings, 'GOOGLE_ANALYTICS_ADDRESS', None),\n }\n return context","def modal_vars(request):\n return {\n 'media_url': settings.MEDIA_URL,\n 'extend_from': get_base(request),\n 'is_ajax': request.is_ajax,\n }","def global_settings(request):\n return {\n 'OFFLINE_MODE_CAPABILITY_ENABLED': settings.OFFLINE_MODE_CAPABILITY_ENABLED\n }","def general(request):\n\treturn render(request, 'general.html', {})","def create_base_context():\n context = {\n 'URL_ROOT': settings.URL_ROOT,\n }\n return context","def default_context(request):\n return {\n 'GOOGLE_ANALYTICS_ID': settings.GOOGLE_ANALYTICS_ID,\n 'SITE_TITLE': settings.SITE_TITLE,\n }","def base_context(request):\n if not hasattr(request, 'user'):\n return {}\n return {\n 'is_project_admin': is_project_admin(request.user)\n }","def load_variables(mod):\n for k in dir(mod):\n if '__' not in k:\n globals()[k] = getattr(mod, k)","def setvariables(self, request, contextvars, thevars):\n postdata = {}\n if request.POST:\n postdata = dict(request.POST.dict())\n for var in thevars:\n if postdata.get(\"custom_\"+var):\n contextvars[var] = postdata.get(\"custom_\"+var)\n else:\n try:\n contextvars[var] = thevars[var]\n except Exception:\n pass\n return contextvars","def get_template_vars(self, template_name, context=None):\n # Read the state template file into a template object using the\n # environment object\n found_template_name = (\n self.find_template_name(template_name + '\\.tpl(\\.\\w+)?$'))\n template = self._template_env.select_template(\n [template_name, found_template_name])\n\n # Use Jinja2's module functionality to grab the template variables and\n # create a dict comprehension\n if context is not None:\n template_module_vars = [\n template_var for template_var in\n dir(template.make_module(vars=context))\n if not re.match('^_+.*', template_var)]\n template_vars = {\n template_var:\n getattr(template.make_module(vars=context), template_var)\n for template_var in template_module_vars}\n else:\n template_module_vars = [\n template_var for template_var in\n dir(template.module) if not re.match('^_+.*', template_var)]\n template_vars = {\n template_var:\n getattr(template.module, template_var)\n for template_var in template_module_vars}\n\n return template_vars","def _initialize_variables(self):\n\n self.font = Font()\n self.BibTerm = ''\n\n self.illegalChars = [chr(i) for i in range(1, 0x20)]\n self.illegalChars.extend([chr(0x7F), '\"', '*', '/', ':', '<', '>', \\\n '?', '\\\\', '|'])\n\n #define all StringVar(), BooleanVar(), etc… needed to hold info\n self.current_project = StringVar()\n self.dict_in = StringVar()\n self.terms_in = StringVar()\n self.old_dict = StringVar()\n self.dict_in_changed = IntVar()\n self.terms_in_changed = IntVar()\n self.old_dict_changed = IntVar()\n self.add_cldr_fields = IntVar()\n self.accept_regional_digits = IntVar()\n self.selected_lang = StringVar()\n self.int_var = IntVar()\n self.preferred = StringVar()\n self.PrefChar = StringVar()","def get_context_data(self, **kwargs):\n context = super(MyAdminView, self).get_context_data(**kwargs)\n context[\"domain\"] = Site.objects.get_current().domain\n context[\"rabbit_port\"] = settings.RABBITMQ_MANAGEMENT_PORT\n context[\"flower_port\"] = settings.FLOWER_PORT\n return context","def variables_used (self) :\r\n\t\treturn []","def InitMyVar(self, documentRoot, sId):\n self.__myvar = DTL.TemplateMacro.MacroMyVar(documentRoot, sId)\n self.__myvar.OpenFile()\n self.__myvar.Set('VERSION', vars.VERSION)\n self.__myvar.Set('COPYRIGHT_HTML_COMMENT', vars.COPYRIGHT_HTML)\n self.__myvar.Set('COPYRIGHT_HTML', vars.COPYRIGHT_HTML)\n if not self.__myvar.ayt('login'):\n self.__myvar.Set('login', '0')\n self.__myvar.Set('REFERER', self.__httpEnv['HTTP_REFERER'])\n self.__myvar.Set('REFERER_TEMPLATE', self.__httpEnv.GetRefererTemplate())\n if self.__myvar.ayt('ACTUAL_TEMPLATE'):\n self.__myvar.Set('LAST_TEMPLATE', self.__myvar.Get('ACTUAL_TEMPLATE'))\n else:\n self.__myvar.Set('LAST_TEMPLATE', '')\n self.__myvar.Set('ACTUAL_TEMPLATE', self.__cgi.GetqVar('qTemplate'))\n self.__myvar.Set('qs', sId)","def getGlobal(self, var):\n if var in self.global_vars:\n return self.global_vars[var]\n # Else...\n return self.ce_proxy.getGlobalVariable(self.userName, var)","def load_global_variables(self):\n return read_and_combine_yamls_in_dir(self.__get_environments_root_dir())","def local_views():\n\tpass","def add_renderer_globals(event):\n def fake_url(controller=None, action=None, **kwargs):\n if action == \"css\":\n return \"/css\"\n if action and controller:\n path = {}\n for key in 'name', 'pocket', 'subpath':\n if key in kwargs:\n path[key] = kwargs.pop(key)\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\n return request.route_path(controller+\"/\"+action, **path)\n if controller and controller.startswith(\"/\"):\n return controller\n return \"/unknown\"\n\n def fake_url_current(**kwargs):\n path = {}\n # XXX request.matchdict?\n if 'name' in kwargs:\n path['name'] = kwargs.pop('name')\n if 'action' in kwargs:\n path['_route_name'] = 'dex/'+kwargs.pop('action')\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\n return request.current_route_path(**path)\n\n def fake_translate(message, plural=None, n=None, context=None, comment=None):\n return unicode(message)\n\n renderer_globals = event\n request = event.get(\"request\") #or threadlocal.get_current_request()\n if not request:\n return\n config = request.registry.settings\n renderer_globals[\"config\"] = config\n renderer_globals[\"h\"] = splinehelpers\n renderer_globals[\"r\"] = request\n renderer_globals[\"c\"] = request.tmpl_context\n #renderer_globals[\"url\"] = request.url_generator\n renderer_globals[\"url\"] = fake_url\n fake_url.current = fake_url_current\n renderer_globals[\"_\"] = fake_translate\n renderer_globals[\"flash\"] = lib.Flash(request.session)\n\n request.tmpl_context.links = config['spline.plugins.links']\n\n # start timer\n request.tmpl_context.timer = lib.ResponseTimer()","def printSettings():\n print \">>>\\n>>> SettingsTool: global variables:\"\n for variable, value in globals().items():\n if variable.count('__')>1: continue\n print \">>> %-16s = %s\"%(variable,value)\n print \">>>\"","def all_globals_dict(self):\n return self.module_node.used_vars","def _init_vars_():\n\n global ADMIN_USERNAME\n ADMIN_USERNAME = _fetch_ssm_parameter(\n '/app/MDL/{}/{}/LDAP/User/HerdAdminUsername'\n .format(INSTANCE_NAME, ENVIRONMENT), False)\n\n global ADMIN_PASS\n ADMIN_PASS = _fetch_ssm_parameter(\n '/app/MDL/{}/{}/LDAP/Password/HerdAdminPassword'.format(INSTANCE_NAME,\n ENVIRONMENT),\n True)\n\n global HERD_REST_BASE_PATH\n HERD_REST_BASE_PATH = 'herd-app/rest'\n\n global HERD_BASE_URL\n HERD_BASE_URL = '{}-herd.dev.aws.cloudfjord.com'.format(INSTANCE_NAME)\n\n global HERD_HEADERS\n HERD_HEADERS = {\n 'Accept': 'application/json',\n 'Content-type': 'application/json'\n }\n\n global S3_HOME_BUCKET\n S3_HOME_BUCKET = _fetch_ssm_parameter('/app/MDL/{}/{}/S3/MDL'\n .format(INSTANCE_NAME, ENVIRONMENT),\n False)\n\n global BDSQL_MASTER\n BDSQL_MASTER = _fetch_ssm_parameter('/app/MDL/{}/{}/Bdsql/MasterIp'\n .format(INSTANCE_NAME, ENVIRONMENT),\n False)","def init_tkvars(self):\n\n for key in self.defaultprefs:\n value = self.defaultprefs[key]\n if type(value) is types.IntType:\n var = self.__dict__[key] = IntVar()\n elif type(value) is types.StringType:\n var = self.__dict__[key] = StringVar()\n var.set(value)\n\n self.resnum = IntVar()\n self.resnum.set(1)\n # Method for calculating Tm of primers\n self.Tm_method = StringVar()\n self.Tm_method.set('Stratagene')\n if 'Darwin' in self.currplatform:\n self.seqfontsize.set(16)\n else:\n self.seqfontsize.set(14)\n return","def __get_vars(self):\n if self.resolved_vars:\n return self.resolved_vars\n return self.config_vars","def get_context_data(self, **kwargs):\n context = super().get_context_data(**kwargs)\n\n context['env'] = {\n 'csrf_token': get_token(self.request),\n 'static_path': settings.STATIC_URL[:-1],\n 'is_stunt': self.request.user.has_committee('STUNT'),\n }\n\n return context","def context(template):\n\n return {\n v.key: v.read()\n for v in [Variable(name) for name in extract_variables(template)]\n }","def test_swift_globals(self):\n self.build()\n self.do_test()","def settings(request=None):\n from mezzanine.conf import settings\n\n allowed_settings = settings.TEMPLATE_ACCESSIBLE_SETTINGS\n\n template_settings = TemplateSettings(settings, allowed_settings)\n template_settings.update(DEPRECATED)\n\n # This is basically the same as the old ADMIN_MEDIA_PREFIX setting,\n # we just use it in a few spots in the admin to optionally load a\n # file from either grappelli or Django admin if grappelli isn't\n # installed. We don't call it ADMIN_MEDIA_PREFIX in order to avoid\n # any confusion.\n admin_prefix = \"grappelli/\" if settings.GRAPPELLI_INSTALLED else \"admin/\"\n template_settings[\"MEZZANINE_ADMIN_PREFIX\"] = admin_prefix\n\n return {\"settings\": template_settings}","def _config(request):\n return request.environ['adminish']","def get_context(self, request, *args, **kwargs):\n context = super().get_context(request, *args, **kwargs)\n context[\"posts\"] = MyblogDetailPage.objects.live().public()\n context[\"regular_context_var\"] = \"Hello world 123123\"\n context[\"special_link\"] = self.reverse_subpage('latest_posts')\n context[\"categories\"] = MyBlogCategory.objects.all()\n return context","def base(request):\n\treturn render(request, 'sett_base.html', {})","def setting():\n return render_template('setting.html', year=datetime.now().year)","def test_globals(self):\n self.assertNotEqual(Languages.LANGUAGES_FILE, None)\n self.assertEqual(Languages._languagesDict, None)","def get_context(self, request, *args, **kwargs):\n context = super(AbstractBasePage, self).get_context(request, *args, **kwargs)\n context['has_multilanguage_support'] = len(settings.ACTIVE_LANGUAGES)\n context['social_twitter_handle'] = settings.TWITTER_HANDLE\n context['social_youtube_url'] = settings.YOUTUBE_CHANNEL_URL\n return context","def template_context(**kwrds):\n usr = User.get_user()\n\n default = {\n 'usr': usr\n }\n default.update(kwrds)\n return default","def default_environment():\n return dict(_VARS)","def base_site(request):\n from django.conf import settings\n\n context = {}\n context['STATIC_URL'] = '/static/'\n context['BASE_SIDEBAR'] = 'yui-t2'\n\n if hasattr(settings, 'STATIC_URL'):\n context['STATIC_URL'] = settings.STATIC_URL\n\n if not hasattr(settings, 'BASE_SIDEBAR'):\n return context\n\n if settings.BASE_SIDEBAR == 'left':\n context['BASE_SIDEBAR'] = 'yui-t2'\n if settings.BASE_SIDEBAR == 'right':\n context['BASE_SIDEBAR'] = 'yui-t4'\n\n return context","def setGlobal(name, value):","def make_template_values(request):\n user = users.get_current_user()\n values = {'request': request}\n if user:\n values['logged_in'] = True\n values['loginout_url'] = users.create_logout_url(request.uri)\n values['loginout_url_linktext'] = 'Logout ({})'.format(user)\n else:\n values['logged_in'] = False\n values['loginout_url'] = users.create_login_url(request.uri)\n values['loginout_url_linktext'] = 'Login'\n return values","def globals_load(plugin_context, globals_, symbols):\n for g in [plugin_context.rosh_globals, globals_]:\n if g is not None:\n g.update(symbols)","def _initialize_project_variables(self):\n self.Source = ''\n self.Regional = ''\n self.Vernacular = ''\n self.Fallback = dict()\n self.New_Target = dict()\n self.Biblical_Terms = dict()\n self.Old_Target = dict()\n\n# self.list_projects = []\n# self.project_lines = []\n# self.indent = 0\n# self.Treed = False\n self.root = etree.Element('root')\n# #add child 'settings', all user configurable bits under here\n self.settings = etree.SubElement(self.root, \"settings\")\n# self.old_mode = dict()\n# self.spreferred = etree.SubElement(self.settings, \"preferred\")\n# self.smode = etree.SubElement(self.settings, \"mode\")\n# self.stemp = etree.SubElement(self.settings, \"template\")\n self.sf0 = etree.SubElement(self.settings, \"f0\")\n self.sf1 = etree.SubElement(self.settings, \"f1\")\n self.sf2 = etree.SubElement(self.settings, \"f2\")\n self.trout = etree.SubElement(self.root, \"tree\")","def debug_context(request):\n\n return {\n 'DEBUG': settings.DEBUG,\n }","def common_template_data(request, revision=None, mime_type=None):\n\n cfg = request.cfg\n\n # Initialize data dictionary members (sorted alphanumerically)\n data = TemplateData(\n {\n \"annotate_href\": None,\n \"cfg\": cfg,\n \"docroot\": (\n cfg.options.docroot is None\n and request.script_name + \"/\" + docroot_magic_path\n or cfg.options.docroot\n ),\n \"download_href\": None,\n \"download_text_href\": None,\n \"graph_href\": None,\n \"home_href\": request.script_name or \"/\",\n \"kv\": request.kv,\n \"lockinfo\": None,\n \"log_href\": None,\n \"nav_path\": nav_path(request),\n \"pathtype\": None,\n \"prefer_markup\": ezt.boolean(0),\n \"queryform_href\": None,\n \"rev\": None,\n \"revision_href\": None,\n \"rootname\": (request.rootname and request.server.escape(request.rootname) or None),\n \"rootpath\": request.rootpath,\n \"roots_href\": None,\n \"roottype\": request.roottype,\n \"rss_href\": None,\n \"tarball_href\": None,\n \"up_href\": None,\n \"username\": request.username,\n \"view\": _view_codes[request.view_func],\n \"view_href\": None,\n \"vsn\": __version__,\n \"where\": request.server.escape(request.where),\n }\n )\n\n rev = revision\n if not rev:\n rev = request.query_dict.get(\"annotate\")\n if not rev:\n rev = request.query_dict.get(\"revision\")\n if not rev and request.roottype == \"svn\":\n rev = request.query_dict.get(\"pathrev\")\n try:\n data[\"rev\"] = hasattr(request.repos, \"_getrev\") and request.repos._getrev(rev) or rev\n except vclib.InvalidRevision:\n raise ViewVCException(\"Invalid revision\", \"404 Not Found\")\n\n if request.pathtype == vclib.DIR:\n data[\"pathtype\"] = \"dir\"\n elif request.pathtype == vclib.FILE:\n data[\"pathtype\"] = \"file\"\n\n if request.path_parts:\n dir = _path_join(request.path_parts[:-1])\n data[\"up_href\"] = request.get_url(\n view_func=view_directory, where=dir, pathtype=vclib.DIR, params={}, escape=1\n )\n\n if \"roots\" in cfg.options.allowed_views:\n data[\"roots_href\"] = request.get_url(view_func=view_roots, escape=1, params={})\n\n if request.pathtype == vclib.FILE:\n fvi = get_file_view_info(request, request.where, data[\"rev\"], mime_type)\n data[\"view_href\"] = fvi.view_href\n data[\"download_href\"] = fvi.download_href\n data[\"download_text_href\"] = fvi.download_text_href\n data[\"annotate_href\"] = fvi.annotate_href\n data[\"revision_href\"] = fvi.revision_href\n data[\"prefer_markup\"] = fvi.prefer_markup\n data[\"log_href\"] = request.get_url(view_func=view_log, params={}, escape=1)\n if request.roottype == \"cvs\" and cfg.options.use_cvsgraph:\n data[\"graph_href\"] = request.get_url(view_func=view_cvsgraph, params={}, escape=1)\n file_data = request.repos.listdir(request.path_parts[:-1], request.pathrev, {})\n entries = [item for item in file_data if item.name == request.path_parts[-1]]\n if len(entries) == 1:\n request.repos.dirlogs(request.path_parts[:-1], request.pathrev, entries, {})\n data[\"lockinfo\"] = entries[0].lockinfo\n elif request.pathtype == vclib.DIR:\n data[\"view_href\"] = request.get_url(view_func=view_directory, params={}, escape=1)\n if \"tar\" in cfg.options.allowed_views:\n data[\"tarball_href\"] = request.get_url(view_func=download_tarball, params={}, escape=1)\n if request.roottype == \"svn\":\n data[\"revision_href\"] = request.get_url(\n view_func=view_revision, params={\"revision\": data[\"rev\"]}, escape=1\n )\n\n data[\"log_href\"] = request.get_url(view_func=view_log, params={}, escape=1)\n\n if is_querydb_nonempty_for_root(request):\n if request.pathtype == vclib.DIR:\n params = {}\n if request.roottype == \"cvs\" and request.pathrev:\n params[\"branch\"] = request.pathrev\n data[\"queryform_href\"] = request.get_url(\n view_func=view_queryform, params=params, escape=1\n )\n data[\"rss_href\"] = request.get_url(\n view_func=view_query, params={\"date\": \"month\", \"format\": \"rss\"}, escape=1\n )\n elif request.pathtype == vclib.FILE:\n parts = _path_parts(request.where)\n where = _path_join(parts[:-1])\n data[\"rss_href\"] = request.get_url(\n view_func=view_query,\n where=where,\n pathtype=request.pathtype,\n params={\"date\": \"month\", \"format\": \"rss\", \"file\": parts[-1], \"file_match\": \"exact\"},\n escape=1,\n )\n return data","def index(request):\n return render(request, 'items/index.html', {\n 'globalvars': globalvars,\n 'fart': 'fart'\n })","def _addGlobals(self, globalsDict):\n globalsDict['obj'] = None\n globalsDict['role'] = None\n globalsDict['pyatspi'] = pyatspi","def get_context_data(self, **kwargs):\n # Making an object of 'HomeView class'\n # 'context' variable is an object of Parent class 'HomeView'.\n # 'super()' identifies that, 'get_context_data' is a parent class's function.\n # Here, we are using Recursion\n context = super().get_context_data(**kwargs)\n # '['injection']' is a key and 'Basic Injection!' is the value which will be shown on Template.\n context['injection'] = \"Basic Injection!\"\n return context","def __init__(self, *args, **kwargs):\n if not kwargs.get('no_django', False):\n overrides = dict([(k, getattr(middleware, k, None),) for k in django_variables])\n kwargs.update(overrides)\n super(Template, self).__init__(*args, **kwargs)","def get_variables(self):\n\t\treturn self.variables","def ioc(globals):\n\tfrom Module.Shapes.ShapeFactory import shape_factory\n\tglobals['shape_factory'] = shape_factory\n\tfrom Module.Lighting.Colors import Colors\n\tglobals['Colors'] = Colors","def __init__(self):\n self.context={}","def __init__(self):\n self.context={}"],"string":"[\n \"def global_variables():\\n item_catalog_app.jinja_env.globals[\\\"ALL_CATEGORIES\\\"] = act.all_categories()\\n __logged_in_user__ = act.user(\\n pointer=login_session.get(\\\"user_id\\\")\\n )\\n item_catalog_app.jinja_env.globals[\\\"USER\\\"] = __logged_in_user__\\n g.USER = __logged_in_user__\",\n \"def inject_dict_for_all_templates():\\n global_vars = {\\\"settings\\\": settings}\\n\\n if is_authenticated():\\n global_vars[\\\"user\\\"] = get_authenticated_user()\\n\\n return global_vars\",\n \"def get_global_vars(self) -> str:\\n return templates.GLOBAL_STATEMENTS\",\n \"def test_with_global(self):\\n t = Template(\\n '{% load djblets_utils %}'\\n '{% block main %}'\\n '{% block inner %}'\\n '{% definevar \\\"myvar\\\" global %}{{num}}{% enddefinevar %}'\\n '{% endblock %}'\\n '{% endblock %}'\\n '[{{myvar}}]')\\n\\n self.assertEqual(\\n t.render(Context({\\n 'num': 123,\\n })),\\n '[123]')\",\n \"def template_context(request):\\n context = {\\n 'application_version': settings.APPLICATION_VERSION,\\n }\\n context.update(settings.STATIC_CONTEXT_VARS)\\n return context\",\n \"def settings(request):\\n return {\\\"SETTINGS\\\": django_settings, \\\"GLOBAL_DEFINITIONS\\\": global_definitions}\",\n \"def set_jinja_globals():\\n\\n # The resource keys will not be present.\\n ufo.app.logger.info('Start setting resources into jinja globals.\\\\n'\\n 'Current jinja globals: %s' %\\n ufo.app.jinja_env.globals.keys())\\n\\n ufo.app.jinja_env.globals['resources'] = json.dumps(_get_resources())\\n\\n # The resource keys should be present if set.\\n ufo.app.logger.info('Finished setting resources into jinja globals.\\\\n'\\n 'Current jinja globals: %s' %\\n ufo.app.jinja_env.globals.keys())\",\n \"def __context(self):\\r\\n # TODO: do we need to include anything else?\\r\\n # TODO: do this with the django-settings-context-processor\\r\\n return {\\r\\n \\\"FEATURES\\\": settings.FEATURES,\\r\\n \\\"THEME_NAME\\\" : getattr(settings, \\\"THEME_NAME\\\", None),\\r\\n }\",\n \"def set_jinja_before_request():\\n resource_provider.set_jinja_globals()\",\n \"def add_renderer_globals(event):\\n request = event.get('request')\\n # add globals for i18n\\n event['_'] = request.translate\\n event['localizer'] = request.localizer\\n # add application globals from the config file\\n settings = request.registry.settings\\n event['brand_name'] = settings['anuket.brand_name']\",\n \"def setup_templates(self):\\n self.libs[\\\"template\\\"] = (\\\"#libs/templates/include\\\", None, \\\"\\\")\\n self[\\\"CPPPATH\\\"].append(\\\"#libs/templates/include\\\")\",\n \"def set_vars():\\n return dict()\",\n \"def extra_context(self):\\n from django.conf import settings\\n\\n return {\\n \\\"site_name\\\": (lambda r: settings.LEONARDO_SITE_NAME\\n if getattr(settings, 'LEONARDO_SITE_NAME', '') != ''\\n else settings.SITE_NAME),\\n \\\"debug\\\": lambda r: settings.TEMPLATE_DEBUG\\n }\",\n \"def init_locals(self):\\n pass\",\n \"def add_renderer_globals(event):\\n request = event.get('request')\\n if request is None:\\n request = get_current_request()\\n globs = {\\n 'url': route_url,\\n 'h': None,\\n 'a_url': request.application_url,\\n 'user': authenticated_userid(request),\\n 'repo': Repo(request.registry.settings.get('git_repo', '.'))\\n }\\n if request is not None:\\n tmpl_context = request.tmpl_context\\n globs['c'] = tmpl_context\\n globs['tmpl_context'] = tmpl_context\\n try:\\n globs['session'] = request.session\\n except ConfigurationError:\\n pass\\n event.update(globs)\",\n \"def __init__(self, *args, **kwargs):\\r\\n if not kwargs.get('no_django', False):\\r\\n overrides = {k: getattr(edxmako, k, None) for k in DJANGO_VARIABLES}\\r\\n overrides['lookup'] = edxmako.LOOKUP['main']\\r\\n kwargs.update(overrides)\\r\\n super(Template, self).__init__(*args, **kwargs)\",\n \"def template_extra_functions(self):\\n\\t\\treturn []\",\n \"def global_jinja_env():\\n return _ENV\",\n \"def settings(request):\\n from django.conf import settings\\n return {\\n 'exhibitBaseTemplate': settings.EXHIBIT_TEMPLATE,\\n 'thumbnailUrl': settings.THUMBNAIL_URL,\\n 'calisphere': settings.CALISPHERE\\n }\",\n \"def inject_global():\\n return {\\n 'user': 'Pythonista'\\n }\",\n \"def T(request):\\n\\treturn all_templates[request.param]\",\n \"def load_jinja_fns(self):\\n\\n\\t\\t# Function for jinja, to remove duplicates from flashed messages\\n\\t\\tdef remove_duplicates(msgs):\\n\\t\\t\\tuniq_msgs = []\\n\\t\\t\\tfor msg in msgs:\\n\\t\\t\\t\\tif msg not in uniq_msgs:\\n\\t\\t\\t\\t\\tuniq_msgs.append(msg)\\n\\n\\t\\t\\treturn uniq_msgs\\n\\n\\t\\tcurrent_app.jinja_env.globals.update(remove_duplicates=remove_duplicates)\",\n \"def renderer_globals_factory(system):\\n return {'current_language': get_localizer(system['request']).locale_name,}\",\n \"def common_vars(environ):\\n fields = getFields(environ)\\n tooltips = getTooltips()\\n usersign = environ['tiddlyweb.usersign']\\n if not 'fields' in usersign:\\n usersign['fields'] = {'name': ''}\\n captcha = process_captcha(environ)\\n query = environ['tiddlyweb.query']\\n\\n return {'fields':fields, 'tooltips':tooltips, 'usersign':usersign, 'captcha':captcha, 'query':query}\",\n \"def all_common_variables(request):\\n articles = Article.objects.all()\\n random_article = Article.objects.order_by('?')[0:4]\\n return {\\n 'articles':articles,\\n 'random_article':random_article,\\n }\",\n \"def defaultTemplateParameter(self):\\n self.tplparam['BODY'] = self.content\\n self.tplparam['FLASH'] = (self.flash or '').replace('\\\"', r'\\\\\\\"')\\n self.tplparam['PYMFRAMEVERSION'] = self.pymframeversion\\n self.tplparam['USER'] = self.session.getAttribute(self.settings.authenvar)\\n self.tplparam['RIGHTS'] = repr(self.session.getAttribute('rights'))\\n self.tplparam['MENU'] = self.routing.getMenu(self.path,self.checkRights)\\n self.tplparam['PATH'] = self.path\",\n \"def standard_variables(self):\\n\\t\\tstd_vars = {\\n\\t\\t\\t'time': {\\n\\t\\t\\t\\t'local': datetime.datetime.now(),\\n\\t\\t\\t\\t'utc': datetime.datetime.utcnow()\\n\\t\\t\\t}\\n\\t\\t}\\n\\t\\treturn std_vars\",\n \"def default_context_setup(context):\\n context['href'] = href\\n context['static'] = static\\n context['session'] = session\\n context['flash_message'] = flash_message\\n context['debug'] = application.debug\\n context['Markup'] = genshi.Markup\",\n \"def _globals(self):\\n return self.__globals\",\n \"def init_vars():\\n\\tda_vinci.base.usepackage(\\\"pgfkeys\\\")\\n\\tda_vinci.base.add_preamble(setup_script)\",\n \"def add_renderer_globals(event):\\r\\n request = event['request']\\r\\n event['_'] = request.translate\\r\\n event['ungettext'] = request.ungettext\\r\\n event['localizer'] = request.localizer\",\n \"def init_vars(self):\\n # type: () -> None\\n raise NotImplementedError\",\n \"def global_values(self):\\n return self.globals.values()\",\n \"def set_global_vars():\\n global_vars = {\\\"status\\\": False}\\n try:\\n global_vars[\\\"Owner\\\"] = \\\"Mystique\\\"\\n global_vars[\\\"Environment\\\"] = \\\"Prod\\\"\\n global_vars[\\\"aws_region\\\"] = \\\"us-east-1\\\"\\n global_vars[\\\"tag_name\\\"] = \\\"serverless_cloudwatch_logs_exporter\\\"\\n global_vars[\\\"retention_days\\\"] = 35\\n global_vars[\\\"cw_logs_to_export\\\"] = [\\\"/aws/lambda/trending_news\\\"]\\n #global_vars[\\\"cw_logs_to_export\\\"] = os.environ.get(\\\"cw_logs_to_export\\\").split(\\\",\\\")\\n global_vars[\\\"log_dest_bkt\\\"] = \\\"cw-log-exports-01\\\"\\n global_vars[\\\"time_out\\\"] = 300\\n global_vars[\\\"tsk_back_off\\\"] = 2\\n global_vars[\\\"status\\\"] = True\\n except Exception as e:\\n logger.error(\\\"Unable to set Global Environment variables. Exiting\\\")\\n global_vars[\\\"error_message\\\"] = str(e)\\n return global_vars\",\n \"def global_var(name: str) -> SetupVal:\\n return GlobalVarVal(name)\",\n \"def common_context(request):\\n c = {\\n 'lessons': get_lesson_numbers(),\\n }\\n return c\",\n \"def _var(self, name=None, context=None):\\n\\t\\tif name is None: name = None\\n\\t\\tif context is None: context = self.context\\n\\t\\tif (not name):\\n\\t\\t\\treturn context.getVariables().keys()\\n\\t\\telif True:\\n\\t\\t\\treturn context.getVariables().get(name)\",\n \"def variables(self):\\n return self._.vars\",\n \"def test_basic_usage(self):\\n t = Template('{% load djblets_utils %}'\\n '{% definevar \\\"myvar\\\" %}\\\\n'\\n 'test{{num}}\\\\n'\\n '{% enddefinevar %}'\\n '{{myvar}}')\\n\\n self.assertEqual(\\n t.render(Context({\\n 'num': 123,\\n })),\\n '\\\\ntest123\\\\n')\",\n \"def variables_declared (self) :\\r\\n\\t\\treturn {}\",\n \"def _init_vars(self):\\n if not self._has(\\\"vars\\\"):\\n if self._has(\\\"p\\\"):\\n self._.vars = self._.p.variables()\\n elif self._has(\\\"q\\\"):\\n self._.vars = self._.q.variables()\\n elif self._has(\\\"P\\\"):\\n self._.vars = variables(self._.P)\\n elif self._has(\\\"Q\\\"):\\n self._.vars = variables(self._.Q)\\n self._.vars_ordered = len(self._.vars) <= 1\",\n \"def _init_tkvars(self,PO):\\n for name,param in PO.params().items():\\n self._create_tkvar(PO,name,param)\",\n \"def _get_test_variables():\\n if __name__ == \\\"__main__\\\":\\n return _MOCKUP_TEST_VARIABLES\\n else:\\n return BuiltIn().get_variables()\",\n \"def is_global(self, key):\\n return key in dir(django_global_settings)\",\n \"def angular_js_tests(request):\\n return locals()\",\n \"def _load_settings_to_jinja_env(self) :\\n\\t\\t# Load filters if exists\\n\\t\\tif hasattr(self.settings, 'FILTERS') :\\n\\t\\t\\tfor name, cls in utils.load_module(self.settings.FILTERS).__dict__.items() :\\n\\t\\t\\t\\tself.jinja_env.filters[name] = cls\\n\\n\\n\\t\\t# Load globals if exists\\n\\t\\tif hasattr(self.settings, 'GLOBALS') :\\n\\t\\t\\tfor name, cls in utils.load_module(self.settings.GLOBALS).__dict__.items() :\\n\\t\\t\\t\\tself.jinja_env.globals[name] = cls\",\n \"def _globals(self):\\n return self.dicts[0]._globals()\",\n \"def __init__(self, template_env):\\r\\n self._template_env = template_env\\r\\n self._pythons = []\",\n \"def request_vars(self):\",\n \"def initGlobals():\\n libxml2mod.xmlInitGlobals()\",\n \"def environment(request):\\n context = {\\n 'COMPRESS_ENABLED': settings.COMPRESS_ENABLED,\\n 'GOOGLE_ANALYTICS_CODE': getattr(settings, 'GOOGLE_ANALYTICS_CODE', None),\\n 'GOOGLE_ANALYTICS_ADDRESS': getattr(settings, 'GOOGLE_ANALYTICS_ADDRESS', None),\\n }\\n return context\",\n \"def modal_vars(request):\\n return {\\n 'media_url': settings.MEDIA_URL,\\n 'extend_from': get_base(request),\\n 'is_ajax': request.is_ajax,\\n }\",\n \"def global_settings(request):\\n return {\\n 'OFFLINE_MODE_CAPABILITY_ENABLED': settings.OFFLINE_MODE_CAPABILITY_ENABLED\\n }\",\n \"def general(request):\\n\\treturn render(request, 'general.html', {})\",\n \"def create_base_context():\\n context = {\\n 'URL_ROOT': settings.URL_ROOT,\\n }\\n return context\",\n \"def default_context(request):\\n return {\\n 'GOOGLE_ANALYTICS_ID': settings.GOOGLE_ANALYTICS_ID,\\n 'SITE_TITLE': settings.SITE_TITLE,\\n }\",\n \"def base_context(request):\\n if not hasattr(request, 'user'):\\n return {}\\n return {\\n 'is_project_admin': is_project_admin(request.user)\\n }\",\n \"def load_variables(mod):\\n for k in dir(mod):\\n if '__' not in k:\\n globals()[k] = getattr(mod, k)\",\n \"def setvariables(self, request, contextvars, thevars):\\n postdata = {}\\n if request.POST:\\n postdata = dict(request.POST.dict())\\n for var in thevars:\\n if postdata.get(\\\"custom_\\\"+var):\\n contextvars[var] = postdata.get(\\\"custom_\\\"+var)\\n else:\\n try:\\n contextvars[var] = thevars[var]\\n except Exception:\\n pass\\n return contextvars\",\n \"def get_template_vars(self, template_name, context=None):\\n # Read the state template file into a template object using the\\n # environment object\\n found_template_name = (\\n self.find_template_name(template_name + '\\\\.tpl(\\\\.\\\\w+)?$'))\\n template = self._template_env.select_template(\\n [template_name, found_template_name])\\n\\n # Use Jinja2's module functionality to grab the template variables and\\n # create a dict comprehension\\n if context is not None:\\n template_module_vars = [\\n template_var for template_var in\\n dir(template.make_module(vars=context))\\n if not re.match('^_+.*', template_var)]\\n template_vars = {\\n template_var:\\n getattr(template.make_module(vars=context), template_var)\\n for template_var in template_module_vars}\\n else:\\n template_module_vars = [\\n template_var for template_var in\\n dir(template.module) if not re.match('^_+.*', template_var)]\\n template_vars = {\\n template_var:\\n getattr(template.module, template_var)\\n for template_var in template_module_vars}\\n\\n return template_vars\",\n \"def _initialize_variables(self):\\n\\n self.font = Font()\\n self.BibTerm = ''\\n\\n self.illegalChars = [chr(i) for i in range(1, 0x20)]\\n self.illegalChars.extend([chr(0x7F), '\\\"', '*', '/', ':', '<', '>', \\\\\\n '?', '\\\\\\\\', '|'])\\n\\n #define all StringVar(), BooleanVar(), etc… needed to hold info\\n self.current_project = StringVar()\\n self.dict_in = StringVar()\\n self.terms_in = StringVar()\\n self.old_dict = StringVar()\\n self.dict_in_changed = IntVar()\\n self.terms_in_changed = IntVar()\\n self.old_dict_changed = IntVar()\\n self.add_cldr_fields = IntVar()\\n self.accept_regional_digits = IntVar()\\n self.selected_lang = StringVar()\\n self.int_var = IntVar()\\n self.preferred = StringVar()\\n self.PrefChar = StringVar()\",\n \"def get_context_data(self, **kwargs):\\n context = super(MyAdminView, self).get_context_data(**kwargs)\\n context[\\\"domain\\\"] = Site.objects.get_current().domain\\n context[\\\"rabbit_port\\\"] = settings.RABBITMQ_MANAGEMENT_PORT\\n context[\\\"flower_port\\\"] = settings.FLOWER_PORT\\n return context\",\n \"def variables_used (self) :\\r\\n\\t\\treturn []\",\n \"def InitMyVar(self, documentRoot, sId):\\n self.__myvar = DTL.TemplateMacro.MacroMyVar(documentRoot, sId)\\n self.__myvar.OpenFile()\\n self.__myvar.Set('VERSION', vars.VERSION)\\n self.__myvar.Set('COPYRIGHT_HTML_COMMENT', vars.COPYRIGHT_HTML)\\n self.__myvar.Set('COPYRIGHT_HTML', vars.COPYRIGHT_HTML)\\n if not self.__myvar.ayt('login'):\\n self.__myvar.Set('login', '0')\\n self.__myvar.Set('REFERER', self.__httpEnv['HTTP_REFERER'])\\n self.__myvar.Set('REFERER_TEMPLATE', self.__httpEnv.GetRefererTemplate())\\n if self.__myvar.ayt('ACTUAL_TEMPLATE'):\\n self.__myvar.Set('LAST_TEMPLATE', self.__myvar.Get('ACTUAL_TEMPLATE'))\\n else:\\n self.__myvar.Set('LAST_TEMPLATE', '')\\n self.__myvar.Set('ACTUAL_TEMPLATE', self.__cgi.GetqVar('qTemplate'))\\n self.__myvar.Set('qs', sId)\",\n \"def getGlobal(self, var):\\n if var in self.global_vars:\\n return self.global_vars[var]\\n # Else...\\n return self.ce_proxy.getGlobalVariable(self.userName, var)\",\n \"def load_global_variables(self):\\n return read_and_combine_yamls_in_dir(self.__get_environments_root_dir())\",\n \"def local_views():\\n\\tpass\",\n \"def add_renderer_globals(event):\\n def fake_url(controller=None, action=None, **kwargs):\\n if action == \\\"css\\\":\\n return \\\"/css\\\"\\n if action and controller:\\n path = {}\\n for key in 'name', 'pocket', 'subpath':\\n if key in kwargs:\\n path[key] = kwargs.pop(key)\\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\\n return request.route_path(controller+\\\"/\\\"+action, **path)\\n if controller and controller.startswith(\\\"/\\\"):\\n return controller\\n return \\\"/unknown\\\"\\n\\n def fake_url_current(**kwargs):\\n path = {}\\n # XXX request.matchdict?\\n if 'name' in kwargs:\\n path['name'] = kwargs.pop('name')\\n if 'action' in kwargs:\\n path['_route_name'] = 'dex/'+kwargs.pop('action')\\n path['_query'] = dict((k,v) for k,v in kwargs.items() if v is not None)\\n return request.current_route_path(**path)\\n\\n def fake_translate(message, plural=None, n=None, context=None, comment=None):\\n return unicode(message)\\n\\n renderer_globals = event\\n request = event.get(\\\"request\\\") #or threadlocal.get_current_request()\\n if not request:\\n return\\n config = request.registry.settings\\n renderer_globals[\\\"config\\\"] = config\\n renderer_globals[\\\"h\\\"] = splinehelpers\\n renderer_globals[\\\"r\\\"] = request\\n renderer_globals[\\\"c\\\"] = request.tmpl_context\\n #renderer_globals[\\\"url\\\"] = request.url_generator\\n renderer_globals[\\\"url\\\"] = fake_url\\n fake_url.current = fake_url_current\\n renderer_globals[\\\"_\\\"] = fake_translate\\n renderer_globals[\\\"flash\\\"] = lib.Flash(request.session)\\n\\n request.tmpl_context.links = config['spline.plugins.links']\\n\\n # start timer\\n request.tmpl_context.timer = lib.ResponseTimer()\",\n \"def printSettings():\\n print \\\">>>\\\\n>>> SettingsTool: global variables:\\\"\\n for variable, value in globals().items():\\n if variable.count('__')>1: continue\\n print \\\">>> %-16s = %s\\\"%(variable,value)\\n print \\\">>>\\\"\",\n \"def all_globals_dict(self):\\n return self.module_node.used_vars\",\n \"def _init_vars_():\\n\\n global ADMIN_USERNAME\\n ADMIN_USERNAME = _fetch_ssm_parameter(\\n '/app/MDL/{}/{}/LDAP/User/HerdAdminUsername'\\n .format(INSTANCE_NAME, ENVIRONMENT), False)\\n\\n global ADMIN_PASS\\n ADMIN_PASS = _fetch_ssm_parameter(\\n '/app/MDL/{}/{}/LDAP/Password/HerdAdminPassword'.format(INSTANCE_NAME,\\n ENVIRONMENT),\\n True)\\n\\n global HERD_REST_BASE_PATH\\n HERD_REST_BASE_PATH = 'herd-app/rest'\\n\\n global HERD_BASE_URL\\n HERD_BASE_URL = '{}-herd.dev.aws.cloudfjord.com'.format(INSTANCE_NAME)\\n\\n global HERD_HEADERS\\n HERD_HEADERS = {\\n 'Accept': 'application/json',\\n 'Content-type': 'application/json'\\n }\\n\\n global S3_HOME_BUCKET\\n S3_HOME_BUCKET = _fetch_ssm_parameter('/app/MDL/{}/{}/S3/MDL'\\n .format(INSTANCE_NAME, ENVIRONMENT),\\n False)\\n\\n global BDSQL_MASTER\\n BDSQL_MASTER = _fetch_ssm_parameter('/app/MDL/{}/{}/Bdsql/MasterIp'\\n .format(INSTANCE_NAME, ENVIRONMENT),\\n False)\",\n \"def init_tkvars(self):\\n\\n for key in self.defaultprefs:\\n value = self.defaultprefs[key]\\n if type(value) is types.IntType:\\n var = self.__dict__[key] = IntVar()\\n elif type(value) is types.StringType:\\n var = self.__dict__[key] = StringVar()\\n var.set(value)\\n\\n self.resnum = IntVar()\\n self.resnum.set(1)\\n # Method for calculating Tm of primers\\n self.Tm_method = StringVar()\\n self.Tm_method.set('Stratagene')\\n if 'Darwin' in self.currplatform:\\n self.seqfontsize.set(16)\\n else:\\n self.seqfontsize.set(14)\\n return\",\n \"def __get_vars(self):\\n if self.resolved_vars:\\n return self.resolved_vars\\n return self.config_vars\",\n \"def get_context_data(self, **kwargs):\\n context = super().get_context_data(**kwargs)\\n\\n context['env'] = {\\n 'csrf_token': get_token(self.request),\\n 'static_path': settings.STATIC_URL[:-1],\\n 'is_stunt': self.request.user.has_committee('STUNT'),\\n }\\n\\n return context\",\n \"def context(template):\\n\\n return {\\n v.key: v.read()\\n for v in [Variable(name) for name in extract_variables(template)]\\n }\",\n \"def test_swift_globals(self):\\n self.build()\\n self.do_test()\",\n \"def settings(request=None):\\n from mezzanine.conf import settings\\n\\n allowed_settings = settings.TEMPLATE_ACCESSIBLE_SETTINGS\\n\\n template_settings = TemplateSettings(settings, allowed_settings)\\n template_settings.update(DEPRECATED)\\n\\n # This is basically the same as the old ADMIN_MEDIA_PREFIX setting,\\n # we just use it in a few spots in the admin to optionally load a\\n # file from either grappelli or Django admin if grappelli isn't\\n # installed. We don't call it ADMIN_MEDIA_PREFIX in order to avoid\\n # any confusion.\\n admin_prefix = \\\"grappelli/\\\" if settings.GRAPPELLI_INSTALLED else \\\"admin/\\\"\\n template_settings[\\\"MEZZANINE_ADMIN_PREFIX\\\"] = admin_prefix\\n\\n return {\\\"settings\\\": template_settings}\",\n \"def _config(request):\\n return request.environ['adminish']\",\n \"def get_context(self, request, *args, **kwargs):\\n context = super().get_context(request, *args, **kwargs)\\n context[\\\"posts\\\"] = MyblogDetailPage.objects.live().public()\\n context[\\\"regular_context_var\\\"] = \\\"Hello world 123123\\\"\\n context[\\\"special_link\\\"] = self.reverse_subpage('latest_posts')\\n context[\\\"categories\\\"] = MyBlogCategory.objects.all()\\n return context\",\n \"def base(request):\\n\\treturn render(request, 'sett_base.html', {})\",\n \"def setting():\\n return render_template('setting.html', year=datetime.now().year)\",\n \"def test_globals(self):\\n self.assertNotEqual(Languages.LANGUAGES_FILE, None)\\n self.assertEqual(Languages._languagesDict, None)\",\n \"def get_context(self, request, *args, **kwargs):\\n context = super(AbstractBasePage, self).get_context(request, *args, **kwargs)\\n context['has_multilanguage_support'] = len(settings.ACTIVE_LANGUAGES)\\n context['social_twitter_handle'] = settings.TWITTER_HANDLE\\n context['social_youtube_url'] = settings.YOUTUBE_CHANNEL_URL\\n return context\",\n \"def template_context(**kwrds):\\n usr = User.get_user()\\n\\n default = {\\n 'usr': usr\\n }\\n default.update(kwrds)\\n return default\",\n \"def default_environment():\\n return dict(_VARS)\",\n \"def base_site(request):\\n from django.conf import settings\\n\\n context = {}\\n context['STATIC_URL'] = '/static/'\\n context['BASE_SIDEBAR'] = 'yui-t2'\\n\\n if hasattr(settings, 'STATIC_URL'):\\n context['STATIC_URL'] = settings.STATIC_URL\\n\\n if not hasattr(settings, 'BASE_SIDEBAR'):\\n return context\\n\\n if settings.BASE_SIDEBAR == 'left':\\n context['BASE_SIDEBAR'] = 'yui-t2'\\n if settings.BASE_SIDEBAR == 'right':\\n context['BASE_SIDEBAR'] = 'yui-t4'\\n\\n return context\",\n \"def setGlobal(name, value):\",\n \"def make_template_values(request):\\n user = users.get_current_user()\\n values = {'request': request}\\n if user:\\n values['logged_in'] = True\\n values['loginout_url'] = users.create_logout_url(request.uri)\\n values['loginout_url_linktext'] = 'Logout ({})'.format(user)\\n else:\\n values['logged_in'] = False\\n values['loginout_url'] = users.create_login_url(request.uri)\\n values['loginout_url_linktext'] = 'Login'\\n return values\",\n \"def globals_load(plugin_context, globals_, symbols):\\n for g in [plugin_context.rosh_globals, globals_]:\\n if g is not None:\\n g.update(symbols)\",\n \"def _initialize_project_variables(self):\\n self.Source = ''\\n self.Regional = ''\\n self.Vernacular = ''\\n self.Fallback = dict()\\n self.New_Target = dict()\\n self.Biblical_Terms = dict()\\n self.Old_Target = dict()\\n\\n# self.list_projects = []\\n# self.project_lines = []\\n# self.indent = 0\\n# self.Treed = False\\n self.root = etree.Element('root')\\n# #add child 'settings', all user configurable bits under here\\n self.settings = etree.SubElement(self.root, \\\"settings\\\")\\n# self.old_mode = dict()\\n# self.spreferred = etree.SubElement(self.settings, \\\"preferred\\\")\\n# self.smode = etree.SubElement(self.settings, \\\"mode\\\")\\n# self.stemp = etree.SubElement(self.settings, \\\"template\\\")\\n self.sf0 = etree.SubElement(self.settings, \\\"f0\\\")\\n self.sf1 = etree.SubElement(self.settings, \\\"f1\\\")\\n self.sf2 = etree.SubElement(self.settings, \\\"f2\\\")\\n self.trout = etree.SubElement(self.root, \\\"tree\\\")\",\n \"def debug_context(request):\\n\\n return {\\n 'DEBUG': settings.DEBUG,\\n }\",\n \"def common_template_data(request, revision=None, mime_type=None):\\n\\n cfg = request.cfg\\n\\n # Initialize data dictionary members (sorted alphanumerically)\\n data = TemplateData(\\n {\\n \\\"annotate_href\\\": None,\\n \\\"cfg\\\": cfg,\\n \\\"docroot\\\": (\\n cfg.options.docroot is None\\n and request.script_name + \\\"/\\\" + docroot_magic_path\\n or cfg.options.docroot\\n ),\\n \\\"download_href\\\": None,\\n \\\"download_text_href\\\": None,\\n \\\"graph_href\\\": None,\\n \\\"home_href\\\": request.script_name or \\\"/\\\",\\n \\\"kv\\\": request.kv,\\n \\\"lockinfo\\\": None,\\n \\\"log_href\\\": None,\\n \\\"nav_path\\\": nav_path(request),\\n \\\"pathtype\\\": None,\\n \\\"prefer_markup\\\": ezt.boolean(0),\\n \\\"queryform_href\\\": None,\\n \\\"rev\\\": None,\\n \\\"revision_href\\\": None,\\n \\\"rootname\\\": (request.rootname and request.server.escape(request.rootname) or None),\\n \\\"rootpath\\\": request.rootpath,\\n \\\"roots_href\\\": None,\\n \\\"roottype\\\": request.roottype,\\n \\\"rss_href\\\": None,\\n \\\"tarball_href\\\": None,\\n \\\"up_href\\\": None,\\n \\\"username\\\": request.username,\\n \\\"view\\\": _view_codes[request.view_func],\\n \\\"view_href\\\": None,\\n \\\"vsn\\\": __version__,\\n \\\"where\\\": request.server.escape(request.where),\\n }\\n )\\n\\n rev = revision\\n if not rev:\\n rev = request.query_dict.get(\\\"annotate\\\")\\n if not rev:\\n rev = request.query_dict.get(\\\"revision\\\")\\n if not rev and request.roottype == \\\"svn\\\":\\n rev = request.query_dict.get(\\\"pathrev\\\")\\n try:\\n data[\\\"rev\\\"] = hasattr(request.repos, \\\"_getrev\\\") and request.repos._getrev(rev) or rev\\n except vclib.InvalidRevision:\\n raise ViewVCException(\\\"Invalid revision\\\", \\\"404 Not Found\\\")\\n\\n if request.pathtype == vclib.DIR:\\n data[\\\"pathtype\\\"] = \\\"dir\\\"\\n elif request.pathtype == vclib.FILE:\\n data[\\\"pathtype\\\"] = \\\"file\\\"\\n\\n if request.path_parts:\\n dir = _path_join(request.path_parts[:-1])\\n data[\\\"up_href\\\"] = request.get_url(\\n view_func=view_directory, where=dir, pathtype=vclib.DIR, params={}, escape=1\\n )\\n\\n if \\\"roots\\\" in cfg.options.allowed_views:\\n data[\\\"roots_href\\\"] = request.get_url(view_func=view_roots, escape=1, params={})\\n\\n if request.pathtype == vclib.FILE:\\n fvi = get_file_view_info(request, request.where, data[\\\"rev\\\"], mime_type)\\n data[\\\"view_href\\\"] = fvi.view_href\\n data[\\\"download_href\\\"] = fvi.download_href\\n data[\\\"download_text_href\\\"] = fvi.download_text_href\\n data[\\\"annotate_href\\\"] = fvi.annotate_href\\n data[\\\"revision_href\\\"] = fvi.revision_href\\n data[\\\"prefer_markup\\\"] = fvi.prefer_markup\\n data[\\\"log_href\\\"] = request.get_url(view_func=view_log, params={}, escape=1)\\n if request.roottype == \\\"cvs\\\" and cfg.options.use_cvsgraph:\\n data[\\\"graph_href\\\"] = request.get_url(view_func=view_cvsgraph, params={}, escape=1)\\n file_data = request.repos.listdir(request.path_parts[:-1], request.pathrev, {})\\n entries = [item for item in file_data if item.name == request.path_parts[-1]]\\n if len(entries) == 1:\\n request.repos.dirlogs(request.path_parts[:-1], request.pathrev, entries, {})\\n data[\\\"lockinfo\\\"] = entries[0].lockinfo\\n elif request.pathtype == vclib.DIR:\\n data[\\\"view_href\\\"] = request.get_url(view_func=view_directory, params={}, escape=1)\\n if \\\"tar\\\" in cfg.options.allowed_views:\\n data[\\\"tarball_href\\\"] = request.get_url(view_func=download_tarball, params={}, escape=1)\\n if request.roottype == \\\"svn\\\":\\n data[\\\"revision_href\\\"] = request.get_url(\\n view_func=view_revision, params={\\\"revision\\\": data[\\\"rev\\\"]}, escape=1\\n )\\n\\n data[\\\"log_href\\\"] = request.get_url(view_func=view_log, params={}, escape=1)\\n\\n if is_querydb_nonempty_for_root(request):\\n if request.pathtype == vclib.DIR:\\n params = {}\\n if request.roottype == \\\"cvs\\\" and request.pathrev:\\n params[\\\"branch\\\"] = request.pathrev\\n data[\\\"queryform_href\\\"] = request.get_url(\\n view_func=view_queryform, params=params, escape=1\\n )\\n data[\\\"rss_href\\\"] = request.get_url(\\n view_func=view_query, params={\\\"date\\\": \\\"month\\\", \\\"format\\\": \\\"rss\\\"}, escape=1\\n )\\n elif request.pathtype == vclib.FILE:\\n parts = _path_parts(request.where)\\n where = _path_join(parts[:-1])\\n data[\\\"rss_href\\\"] = request.get_url(\\n view_func=view_query,\\n where=where,\\n pathtype=request.pathtype,\\n params={\\\"date\\\": \\\"month\\\", \\\"format\\\": \\\"rss\\\", \\\"file\\\": parts[-1], \\\"file_match\\\": \\\"exact\\\"},\\n escape=1,\\n )\\n return data\",\n \"def index(request):\\n return render(request, 'items/index.html', {\\n 'globalvars': globalvars,\\n 'fart': 'fart'\\n })\",\n \"def _addGlobals(self, globalsDict):\\n globalsDict['obj'] = None\\n globalsDict['role'] = None\\n globalsDict['pyatspi'] = pyatspi\",\n \"def get_context_data(self, **kwargs):\\n # Making an object of 'HomeView class'\\n # 'context' variable is an object of Parent class 'HomeView'.\\n # 'super()' identifies that, 'get_context_data' is a parent class's function.\\n # Here, we are using Recursion\\n context = super().get_context_data(**kwargs)\\n # '['injection']' is a key and 'Basic Injection!' is the value which will be shown on Template.\\n context['injection'] = \\\"Basic Injection!\\\"\\n return context\",\n \"def __init__(self, *args, **kwargs):\\n if not kwargs.get('no_django', False):\\n overrides = dict([(k, getattr(middleware, k, None),) for k in django_variables])\\n kwargs.update(overrides)\\n super(Template, self).__init__(*args, **kwargs)\",\n \"def get_variables(self):\\n\\t\\treturn self.variables\",\n \"def ioc(globals):\\n\\tfrom Module.Shapes.ShapeFactory import shape_factory\\n\\tglobals['shape_factory'] = shape_factory\\n\\tfrom Module.Lighting.Colors import Colors\\n\\tglobals['Colors'] = Colors\",\n \"def __init__(self):\\n self.context={}\",\n \"def __init__(self):\\n self.context={}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73522717","0.70804507","0.6623835","0.6614453","0.6387393","0.6256472","0.61475796","0.61302704","0.6017198","0.5988722","0.5954301","0.5932908","0.5932745","0.5928411","0.59138465","0.58811116","0.58521664","0.58481276","0.5838821","0.5833165","0.5792599","0.578112","0.5740566","0.57113785","0.56821847","0.5677584","0.5676554","0.56669664","0.56617594","0.5629286","0.56262076","0.56082356","0.5598494","0.55657744","0.55581844","0.553626","0.55149144","0.54936","0.5491348","0.5479304","0.5452235","0.5427078","0.5394575","0.53904545","0.53883564","0.53784835","0.5375586","0.5371812","0.53466815","0.5331608","0.5327024","0.5321076","0.53122157","0.531024","0.53049034","0.53024817","0.5302046","0.53008497","0.5299427","0.5299016","0.52960914","0.52950424","0.5293809","0.5289502","0.52788","0.52745605","0.52706534","0.52670467","0.5260091","0.52581227","0.5257664","0.5243804","0.5229288","0.52258575","0.52206683","0.52133703","0.52088034","0.52070564","0.5204037","0.51903844","0.51824206","0.5137377","0.5131418","0.5127344","0.51179165","0.51080865","0.50979733","0.509132","0.50896823","0.5083258","0.5077465","0.50746745","0.50604856","0.5052939","0.50520116","0.5043003","0.50405246","0.5040099","0.5026797","0.5026797"],"string":"[\n \"0.73522717\",\n \"0.70804507\",\n \"0.6623835\",\n \"0.6614453\",\n \"0.6387393\",\n \"0.6256472\",\n \"0.61475796\",\n \"0.61302704\",\n \"0.6017198\",\n \"0.5988722\",\n \"0.5954301\",\n \"0.5932908\",\n \"0.5932745\",\n \"0.5928411\",\n \"0.59138465\",\n \"0.58811116\",\n \"0.58521664\",\n \"0.58481276\",\n \"0.5838821\",\n \"0.5833165\",\n \"0.5792599\",\n \"0.578112\",\n \"0.5740566\",\n \"0.57113785\",\n \"0.56821847\",\n \"0.5677584\",\n \"0.5676554\",\n \"0.56669664\",\n \"0.56617594\",\n \"0.5629286\",\n \"0.56262076\",\n \"0.56082356\",\n \"0.5598494\",\n \"0.55657744\",\n \"0.55581844\",\n \"0.553626\",\n \"0.55149144\",\n \"0.54936\",\n \"0.5491348\",\n \"0.5479304\",\n \"0.5452235\",\n \"0.5427078\",\n \"0.5394575\",\n \"0.53904545\",\n \"0.53883564\",\n \"0.53784835\",\n \"0.5375586\",\n \"0.5371812\",\n \"0.53466815\",\n \"0.5331608\",\n \"0.5327024\",\n \"0.5321076\",\n \"0.53122157\",\n \"0.531024\",\n \"0.53049034\",\n \"0.53024817\",\n \"0.5302046\",\n \"0.53008497\",\n \"0.5299427\",\n \"0.5299016\",\n \"0.52960914\",\n \"0.52950424\",\n \"0.5293809\",\n \"0.5289502\",\n \"0.52788\",\n \"0.52745605\",\n \"0.52706534\",\n \"0.52670467\",\n \"0.5260091\",\n \"0.52581227\",\n \"0.5257664\",\n \"0.5243804\",\n \"0.5229288\",\n \"0.52258575\",\n \"0.52206683\",\n \"0.52133703\",\n \"0.52088034\",\n \"0.52070564\",\n \"0.5204037\",\n \"0.51903844\",\n \"0.51824206\",\n \"0.5137377\",\n \"0.5131418\",\n \"0.5127344\",\n \"0.51179165\",\n \"0.51080865\",\n \"0.50979733\",\n \"0.509132\",\n \"0.50896823\",\n \"0.5083258\",\n \"0.5077465\",\n \"0.50746745\",\n \"0.50604856\",\n \"0.5052939\",\n \"0.50520116\",\n \"0.5043003\",\n \"0.50405246\",\n \"0.5040099\",\n \"0.5026797\",\n \"0.5026797\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6709685"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":17082,"cells":{"query":{"kind":"string","value":"raise WinproxyError if result is 0"},"document":{"kind":"string","value":"def fail_on_zero(func_name, result, func, args):\n if not result:\n raise WinproxyError(func_name)\n return args"},"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 winhttp_WinHttpFreeProxyResult(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"pProxyResult\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def winhttp_WinHttpGetProxyResult(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hResolver\", \"pProxyResult\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def ErrCheckBool(result, func, args):\n if not result:\n raise WinError()\n return args","def ErrCheckHandle(result, func, args):\n if not result:\n raise WinError()\n return AutoHANDLE(result)","def error_if_null_return(retval: Any, func: Callable, args: Tuple[Any]):\n if not retval:\n raise WinError()\n return retval","def _check_return(self, name, ret_code):\n if ret_code == 0:\n pass\n else:\n raise RuntimeError('An error occured setting %s: %d' % (name, ret_code))","def retry(self):\n # XXX: check whether it is possible to distingish \n # between the error conditions and set meaningfull exitcode\n return False","def _check_error(return_value):\n if return_value < 0:\n raise IOError(pm.lib.Pm_GetErrorText(return_value))","def check_proxy(q):\n\n\n if not q.empty():\n\n proxy = q.get(False)\n proxy = proxy.strip()\n\n\n try:\n \n is_working = False\n\n if not is_bad_proxy(proxy):\n proxys_working_list.update({proxy: proxy})\n\n \n\n print(bcolors.OKGREEN + \" --[+] \", proxy, \" | PASS\" + bcolors.ENDC)\n\n else:\n print(\" --[!] \", proxy, \" | FAILED\")\n \n \n\n except Exception as err:\n print(\" --[!] \", proxy, \" | FAILED | \" + str(err))","def check_result(ec):\r\n # NOTE: This will break some oscilloscopes that are powered by USB.\r\n # Some of the newer scopes, can actually be powered by USB and will\r\n # return a useful value. That should be given back to the user.\r\n # I guess we can deal with these edge cases in the functions themselves\r\n if ec == 0:\r\n return\r\n\r\n else:\r\n ecName = error_num_to_name(ec)\r\n ecDesc = error_num_to_desc(ec)\r\n raise IOError('Error calling %s: %s (%s)' % (\r\n str(inspect.stack()[1][3]), ecName, ecDesc))","def _tunnel_success(tunnel_returncode):\n return tunnel_returncode < 0","def proxy_check(self, proxy):","def CHK(err):\n if err < 0:\n buf_size = 100\n buf = ctypes.create_string_buffer('\\000' * buf_size)\n nidaq.DAQmxGetErrorString(err,ctypes.byref(buf),buf_size)\n raise RuntimeError('nidaq call failed with error %d: %s'%(err,repr(buf.value)))","def _check(self,err):\r\n if err < 0:\r\n buf_size = 128\r\n buf = create_string_buffer('\\000' * buf_size)\r\n self.nidaq.DAQmxGetErrorString(err,byref(buf),buf_size)\r\n raise RuntimeError('NI-DAQ call failed with error %d: %s'%(err,repr(buf.value)))","def winhttp_WinHttpGetProxyForUrlEx(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hResolver\", \"pcwszUrl\", \"pAutoProxyOptions\", \"pContext\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def checkResult(self, errorCode):\n # NOTE: This will break some oscilloscopes that are powered by USB.\n # Some of the newer scopes, can actually be powered by USB and will\n # return a useful value. That should be given back to the user.\n # I guess we can deal with these edge cases in the functions themselves\n if errorCode == 0:\n return\n\n else:\n ecName = self.errorNumToName(errorCode)\n ecDesc = self.errorNumToDesc(errorCode)\n raise IOError('Error calling %s: %s (%s)' % (\n str(inspect.stack()[1][3]), ecName, ecDesc))","def _checknet():\n exit_code = os.system('ping -c 1 www.baidu.com 1>/dev/null 2>&1')\n return exit_code","def winhttp_WinHttpOpen(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"pwszUserAgent\", \"dwAccessType\", \"pwszProxyName\", \"pwszProxyBypass\", \"dwFlags\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def is_bad_proxy(pip, url):\n try:\n res = requests.get(\n url,\n proxies={'http':pip},\n headers={'User-agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0'},\n timeout=10\n )\n except Exception as e:\n return 1\n if res.status_code == 200:\n return 0\n\n print(res.status_code)\n return 1","def proxy_error(response):\n r = HttpResponse(\n response.content,\n content_type=response.headers[\"content-type\"],\n status=response.status_code,\n )\n r.setdefault(\"X-PROMGEN-PROXY\", response.url)\n return r","def magmaCheckStatus(status):\n\n if status != 0:\n raise MagmaError(status)","def _check(error: int) -> None:\n if error < 0:\n raise RuntimeError(ffi.string(lib.TCOD_get_error()).decode())","def systcpconnfail(self) :\n\t\ttry :\n\t\t\treturn self._systcpconnfail\n\t\texcept Exception as e:\n\t\t\traise e","def check_proxy_status(proxy_ip):\n try:\n status = subprocess.check_output([\"ping\", \"-c\",\"1\", proxy_ip]).decode('utf-8')\n if status.find(\"1 received\") > -1:\n return True\n except subprocess.CalledProcessError as e:\n return False\n\n return False","def ConnectByNameError(self) -> _n_0_t_14:","def check_exit_code(results):\n assert results[\"metrics\"][\"Exit code\"] == 0","def clientconnfail(self) :\n\t\ttry :\n\t\t\treturn self._clientconnfail\n\t\texcept Exception as e:\n\t\t\traise e","def connectFailed(self, reason):\n\t\tself._tunnelReadyDeferred.errback(reason)","def execute_failure(self, *args, **kwargs):\n return 1, \"\", None","def check_success(odbc_obj, ret):\n if ret not in (SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NO_DATA, SQL_NULL_DATA):\n if isinstance(odbc_obj, Cursor):\n ctrl_err(SQL_HANDLE_STMT, odbc_obj.stmt_h, odbc_obj.ansi)\n elif isinstance(odbc_obj, Connection):\n ctrl_err(SQL_HANDLE_DBC, odbc_obj.dbc_h, odbc_obj.ansi)\n else:\n ctrl_err(SQL_HANDLE_ENV, odbc_obj, False)","def test_QRCodeFail(self):\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n s.connect(ADDRESS)\n self.assertFalse(Functions.detectQR(s))","def test_check_replication_unknown_valueerror1(self, mock_urlopen):\n base_url = '.'\n mock_urlopen.side_effect = ValueError(Mock(return_value=''))\n result = check_replication(base_url, [4, 10, 4, 10])\n self.assertEqual(result,\n 3*[(STATUS_UNKNOWN,\n \"Can't parse status data\")])","def lastError(self):\n self.bib.DapiGetLastError.argtypes = [] # None geht nicht?!\n self.bib.DapiGetLastError.restype = c_ulong\n error = self.bib.DapiGetLastError()\n if error > self.DAPI_ERR_NONE:\n print(\"Delib error number: {\", hex(error),\"}\")\n self.bib.DapiClearLastError()\n return(hex(error))\n else:\n #print(\"OK\",end=\"\", flush=True)\n return(0)","def test_not_running(): # pragma: windows\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)","def failure(self, result):\r\n raise NotImplementedError","def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False","def status_3proxy():\n p = Popen(\"service 3proxy status\", shell=True, stdout=PIPE, stderr=PIPE)\n (so, se) = p.communicate()\n return True if p.returncode == 0 else False","def proxy_result(self):\n return None","def hasGridProxy():\n import os\n from subprocess import Popen, PIPE\n \n arguments = 'dirac-proxy-info --checkvalid'\n arguments = ['dirac-command'] + arguments.split()\n logger.verbose ( 'hasGridProxy:use Popen(%s)' % arguments)\n\n p = Popen(arguments, stdout=PIPE, stderr=PIPE)\n (cout, cerr) = p.communicate()\n #\n if 0 != p.returncode: return False\n #\n if py3 :\n cout = cout.decode ( 'utf-8' ) if cout else cout \n cerr = cerr.decode ( 'utf-8' ) if cerr else cerr \n # \n\n if 'expired' in cout : return False\n if 'Insane' in cout : return False\n if 'Error' in cout : return False\n #\n return 0 == p.returncode and cout and not cerr","def test_get_report_connection_error(self):\n err_code = 0\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\n try:\n vt_analyses.get_report('test_object_id')\n except VirusTotalAPIError as err:\n err_code = err.err_code\n self.assertEqual(err_code, errno.ECONNABORTED)","def test_check_if_not_error(self):\n actual_result = SshpassErrorExitCodeController(OK_RETURN_CODE,\n OK_MESSAGE)\\\n .check_if_error()\n self.assertIsNone(actual_result)","def _CHK(self,_err):\n if _err < 0:\n buf_size = 100\n buf = ctypes.create_string_buffer('\\000' * buf_size)\n nidaq.DAQmxGetErrorString(_err,ctypes.byref(buf),buf_size)\n raise RuntimeError(\"nidaq call failed with error %d: %s\"%(_err,repr(buf.value)))\n if _err > 0:\n buf_size = 100\n buf = ctypes.create_string_buffer('\\000' * buf_size)\n nidaq.DAQmxGetErrorString(_err,ctypes.byref(buf),buf_size)\n raise RuntimeError(\"nidaq generated warning %d: %s\"%(_err,repr(buf.value)))","def verif(self, verif=False):\r\n\r\n \r\n try:\r\n urlO = tmout(self.makeTheUrlOpener,timeout_duration=15)\r\n ip = tmout(getMyIp,(urlO,)) #getMyIp(urlO)\r\n \r\n if verif:\r\n ip.index(str(self.url))\r\n if not ip:\r\n raise Exception('Impossible de se connecte en moins de 30 sec')\r\n \r\n \r\n except Exception as inst:\r\n print '\\terreur de Proxy : %s' % (inst)\r\n #print type(inst) # the exception instance\r\n #print inst.args # arguments stored in .args\r\n pass\r\n else:\r\n print '- Proxy Ok -'\r\n return True","def test_ipcrm_not_isntalled(): # pragma: windows\n IPCComm.ipcrm()","def shellExecErrorCode(cmd):\n return subprocess.call(cmd, shell=True)","def test_analytics_proxy_reqfailed(self, act):\r\n act.return_value = self.FakeBadProxyResponse()\r\n\r\n url = reverse('proxy_legacy_analytics', kwargs={'course_id': self.course.id.to_deprecated_string()})\r\n response = self.client.get(url, {\r\n 'aname': 'ProblemGradeDistribution'\r\n })\r\n self.assertEqual(response.status_code, 500)","def ReturnCode(rc):\r\n return _hiew.ReturnCode(rc)","def test_connect_53371():\n with patch(\n \"socket.getaddrinfo\",\n autospec=True,\n side_effect=socket.gaierror(\"[Errno 11004] getaddrinfo failed\"),\n ):\n rtn = win_network.connect(\"test-server\", 80)\n assert rtn\n assert not rtn[\"result\"]\n assert (\n rtn[\"comment\"]\n == \"Unable to connect to test-server (unknown) on tcp port 80\"\n )","def test_check_replication_unknown_valueerror2(self, mock_urlopen):\n base_url = 'http://localhost:6000/recon/'\n jdata = PropertyMock(return_value=b'X')\n mock_urlopen.return_value = MagicMock(read=jdata)\n result = check_replication(base_url, [4, 10, 4, 10])\n self.assertEqual(result,\n 3*[(STATUS_UNKNOWN,\n \"Can't parse status data\")])","def SocketErrorCode(self) -> SocketError:","def error():\n return None","def test_check_if_not_error(self):\n actual_result = ExecutionExitCodeController(OK_RETURN_CODE,\n OK_MESSAGE)\\\n .check_if_error()\n self.assertIsNone(actual_result)","def prnt_error():\n print \"Error!\\n\"\n return False","def onCheckConnectionError(self):\r\n\r\n # show the error message\r\n msgBox = QMessageBox(self)\r\n msgBox.setWindowTitle(conf_parser.get(\"APP\", \"name\"))\r\n msgBox.setText(\"Internet connection not detected.\")\r\n msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Close)\r\n msgBox.setDefaultButton(QMessageBox.Close)\r\n ret = msgBox.exec()\r\n\r\n # interact user\r\n if(ret == QMessageBox.Close):\r\n # exit program\r\n sys.exit()\r\n if(ret == QMessageBox.Retry):\r\n # retry connection\r\n self.thread = threading.Thread(target=self.checkServerThread)\r\n self.thread.setDaemon(True)\r\n self.thread.start()\r\n self.pros = 0\r\n self.check_timer.start(100)","def test_handles_no_output(self):\n self.assertRaises(ValueError, self.pybird.get_peer_status, \"no output\")","def onConnectError(self, fetcher, error): #$NON-NLS-1$\r","def test_check_replication_unknown_urlerror(self, mock_urlopen):\n base_url = 'http://localhost:6000/recon/'\n url = '{}replication/{}'\n error = 'connection refused'\n mock_urlopen.side_effect = (urllib\n .error\n .URLError(Mock(return_value=error)))\n result = check_replication(base_url, 60)\n expected_result = [(STATUS_UNKNOWN,\n \"Can't open url: \"\n \"{}\".format(url.format(base_url, name)))\n for name in ('account', 'object', 'container')]\n self.assertEqual(result, expected_result)","def validate_ping(result):\n if '0 packets received' in str(result) or 'no answer from' in str(result) or '0 received' in str(result):\n print 'Conectividade - DOWN'\n return False\n print 'Conectividade - OK'\n return True","def raise_connection_error(api_url, headers, timeout, proxies):\n raise requests.exceptions.ConnectionError","def raise_connection_error(api_url, headers, timeout, proxies):\n raise requests.exceptions.ConnectionError","def winhttp_WinHttpResetAutoProxy(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hSession\", \"dwFlags\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def test_404(self):\n response = self.make_call(origin='Milano Lambrate', destination='Milano Cadorna')\n self.assert400(response)","def check_result(self, result):\n self.log.info(\"--check_result, result= %s\", result)\n if result[0]['exit_status'] != 0:\n self.fail(\"##Error detected from check_result\")\n else:\n self.log.info(\"--check_result passed\")","def _check_for_api_errors(geocoding_results):\n status_result = geocoding_results.get(\"STATUS\", {})\n api_call_success = status_result.get(\"status\", \"\") == \"SUCCESS\"\n if not api_call_success:\n access_error = status_result.get(\"access\")\n access_error_to_exception = {\n 'API_KEY_INVALID': GeocoderAuthenticationFailure,\n 'OVER_QUERY_LIMIT': GeocoderQuotaExceeded,\n }\n exception_cls = access_error_to_exception.get(\n access_error, GeocoderServiceError\n )\n raise exception_cls(access_error)","def decide_to_retry(error):\n return True","def ERR(self):","def test_ip_addr_fails(self, mock_ghn, mock_grnam, mock_pwnam):\n # Should pass\n self.driver.check_for_setup_error()\n # Throw exception, need to clear internal cached host in driver\n self._fail_ip = True\n self.driver._vgc_host = None\n self.assertRaises(exception.VolumeDriverException,\n self.driver.check_for_setup_error)","def winhttp_WinHttpGetProxyForUrl(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hSession\", \"lpcwszUrl\", \"pAutoProxyOptions\", \"pProxyInfo\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def raise_connection_error_get_votes(api_url, headers, params, timeout, proxies):\n raise requests.exceptions.ConnectionError","def _errcheck_link(value, func, args): # pylint: disable=W0613\n # The windows api returns nonzero if the call was successful\n if value != 0:\n return\n\n last_error = ctypes.windll.kernel32.GetLastError()\n # Somehow CreateSymbolicLinkW and CreateHardLinkW retuns zero\n # and the last error is 2 (The system cannot find the file specified)\n # but the link is created successfuly\n # it seems like a bug in the WinAPI\n if last_error == 0 or last_error == 2:\n return\n if last_error == 183:\n raise OSError(errno.EEXIST,\n \"Cannot create a file when that file already exists\",\n args[0])","def retry_on_py4j_network(exc: Exception) -> bool:\n return isinstance(exc, Py4JNetworkError)","def retry_if_connection_error(exception):\r\n # return True\r\n return isinstance(exception, HttpError)","def __connect_failed__(self):\n # Ask the user what to do with the error\n choice = input(\"[A]bort, [C]hange address and port, or [R]etry?\")\n if (choice.lower() == \"a\"):\n exit()\n elif (choice.lower() == \"c\"):\n address = input(\"Please enter the address:\")\n port_number = input(\"Please enter the port:\")","def test_check_if_not_error(self):\n actual_result = SshErrorExitCodeController(ERROR_RETURN_CODE,\n OK_MESSAGE)\\\n .check_if_error()\n self.assertIsNone(actual_result)","def test_with_bad_resolution():\n try:\n site_parser.get_wallpapers_urls(\"07-2020\", \"1920x10\")\n except SystemExit:\n assert True\n else:\n assert False","def test_ALLOWED_RPC_FAILS(self):\n self.assertIsInstance(constants.ALLOWED_RPC_FAILS, int,\n \"constants.ALLOWED_RPC_FAILS must be an \" +\n \"integer.\")","def _raise_performing_request_error(self, *args, **kwargs):","def connection_failed(self, connection, error):\n assert False","def _CheckConnect(self):\n try:\n resp = requests.get(self._target_url, timeout=2)\n if resp.headers['Maximum-Bytes']:\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\n return resp.status_code == 200\n except requests.exceptions.ConnectionError:\n return False\n except Exception as e:\n self.exception('Unexpected test connect failure: %s', str(e))\n return False","def test_startconnector_with_noretry_on_con_failure(self):\n\n yield self.connect('127.0.0.1', self.pbPort)\n\n localConfig = copy.copy(self.defaultConfig)\n localConfig.reconnectOnConnectionFailure = False\n yield self.add(localConfig)\n yield self.start(localConfig.id)\n\n # It takes a moment to stop the service after a connection failure\n while True:\n ssRet = yield self.service_status(localConfig.id)\n if ssRet != 1:\n break;\n else:\n time.sleep(1)\n\n self.assertEqual(0, ssRet)\n\n yield self.stop(localConfig.id)","def checkGetHostByName(self, result):\n self.assertEquals(result, '127.0.0.1')","def test_check_if_not_error(self):\n actual_result = SshErrorExitCodeController(OK_RETURN_CODE,\n OK_MESSAGE)\\\n .check_if_error()\n self.assertIsNone(actual_result)","def test_get_availability_with_error(self, m):\n url = \"https://www.cellartracker.com/xlquery.asp?User=test-username&Password=test-password&Table=Availability&Format=tab&Location=1\"\n m.register_uri(\"GET\", url, exc=requests.exceptions.ConnectTimeout)\n\n cellartracker = CellarTracker(username=\"test-username\", password=\"test-password\")\n with self.assertRaises(CannotConnect):\n cellartracker.get_availability()","def test():\n if not MpUsbApi.__get_dll():\n return \"Error loading library mpusbapi.dll, it is missing or not installed!\"\n return None\n #end test()","def retry(self):\n return False","def lch_mw_check_failed(shell, obj):\n trade_qualifying_query_folder_name = CONFIG_PARAMS['Front_Trade_qualifying_query_folder']\n query_folder = acm.FStoredASQLQuery[trade_qualifying_query_folder_name.Text()]\n trade = obj\n if query_folder:\n if query_folder.Query().IsSatisfiedBy(trade):\n if not trade.AdditionalInfo().CCPmiddleware_id():\n message = 'Cannot book the trade in LCH portfolio.\\n\\nPlease enter Clearing ID in MarkitWire tab and try again.'\n popup_error(shell, message)\n return True\n \n return False","def cbr_not_avalible():\n return \"CBR service is unavailable\", 503","def test_rsp_failure(self):\n\n def handle(event):\n return 0x0112, None\n\n self.ae = ae = AE()\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n ae.network_timeout = 5\n ae.add_supported_context(DisplaySystem)\n scp = ae.start_server(\n (\"localhost\", 11112), block=False, evt_handlers=[(evt.EVT_N_GET, handle)]\n )\n\n ae.add_requested_context(DisplaySystem)\n assoc = ae.associate(\"localhost\", 11112)\n assert assoc.is_established\n\n status, ds = assoc.send_n_get(\n [(0x7FE0, 0x0010)], DisplaySystem, \"1.2.840.10008.5.1.1.40.1\"\n )\n assert status.Status == 0x0112\n assert ds is None\n assoc.release()\n assert assoc.is_released\n\n scp.shutdown()","def _access_wxapi_or_raise(self, *args, **kwargs):\n r = json.loads(get_remote(*args, **kwargs))\n\n if \"errcode\" in r:\n raise Exception(\"errcode: \" + str(r[\"errcode\"]) + \", errmsg: \" + r[\"errmsg\"])\n\n return r","def testFailure(self):\n request = b'hello'\n reply = self.sendAndReceive(request)\n self.assertEqual(2, reply[0])","def test_validate_callback_connection_error(self):\n with patch('requests.get') as mock:\n mock.side_effect = requests.exceptions.ConnectionError\n with self.assertRaises(InvalidProxyCallback):\n ProxyGrantingTicket.objects.validate_callback('http://www.example.com/', 'https://www.example.org/',\n self.pgtid, self.pgtiou)","def connectionLost(reason):","def _process_fetch_failure(self):\n logger.info('DataFetcher: No valid result is received')\n if len(self.urls_processed) == len(self.urls):\n raise NoDataReceivedFromCaster()\n for _, error_code, error_text in self._curls_failed:\n if error_code == PYCURL_TIMEOUT_ERRNO:\n raise ExceededTimeoutError(error_text)\n if self._curls_failed:\n _, _, error_text = self._curls_failed[0]\n raise UnableToConnect(error_text)\n raise NoDataReceivedFromCaster()","def error_invalid_response(self):\r\n return self.type() == 0x00","def test_check_if_not_error(self):\n actual_result = BaseErrorExitCodeController(OK_RETURN_CODE,\n OK_MESSAGE)\\\n .check_if_error()\n self.assertIsNone(actual_result)","def test_validate_callback_invalid_status(self):\n with patch('requests.get') as mock:\n mock.return_value.raise_for_status.side_effect = requests.exceptions.HTTPError\n with self.assertRaises(InvalidProxyCallback):\n ProxyGrantingTicket.objects.validate_callback('http://www.example.com/', 'https://www.example.org/',\n self.pgtid, self.pgtiou)","def winhttp_WinHttpConnect(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hSession\", \"pswzServerName\", \"nServerPort\", \"dwReserved\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def robust_proxy_visit(url):\n page = None\n while not page:\n try:\n proxy = db.zrange('spool', -1, -1)[0]\n except:\n proxy = None\n # if not proxy:\n # print('there is no proxy left, need to refill')\n page = utils.visit(url, proxy)\n if proxy:\n print('successfully visited {} via proxy {}, add it back'.format(url, proxy))\n db.zadd('spool', time.time(), proxy)\n else:\n print('directly visited {}'.format(url))\n return page, proxy","def retcode(self):\n if not self.result:\n return None\n return self.result.retcode","def call_silent(args):\n try:\n check_call(args)\n return 0\n except FailedSystemCall as e:\n return e.retcode"],"string":"[\n \"def winhttp_WinHttpFreeProxyResult(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"pProxyResult\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def winhttp_WinHttpGetProxyResult(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hResolver\\\", \\\"pProxyResult\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def ErrCheckBool(result, func, args):\\n if not result:\\n raise WinError()\\n return args\",\n \"def ErrCheckHandle(result, func, args):\\n if not result:\\n raise WinError()\\n return AutoHANDLE(result)\",\n \"def error_if_null_return(retval: Any, func: Callable, args: Tuple[Any]):\\n if not retval:\\n raise WinError()\\n return retval\",\n \"def _check_return(self, name, ret_code):\\n if ret_code == 0:\\n pass\\n else:\\n raise RuntimeError('An error occured setting %s: %d' % (name, ret_code))\",\n \"def retry(self):\\n # XXX: check whether it is possible to distingish \\n # between the error conditions and set meaningfull exitcode\\n return False\",\n \"def _check_error(return_value):\\n if return_value < 0:\\n raise IOError(pm.lib.Pm_GetErrorText(return_value))\",\n \"def check_proxy(q):\\n\\n\\n if not q.empty():\\n\\n proxy = q.get(False)\\n proxy = proxy.strip()\\n\\n\\n try:\\n \\n is_working = False\\n\\n if not is_bad_proxy(proxy):\\n proxys_working_list.update({proxy: proxy})\\n\\n \\n\\n print(bcolors.OKGREEN + \\\" --[+] \\\", proxy, \\\" | PASS\\\" + bcolors.ENDC)\\n\\n else:\\n print(\\\" --[!] \\\", proxy, \\\" | FAILED\\\")\\n \\n \\n\\n except Exception as err:\\n print(\\\" --[!] \\\", proxy, \\\" | FAILED | \\\" + str(err))\",\n \"def check_result(ec):\\r\\n # NOTE: This will break some oscilloscopes that are powered by USB.\\r\\n # Some of the newer scopes, can actually be powered by USB and will\\r\\n # return a useful value. That should be given back to the user.\\r\\n # I guess we can deal with these edge cases in the functions themselves\\r\\n if ec == 0:\\r\\n return\\r\\n\\r\\n else:\\r\\n ecName = error_num_to_name(ec)\\r\\n ecDesc = error_num_to_desc(ec)\\r\\n raise IOError('Error calling %s: %s (%s)' % (\\r\\n str(inspect.stack()[1][3]), ecName, ecDesc))\",\n \"def _tunnel_success(tunnel_returncode):\\n return tunnel_returncode < 0\",\n \"def proxy_check(self, proxy):\",\n \"def CHK(err):\\n if err < 0:\\n buf_size = 100\\n buf = ctypes.create_string_buffer('\\\\000' * buf_size)\\n nidaq.DAQmxGetErrorString(err,ctypes.byref(buf),buf_size)\\n raise RuntimeError('nidaq call failed with error %d: %s'%(err,repr(buf.value)))\",\n \"def _check(self,err):\\r\\n if err < 0:\\r\\n buf_size = 128\\r\\n buf = create_string_buffer('\\\\000' * buf_size)\\r\\n self.nidaq.DAQmxGetErrorString(err,byref(buf),buf_size)\\r\\n raise RuntimeError('NI-DAQ call failed with error %d: %s'%(err,repr(buf.value)))\",\n \"def winhttp_WinHttpGetProxyForUrlEx(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hResolver\\\", \\\"pcwszUrl\\\", \\\"pAutoProxyOptions\\\", \\\"pContext\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def checkResult(self, errorCode):\\n # NOTE: This will break some oscilloscopes that are powered by USB.\\n # Some of the newer scopes, can actually be powered by USB and will\\n # return a useful value. That should be given back to the user.\\n # I guess we can deal with these edge cases in the functions themselves\\n if errorCode == 0:\\n return\\n\\n else:\\n ecName = self.errorNumToName(errorCode)\\n ecDesc = self.errorNumToDesc(errorCode)\\n raise IOError('Error calling %s: %s (%s)' % (\\n str(inspect.stack()[1][3]), ecName, ecDesc))\",\n \"def _checknet():\\n exit_code = os.system('ping -c 1 www.baidu.com 1>/dev/null 2>&1')\\n return exit_code\",\n \"def winhttp_WinHttpOpen(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"pwszUserAgent\\\", \\\"dwAccessType\\\", \\\"pwszProxyName\\\", \\\"pwszProxyBypass\\\", \\\"dwFlags\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def is_bad_proxy(pip, url):\\n try:\\n res = requests.get(\\n url,\\n proxies={'http':pip},\\n headers={'User-agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0'},\\n timeout=10\\n )\\n except Exception as e:\\n return 1\\n if res.status_code == 200:\\n return 0\\n\\n print(res.status_code)\\n return 1\",\n \"def proxy_error(response):\\n r = HttpResponse(\\n response.content,\\n content_type=response.headers[\\\"content-type\\\"],\\n status=response.status_code,\\n )\\n r.setdefault(\\\"X-PROMGEN-PROXY\\\", response.url)\\n return r\",\n \"def magmaCheckStatus(status):\\n\\n if status != 0:\\n raise MagmaError(status)\",\n \"def _check(error: int) -> None:\\n if error < 0:\\n raise RuntimeError(ffi.string(lib.TCOD_get_error()).decode())\",\n \"def systcpconnfail(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._systcpconnfail\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def check_proxy_status(proxy_ip):\\n try:\\n status = subprocess.check_output([\\\"ping\\\", \\\"-c\\\",\\\"1\\\", proxy_ip]).decode('utf-8')\\n if status.find(\\\"1 received\\\") > -1:\\n return True\\n except subprocess.CalledProcessError as e:\\n return False\\n\\n return False\",\n \"def ConnectByNameError(self) -> _n_0_t_14:\",\n \"def check_exit_code(results):\\n assert results[\\\"metrics\\\"][\\\"Exit code\\\"] == 0\",\n \"def clientconnfail(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._clientconnfail\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def connectFailed(self, reason):\\n\\t\\tself._tunnelReadyDeferred.errback(reason)\",\n \"def execute_failure(self, *args, **kwargs):\\n return 1, \\\"\\\", None\",\n \"def check_success(odbc_obj, ret):\\n if ret not in (SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NO_DATA, SQL_NULL_DATA):\\n if isinstance(odbc_obj, Cursor):\\n ctrl_err(SQL_HANDLE_STMT, odbc_obj.stmt_h, odbc_obj.ansi)\\n elif isinstance(odbc_obj, Connection):\\n ctrl_err(SQL_HANDLE_DBC, odbc_obj.dbc_h, odbc_obj.ansi)\\n else:\\n ctrl_err(SQL_HANDLE_ENV, odbc_obj, False)\",\n \"def test_QRCodeFail(self):\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\\n s.connect(ADDRESS)\\n self.assertFalse(Functions.detectQR(s))\",\n \"def test_check_replication_unknown_valueerror1(self, mock_urlopen):\\n base_url = '.'\\n mock_urlopen.side_effect = ValueError(Mock(return_value=''))\\n result = check_replication(base_url, [4, 10, 4, 10])\\n self.assertEqual(result,\\n 3*[(STATUS_UNKNOWN,\\n \\\"Can't parse status data\\\")])\",\n \"def lastError(self):\\n self.bib.DapiGetLastError.argtypes = [] # None geht nicht?!\\n self.bib.DapiGetLastError.restype = c_ulong\\n error = self.bib.DapiGetLastError()\\n if error > self.DAPI_ERR_NONE:\\n print(\\\"Delib error number: {\\\", hex(error),\\\"}\\\")\\n self.bib.DapiClearLastError()\\n return(hex(error))\\n else:\\n #print(\\\"OK\\\",end=\\\"\\\", flush=True)\\n return(0)\",\n \"def test_not_running(): # pragma: windows\\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)\",\n \"def failure(self, result):\\r\\n raise NotImplementedError\",\n \"def _connect_failed(self):\\n\\t\\tself.root.stdout.write(\\\"Error: Connection Failed!\\\\n\\\")\\n\\t\\tself.client = False\",\n \"def status_3proxy():\\n p = Popen(\\\"service 3proxy status\\\", shell=True, stdout=PIPE, stderr=PIPE)\\n (so, se) = p.communicate()\\n return True if p.returncode == 0 else False\",\n \"def proxy_result(self):\\n return None\",\n \"def hasGridProxy():\\n import os\\n from subprocess import Popen, PIPE\\n \\n arguments = 'dirac-proxy-info --checkvalid'\\n arguments = ['dirac-command'] + arguments.split()\\n logger.verbose ( 'hasGridProxy:use Popen(%s)' % arguments)\\n\\n p = Popen(arguments, stdout=PIPE, stderr=PIPE)\\n (cout, cerr) = p.communicate()\\n #\\n if 0 != p.returncode: return False\\n #\\n if py3 :\\n cout = cout.decode ( 'utf-8' ) if cout else cout \\n cerr = cerr.decode ( 'utf-8' ) if cerr else cerr \\n # \\n\\n if 'expired' in cout : return False\\n if 'Insane' in cout : return False\\n if 'Error' in cout : return False\\n #\\n return 0 == p.returncode and cout and not cerr\",\n \"def test_get_report_connection_error(self):\\n err_code = 0\\n vt_analyses = VirusTotalAPIAnalyses('test_api_key')\\n try:\\n vt_analyses.get_report('test_object_id')\\n except VirusTotalAPIError as err:\\n err_code = err.err_code\\n self.assertEqual(err_code, errno.ECONNABORTED)\",\n \"def test_check_if_not_error(self):\\n actual_result = SshpassErrorExitCodeController(OK_RETURN_CODE,\\n OK_MESSAGE)\\\\\\n .check_if_error()\\n self.assertIsNone(actual_result)\",\n \"def _CHK(self,_err):\\n if _err < 0:\\n buf_size = 100\\n buf = ctypes.create_string_buffer('\\\\000' * buf_size)\\n nidaq.DAQmxGetErrorString(_err,ctypes.byref(buf),buf_size)\\n raise RuntimeError(\\\"nidaq call failed with error %d: %s\\\"%(_err,repr(buf.value)))\\n if _err > 0:\\n buf_size = 100\\n buf = ctypes.create_string_buffer('\\\\000' * buf_size)\\n nidaq.DAQmxGetErrorString(_err,ctypes.byref(buf),buf_size)\\n raise RuntimeError(\\\"nidaq generated warning %d: %s\\\"%(_err,repr(buf.value)))\",\n \"def verif(self, verif=False):\\r\\n\\r\\n \\r\\n try:\\r\\n urlO = tmout(self.makeTheUrlOpener,timeout_duration=15)\\r\\n ip = tmout(getMyIp,(urlO,)) #getMyIp(urlO)\\r\\n \\r\\n if verif:\\r\\n ip.index(str(self.url))\\r\\n if not ip:\\r\\n raise Exception('Impossible de se connecte en moins de 30 sec')\\r\\n \\r\\n \\r\\n except Exception as inst:\\r\\n print '\\\\terreur de Proxy : %s' % (inst)\\r\\n #print type(inst) # the exception instance\\r\\n #print inst.args # arguments stored in .args\\r\\n pass\\r\\n else:\\r\\n print '- Proxy Ok -'\\r\\n return True\",\n \"def test_ipcrm_not_isntalled(): # pragma: windows\\n IPCComm.ipcrm()\",\n \"def shellExecErrorCode(cmd):\\n return subprocess.call(cmd, shell=True)\",\n \"def test_analytics_proxy_reqfailed(self, act):\\r\\n act.return_value = self.FakeBadProxyResponse()\\r\\n\\r\\n url = reverse('proxy_legacy_analytics', kwargs={'course_id': self.course.id.to_deprecated_string()})\\r\\n response = self.client.get(url, {\\r\\n 'aname': 'ProblemGradeDistribution'\\r\\n })\\r\\n self.assertEqual(response.status_code, 500)\",\n \"def ReturnCode(rc):\\r\\n return _hiew.ReturnCode(rc)\",\n \"def test_connect_53371():\\n with patch(\\n \\\"socket.getaddrinfo\\\",\\n autospec=True,\\n side_effect=socket.gaierror(\\\"[Errno 11004] getaddrinfo failed\\\"),\\n ):\\n rtn = win_network.connect(\\\"test-server\\\", 80)\\n assert rtn\\n assert not rtn[\\\"result\\\"]\\n assert (\\n rtn[\\\"comment\\\"]\\n == \\\"Unable to connect to test-server (unknown) on tcp port 80\\\"\\n )\",\n \"def test_check_replication_unknown_valueerror2(self, mock_urlopen):\\n base_url = 'http://localhost:6000/recon/'\\n jdata = PropertyMock(return_value=b'X')\\n mock_urlopen.return_value = MagicMock(read=jdata)\\n result = check_replication(base_url, [4, 10, 4, 10])\\n self.assertEqual(result,\\n 3*[(STATUS_UNKNOWN,\\n \\\"Can't parse status data\\\")])\",\n \"def SocketErrorCode(self) -> SocketError:\",\n \"def error():\\n return None\",\n \"def test_check_if_not_error(self):\\n actual_result = ExecutionExitCodeController(OK_RETURN_CODE,\\n OK_MESSAGE)\\\\\\n .check_if_error()\\n self.assertIsNone(actual_result)\",\n \"def prnt_error():\\n print \\\"Error!\\\\n\\\"\\n return False\",\n \"def onCheckConnectionError(self):\\r\\n\\r\\n # show the error message\\r\\n msgBox = QMessageBox(self)\\r\\n msgBox.setWindowTitle(conf_parser.get(\\\"APP\\\", \\\"name\\\"))\\r\\n msgBox.setText(\\\"Internet connection not detected.\\\")\\r\\n msgBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Close)\\r\\n msgBox.setDefaultButton(QMessageBox.Close)\\r\\n ret = msgBox.exec()\\r\\n\\r\\n # interact user\\r\\n if(ret == QMessageBox.Close):\\r\\n # exit program\\r\\n sys.exit()\\r\\n if(ret == QMessageBox.Retry):\\r\\n # retry connection\\r\\n self.thread = threading.Thread(target=self.checkServerThread)\\r\\n self.thread.setDaemon(True)\\r\\n self.thread.start()\\r\\n self.pros = 0\\r\\n self.check_timer.start(100)\",\n \"def test_handles_no_output(self):\\n self.assertRaises(ValueError, self.pybird.get_peer_status, \\\"no output\\\")\",\n \"def onConnectError(self, fetcher, error): #$NON-NLS-1$\\r\",\n \"def test_check_replication_unknown_urlerror(self, mock_urlopen):\\n base_url = 'http://localhost:6000/recon/'\\n url = '{}replication/{}'\\n error = 'connection refused'\\n mock_urlopen.side_effect = (urllib\\n .error\\n .URLError(Mock(return_value=error)))\\n result = check_replication(base_url, 60)\\n expected_result = [(STATUS_UNKNOWN,\\n \\\"Can't open url: \\\"\\n \\\"{}\\\".format(url.format(base_url, name)))\\n for name in ('account', 'object', 'container')]\\n self.assertEqual(result, expected_result)\",\n \"def validate_ping(result):\\n if '0 packets received' in str(result) or 'no answer from' in str(result) or '0 received' in str(result):\\n print 'Conectividade - DOWN'\\n return False\\n print 'Conectividade - OK'\\n return True\",\n \"def raise_connection_error(api_url, headers, timeout, proxies):\\n raise requests.exceptions.ConnectionError\",\n \"def raise_connection_error(api_url, headers, timeout, proxies):\\n raise requests.exceptions.ConnectionError\",\n \"def winhttp_WinHttpResetAutoProxy(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hSession\\\", \\\"dwFlags\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def test_404(self):\\n response = self.make_call(origin='Milano Lambrate', destination='Milano Cadorna')\\n self.assert400(response)\",\n \"def check_result(self, result):\\n self.log.info(\\\"--check_result, result= %s\\\", result)\\n if result[0]['exit_status'] != 0:\\n self.fail(\\\"##Error detected from check_result\\\")\\n else:\\n self.log.info(\\\"--check_result passed\\\")\",\n \"def _check_for_api_errors(geocoding_results):\\n status_result = geocoding_results.get(\\\"STATUS\\\", {})\\n api_call_success = status_result.get(\\\"status\\\", \\\"\\\") == \\\"SUCCESS\\\"\\n if not api_call_success:\\n access_error = status_result.get(\\\"access\\\")\\n access_error_to_exception = {\\n 'API_KEY_INVALID': GeocoderAuthenticationFailure,\\n 'OVER_QUERY_LIMIT': GeocoderQuotaExceeded,\\n }\\n exception_cls = access_error_to_exception.get(\\n access_error, GeocoderServiceError\\n )\\n raise exception_cls(access_error)\",\n \"def decide_to_retry(error):\\n return True\",\n \"def ERR(self):\",\n \"def test_ip_addr_fails(self, mock_ghn, mock_grnam, mock_pwnam):\\n # Should pass\\n self.driver.check_for_setup_error()\\n # Throw exception, need to clear internal cached host in driver\\n self._fail_ip = True\\n self.driver._vgc_host = None\\n self.assertRaises(exception.VolumeDriverException,\\n self.driver.check_for_setup_error)\",\n \"def winhttp_WinHttpGetProxyForUrl(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hSession\\\", \\\"lpcwszUrl\\\", \\\"pAutoProxyOptions\\\", \\\"pProxyInfo\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def raise_connection_error_get_votes(api_url, headers, params, timeout, proxies):\\n raise requests.exceptions.ConnectionError\",\n \"def _errcheck_link(value, func, args): # pylint: disable=W0613\\n # The windows api returns nonzero if the call was successful\\n if value != 0:\\n return\\n\\n last_error = ctypes.windll.kernel32.GetLastError()\\n # Somehow CreateSymbolicLinkW and CreateHardLinkW retuns zero\\n # and the last error is 2 (The system cannot find the file specified)\\n # but the link is created successfuly\\n # it seems like a bug in the WinAPI\\n if last_error == 0 or last_error == 2:\\n return\\n if last_error == 183:\\n raise OSError(errno.EEXIST,\\n \\\"Cannot create a file when that file already exists\\\",\\n args[0])\",\n \"def retry_on_py4j_network(exc: Exception) -> bool:\\n return isinstance(exc, Py4JNetworkError)\",\n \"def retry_if_connection_error(exception):\\r\\n # return True\\r\\n return isinstance(exception, HttpError)\",\n \"def __connect_failed__(self):\\n # Ask the user what to do with the error\\n choice = input(\\\"[A]bort, [C]hange address and port, or [R]etry?\\\")\\n if (choice.lower() == \\\"a\\\"):\\n exit()\\n elif (choice.lower() == \\\"c\\\"):\\n address = input(\\\"Please enter the address:\\\")\\n port_number = input(\\\"Please enter the port:\\\")\",\n \"def test_check_if_not_error(self):\\n actual_result = SshErrorExitCodeController(ERROR_RETURN_CODE,\\n OK_MESSAGE)\\\\\\n .check_if_error()\\n self.assertIsNone(actual_result)\",\n \"def test_with_bad_resolution():\\n try:\\n site_parser.get_wallpapers_urls(\\\"07-2020\\\", \\\"1920x10\\\")\\n except SystemExit:\\n assert True\\n else:\\n assert False\",\n \"def test_ALLOWED_RPC_FAILS(self):\\n self.assertIsInstance(constants.ALLOWED_RPC_FAILS, int,\\n \\\"constants.ALLOWED_RPC_FAILS must be an \\\" +\\n \\\"integer.\\\")\",\n \"def _raise_performing_request_error(self, *args, **kwargs):\",\n \"def connection_failed(self, connection, error):\\n assert False\",\n \"def _CheckConnect(self):\\n try:\\n resp = requests.get(self._target_url, timeout=2)\\n if resp.headers['Maximum-Bytes']:\\n self._max_bytes = int(resp.headers['Maximum-Bytes'])\\n return resp.status_code == 200\\n except requests.exceptions.ConnectionError:\\n return False\\n except Exception as e:\\n self.exception('Unexpected test connect failure: %s', str(e))\\n return False\",\n \"def test_startconnector_with_noretry_on_con_failure(self):\\n\\n yield self.connect('127.0.0.1', self.pbPort)\\n\\n localConfig = copy.copy(self.defaultConfig)\\n localConfig.reconnectOnConnectionFailure = False\\n yield self.add(localConfig)\\n yield self.start(localConfig.id)\\n\\n # It takes a moment to stop the service after a connection failure\\n while True:\\n ssRet = yield self.service_status(localConfig.id)\\n if ssRet != 1:\\n break;\\n else:\\n time.sleep(1)\\n\\n self.assertEqual(0, ssRet)\\n\\n yield self.stop(localConfig.id)\",\n \"def checkGetHostByName(self, result):\\n self.assertEquals(result, '127.0.0.1')\",\n \"def test_check_if_not_error(self):\\n actual_result = SshErrorExitCodeController(OK_RETURN_CODE,\\n OK_MESSAGE)\\\\\\n .check_if_error()\\n self.assertIsNone(actual_result)\",\n \"def test_get_availability_with_error(self, m):\\n url = \\\"https://www.cellartracker.com/xlquery.asp?User=test-username&Password=test-password&Table=Availability&Format=tab&Location=1\\\"\\n m.register_uri(\\\"GET\\\", url, exc=requests.exceptions.ConnectTimeout)\\n\\n cellartracker = CellarTracker(username=\\\"test-username\\\", password=\\\"test-password\\\")\\n with self.assertRaises(CannotConnect):\\n cellartracker.get_availability()\",\n \"def test():\\n if not MpUsbApi.__get_dll():\\n return \\\"Error loading library mpusbapi.dll, it is missing or not installed!\\\"\\n return None\\n #end test()\",\n \"def retry(self):\\n return False\",\n \"def lch_mw_check_failed(shell, obj):\\n trade_qualifying_query_folder_name = CONFIG_PARAMS['Front_Trade_qualifying_query_folder']\\n query_folder = acm.FStoredASQLQuery[trade_qualifying_query_folder_name.Text()]\\n trade = obj\\n if query_folder:\\n if query_folder.Query().IsSatisfiedBy(trade):\\n if not trade.AdditionalInfo().CCPmiddleware_id():\\n message = 'Cannot book the trade in LCH portfolio.\\\\n\\\\nPlease enter Clearing ID in MarkitWire tab and try again.'\\n popup_error(shell, message)\\n return True\\n \\n return False\",\n \"def cbr_not_avalible():\\n return \\\"CBR service is unavailable\\\", 503\",\n \"def test_rsp_failure(self):\\n\\n def handle(event):\\n return 0x0112, None\\n\\n self.ae = ae = AE()\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n ae.network_timeout = 5\\n ae.add_supported_context(DisplaySystem)\\n scp = ae.start_server(\\n (\\\"localhost\\\", 11112), block=False, evt_handlers=[(evt.EVT_N_GET, handle)]\\n )\\n\\n ae.add_requested_context(DisplaySystem)\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n assert assoc.is_established\\n\\n status, ds = assoc.send_n_get(\\n [(0x7FE0, 0x0010)], DisplaySystem, \\\"1.2.840.10008.5.1.1.40.1\\\"\\n )\\n assert status.Status == 0x0112\\n assert ds is None\\n assoc.release()\\n assert assoc.is_released\\n\\n scp.shutdown()\",\n \"def _access_wxapi_or_raise(self, *args, **kwargs):\\n r = json.loads(get_remote(*args, **kwargs))\\n\\n if \\\"errcode\\\" in r:\\n raise Exception(\\\"errcode: \\\" + str(r[\\\"errcode\\\"]) + \\\", errmsg: \\\" + r[\\\"errmsg\\\"])\\n\\n return r\",\n \"def testFailure(self):\\n request = b'hello'\\n reply = self.sendAndReceive(request)\\n self.assertEqual(2, reply[0])\",\n \"def test_validate_callback_connection_error(self):\\n with patch('requests.get') as mock:\\n mock.side_effect = requests.exceptions.ConnectionError\\n with self.assertRaises(InvalidProxyCallback):\\n ProxyGrantingTicket.objects.validate_callback('http://www.example.com/', 'https://www.example.org/',\\n self.pgtid, self.pgtiou)\",\n \"def connectionLost(reason):\",\n \"def _process_fetch_failure(self):\\n logger.info('DataFetcher: No valid result is received')\\n if len(self.urls_processed) == len(self.urls):\\n raise NoDataReceivedFromCaster()\\n for _, error_code, error_text in self._curls_failed:\\n if error_code == PYCURL_TIMEOUT_ERRNO:\\n raise ExceededTimeoutError(error_text)\\n if self._curls_failed:\\n _, _, error_text = self._curls_failed[0]\\n raise UnableToConnect(error_text)\\n raise NoDataReceivedFromCaster()\",\n \"def error_invalid_response(self):\\r\\n return self.type() == 0x00\",\n \"def test_check_if_not_error(self):\\n actual_result = BaseErrorExitCodeController(OK_RETURN_CODE,\\n OK_MESSAGE)\\\\\\n .check_if_error()\\n self.assertIsNone(actual_result)\",\n \"def test_validate_callback_invalid_status(self):\\n with patch('requests.get') as mock:\\n mock.return_value.raise_for_status.side_effect = requests.exceptions.HTTPError\\n with self.assertRaises(InvalidProxyCallback):\\n ProxyGrantingTicket.objects.validate_callback('http://www.example.com/', 'https://www.example.org/',\\n self.pgtid, self.pgtiou)\",\n \"def winhttp_WinHttpConnect(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hSession\\\", \\\"pswzServerName\\\", \\\"nServerPort\\\", \\\"dwReserved\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def robust_proxy_visit(url):\\n page = None\\n while not page:\\n try:\\n proxy = db.zrange('spool', -1, -1)[0]\\n except:\\n proxy = None\\n # if not proxy:\\n # print('there is no proxy left, need to refill')\\n page = utils.visit(url, proxy)\\n if proxy:\\n print('successfully visited {} via proxy {}, add it back'.format(url, proxy))\\n db.zadd('spool', time.time(), proxy)\\n else:\\n print('directly visited {}'.format(url))\\n return page, proxy\",\n \"def retcode(self):\\n if not self.result:\\n return None\\n return self.result.retcode\",\n \"def call_silent(args):\\n try:\\n check_call(args)\\n return 0\\n except FailedSystemCall as e:\\n return e.retcode\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68406665","0.63366336","0.6020998","0.6016139","0.58826256","0.5877293","0.5857276","0.582949","0.57794017","0.5773708","0.57534397","0.56958175","0.5652606","0.5602097","0.5585624","0.5577021","0.55100924","0.5496161","0.54908186","0.5478192","0.54240996","0.54150003","0.5410886","0.5403818","0.5382604","0.5370788","0.5363099","0.5312704","0.5312337","0.52970254","0.5291511","0.5280685","0.52806616","0.5279163","0.5270123","0.52399737","0.52380973","0.52253133","0.5225081","0.5220199","0.5205886","0.51956224","0.51887506","0.51694596","0.51692903","0.5167241","0.5160167","0.514646","0.51389796","0.5137648","0.5134121","0.5126122","0.51088655","0.5107984","0.51058775","0.5101548","0.5087008","0.5078893","0.50780916","0.50780916","0.50764596","0.5075149","0.5071964","0.5058571","0.505813","0.5057423","0.5048607","0.5045799","0.50456053","0.5040462","0.50392616","0.50365573","0.50326204","0.50249654","0.50239813","0.5022587","0.5013451","0.49994284","0.49985904","0.4996568","0.4993674","0.49898407","0.4985935","0.4985357","0.4981448","0.49812013","0.49808052","0.49789962","0.49745327","0.4973109","0.4971371","0.49670914","0.49636662","0.49491993","0.4946916","0.49401662","0.49384832","0.49375534","0.4937245","0.49239662"],"string":"[\n \"0.68406665\",\n \"0.63366336\",\n \"0.6020998\",\n \"0.6016139\",\n \"0.58826256\",\n \"0.5877293\",\n \"0.5857276\",\n \"0.582949\",\n \"0.57794017\",\n \"0.5773708\",\n \"0.57534397\",\n \"0.56958175\",\n \"0.5652606\",\n \"0.5602097\",\n \"0.5585624\",\n \"0.5577021\",\n \"0.55100924\",\n \"0.5496161\",\n \"0.54908186\",\n \"0.5478192\",\n \"0.54240996\",\n \"0.54150003\",\n \"0.5410886\",\n \"0.5403818\",\n \"0.5382604\",\n \"0.5370788\",\n \"0.5363099\",\n \"0.5312704\",\n \"0.5312337\",\n \"0.52970254\",\n \"0.5291511\",\n \"0.5280685\",\n \"0.52806616\",\n \"0.5279163\",\n \"0.5270123\",\n \"0.52399737\",\n \"0.52380973\",\n \"0.52253133\",\n \"0.5225081\",\n \"0.5220199\",\n \"0.5205886\",\n \"0.51956224\",\n \"0.51887506\",\n \"0.51694596\",\n \"0.51692903\",\n \"0.5167241\",\n \"0.5160167\",\n \"0.514646\",\n \"0.51389796\",\n \"0.5137648\",\n \"0.5134121\",\n \"0.5126122\",\n \"0.51088655\",\n \"0.5107984\",\n \"0.51058775\",\n \"0.5101548\",\n \"0.5087008\",\n \"0.5078893\",\n \"0.50780916\",\n \"0.50780916\",\n \"0.50764596\",\n \"0.5075149\",\n \"0.5071964\",\n \"0.5058571\",\n \"0.505813\",\n \"0.5057423\",\n \"0.5048607\",\n \"0.5045799\",\n \"0.50456053\",\n \"0.5040462\",\n \"0.50392616\",\n \"0.50365573\",\n \"0.50326204\",\n \"0.50249654\",\n \"0.50239813\",\n \"0.5022587\",\n \"0.5013451\",\n \"0.49994284\",\n \"0.49985904\",\n \"0.4996568\",\n \"0.4993674\",\n \"0.49898407\",\n \"0.4985935\",\n \"0.4985357\",\n \"0.4981448\",\n \"0.49812013\",\n \"0.49808052\",\n \"0.49789962\",\n \"0.49745327\",\n \"0.4973109\",\n \"0.4971371\",\n \"0.49670914\",\n \"0.49636662\",\n \"0.49491993\",\n \"0.4946916\",\n \"0.49401662\",\n \"0.49384832\",\n \"0.49375534\",\n \"0.4937245\",\n \"0.49239662\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.721989"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17083,"cells":{"query":{"kind":"string","value":"Function called when extension is loaded."},"document":{"kind":"string","value":"def setup(bot):\n bot.logger.debug(\n 'Registering extension \"Quiz\"'\n )\n bot.add_cog(QuizCog(bot))"},"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 on_load(self):\n pass","def on_load(self):\n pass","def init_extensions(self, package, module):\n\n pass","def on_load(self):","def on_startup(self) -> None:\n ...","def on_load(self):\n self.__init__()","def __init_on_load__(self):","def test_load(self):\n class TestExtension(Extension):\n pass\n\n self.setup_extension(TestExtension, enable=False)\n\n self.assertEqual(self.manager.get_installed_extensions(),\n [TestExtension])\n self.assertEqual(len(self.manager.get_enabled_extensions()), 0)\n self.assertTrue(hasattr(TestExtension, 'info'))\n self.assertEqual(TestExtension.info.name, self.test_project_name)\n self.assertTrue(hasattr(TestExtension, 'registration'))\n self.assertEqual(TestExtension.registration.name,\n self.test_project_name)","def plugin_loaded():\n events.broadcast(\"plugin_loaded\")","def extensions():\n\n pass","def _post_load(self):\n pass","def get_loaded_extensions():\n raise NotImplementedError()","def init():\n return _libsbml.CompExtension_init()","def CompExtension_init():\n return _libsbml.CompExtension_init()","def OnStartup(cls, modName ):\r\n import sys\r\n targetMod = sys.modules[ modName ]\r\n cls.StartupVarsInjectToMod( targetMod )\r\n EasyIpyMagics.RegisterMagics()\r\n \r\n cls.RegisterPostExecute()","def load_extensions(self):\n extension_module_name = f\"{utils.get_project_name()}.cogs\"\n for extension in CONF.LOADED_EXTENSIONS:\n try:\n self.load_extension(extension_module_name + \".\" + extension)\n LOG.debug(f\"The extension '{extension.split('.')[0]}' has been successfully loaded\")\n except Exception as e:\n message = f\"Failed to load extension '{extension.split('.')[0]}'\"\n LOG.exception(log.get_log_exception_message(message, e))","def init():\n return _libsbml.MultiExtension_init()","def _afterInit(self):\n pass","def on_window_ready(self):\n pass","def onInit(self):\n pass","def load_ep(entry_point):\n logger.debug('Loading extension: %s', entry_point)\n try:\n func = entry_point.load()\n func()\n except Exception as e:\n msg = (f\"Numba extension module '{entry_point.module}' \"\n f\"failed to load due to '{type(e).__name__}({str(e)})'.\")\n warnings.warn(msg, stacklevel=3)\n logger.debug('Extension loading failed for: %s', entry_point)","def getExtension(self): #$NON-NLS-1$\r","def afterInit(self):","def init_app(app):\n app.load_extension(__name__)","def MultiExtension_init():\n return _libsbml.MultiExtension_init()","def on_loaded(self, func):\n self._on_loaded_funcs.append(func)","def postLoad(self):\n pass","def init():\n return _libsbml.QualExtension_init()","def _add_extensions(self):\n ext_cache_down = 'cache_downloading'\n ext_cache_up = 'cache_uploading'\n cmd_args = self.task_data.get('cmd_args', {})\n if not isinstance(cmd_args, dict):\n cmd_args = {}\n if cmd_args.get('save_raw_pages', False):\n self.required_signals[SIGNAL_SPIDER_OPENED]['wait'] += \\\n EXTENSION_SIGNALS[ext_cache_up]\n if cmd_args.get('load_raw_pages'):\n self.required_signals[SIGNAL_SCRIPT_CLOSED]['wait'] += \\\n EXTENSION_SIGNALS[ext_cache_down]","def QualExtension_init():\n return _libsbml.QualExtension_init()","def handle_reload_toolbox(self):","def init():\n return _libsbml.FbcExtension_init()","def init():\n global PLUGIN_NAME\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename","def mod_load(self):\n raise NotImplementedError(\"Mod load isn't overriden\")","def on_initialize(self) -> None:\n pass","def Extension_Init():\n\n # After calling this, we will be able to invoke glFogCoordEXT ()\n if not glInitFogCoordEXT():\n print(\"Help! No GL_EXT_ForCoord\")\n sys.exit(1)\n return False\n return True","def core_plugin(self):\n pass","def extension_hooks(self, global_step):\n return []","def extension_hooks(self, global_step):\n return []","def __macroLoad(self):\n self.activeWindow().macroLoad()","def test_load_full_reload_hooks(self):\n class TestExtension(Extension):\n pass\n\n extension = self.setup_extension(TestExtension)\n\n self.assertEqual(len(self.manager.get_installed_extensions()), 1)\n self.assertEqual(len(self.manager.get_enabled_extensions()), 1)\n\n URLHook(extension, ())\n self.assertEqual(len(URLHook.hooks), 1)\n self.assertEqual(URLHook.hooks[0].extension, extension)\n\n self.manager.load(full_reload=True)\n\n self.assertEqual(len(URLHook.hooks), 0)","def _post_init(self):\n pass","def plugin_loaded():\n # Required for sublime.packages_path().\n # ST only \"loads resources\" from the Packages dir.\n global _temp_path\n packages_path = sublime.packages_path()\n _temp_path = os.path.join(packages_path, _temp_dir_name)\n\n _remove_temp_path()","def post_init(self):\n\t\tpass","def preReadyInitalizatize(self):\n self.pbug(\"Pre Ready Initalization\")\n self.xj(\"window.onerror = miteErrorCallback\")\n for funcs in self.j_funcs:\n if \"bind\" in funcs:\n for bind in funcs[\"bind\"]:\n self.pbug(\"Binding {0} function to #{1}\".format(bind, funcs[\"name\"]))\n script = \"$('#{0}').attr('{1}', '{2}()');\".format(bind, funcs[\"event\"], funcs[\"name\"])\n self.xj(script)\n self.pbug(\"Mite Load Finished\")","def inject_extensions(self, extensions: Dict[str, str]) -> None:\n self.extensions = extensions","def on_hook(self) -> None:","def ready(self):\n from django_sites_extensions import models\n from django_sites_extensions import signals","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def on_start(self):\n pass","def force_load(self):\n pass","def onReload(self,moduleName=\"NeedleFinder\"):\n if profiling : profbox()\n #framework\n globals()[moduleName] = slicer.util.reloadScriptedModule(moduleName)","def FbcExtension_init():\n return _libsbml.FbcExtension_init()","def __init__(cls, *args, **kwargs):\n super(ExtensionMeta, cls).__init__(*args, **kwargs)\n scope = ExtensionMeta._get_extension_scope(cls)\n\n # Only register application extension here\n if scope is ExtensionScope.APPLICATION:\n ExtensionMeta._register_application_extension(cls)","def findExtensions(self):\n if SYSTEM_EXTENSIONS:\n self._populateExtensions()\n return\n\n pylabs.q.logger.log('Loading pylabs extensions from %s' % self.extensionsRootPath,7)\n\n #Add extensions base dir to sys.path\n sys.path.append(self.extensionsRootPath)\n\n SYSTEM_EXTENSIONS.extend(self.findExtensionInfo())\n\n self._populateExtensions()","def load_extension(self, name):\n if name in self.__extensions.loaded_by_core:\n raise commands.ExtensionAlreadyLoaded(name)\n try:\n cog_module = importlib.import_module(f'extensions.{name}.cogs')\n except ImportError:\n cog_module = importlib.import_module(f'hero.extensions.{name}.cogs')\n\n self.__settings[name] = self.__extensions[name].get_settings(self)\n self.__controllers[name] = self.__extensions[name].get_controller(self)\n\n if hasattr(cog_module, 'setup'):\n cog_module.setup(self, name)\n else:\n cog_classes = inspect.getmembers(cog_module, lambda member: isinstance(member, type) and\n issubclass(member, hero.Cog) and member is not hero.Cog)\n for _, _Cog in cog_classes:\n if _Cog is None:\n raise ImportError(f\"The {name} extension's cog module didn't have \"\n f\"any Cog subclass and no setup function\")\n self.add_cog(_Cog(self, self.__extensions[name]))\n\n self.__extensions.loaded_by_core.append(name)\n return cog_module","def _setup(self):","def _setup(self):","def setup_hooks(self):\n pass","def load(self):\n self.__additionnal_datas.update({\n 'hostname_fqdn': socket.getfqdn(),\n 'hostname': socket.gethostname(),\n 'ipcheck_version': self.__ipcheck_version,\n })\n # parse all trigger section in config file\n for section in filter(lambda s: self.RE_EXTENSION_SECTION.match(s) is not None, self.cp.sections()):\n conf = dict(self.cp.items(section))\n conf['name'] = section.partition('.')[2].lower()\n ext_name = conf['name']\n # check if the trigger name contains only alpha caracters\n if not ext_name.isalpha():\n self.__logger.error('[extension] Extension name \"%s\" must contains only alphabetical caracters', ext_name)\n continue\n # import process\n try:\n m = __import__('ipcheckadvanced.extension.' + ext_name, fromlist=['Extension'])\n ext = m.Extension()\n if not isinstance(ext, ExtensionBase):\n # inheritance error\n self.__logger.error('[extension] Extension \"%s\" must inherit from TriggerHandler class',\n ext_name)\n continue\n ext.logger = logging.getLogger('ipcheck.' + ext_name)\n ext.configuration = conf\n ext.event_receiver = self\n if ext.load():\n self.__extensions.append(ext)\n self.__logger.debug('[extension] loaded extension %s', ext_name)\n else:\n # loading error\n self.__logger.error('[extension] Extension \"%s\" cannot be loaded', ext_name)\n except ImportError as e:\n self.__logger.error('[extension] Extension \"%s\" name cannot be found in extension directory %s',\n ext_name, str(e))\n except NotImplementedError as e:\n self.__logger.error('[extension] Extension \"%s\" must implement the method \"%s\"',\n ext_name, str(e))\n except KeyError as e:\n self.__logger.error('[extension] Extension \"%s\" require %s missing parameters see extension documentation',\n ext_name, str(e))\n except Exception as e:\n self.__logger.error('[extension] Extension \"%s\" has encountered an unknown error: %s',\n ext_name, str(e))\n self.__logger.exception(e)\n # # return false if no trigger have been loaded\n return self.hasExtensions()","def extensions(self):\n raise NotImplementedError()","def ready(self):\n # export app settings\n self.export_settings()\n # import the submodule with signal handlers\n self.load_module('signals')","def _hook(self):","def _post_init(self) -> None:\n return","def on_start(self):\n self.init()","def on_modules_loaded(self, loader, callback=None):\n enabled_list = self.get_enabled_modules()\n \n self.update_modules_priority(enabled_list)\n \n self._keybinder.connect(\"activated\", lambda k,t: self._emit_keybinding_activated(t))\n self._emit_loaded()\n \n for mod in enabled_list:\n modinst = self._module_list.get_module_instance_from_name( mod )\n if modinst != None:\n self._module_loader.initialize_module_async( modinst )\n self._loaded_modules += 1","def on_init(self):\n self.write_log(\"策略初始化\")\n self.load_bar(1)","def startup(self) -> None:","def __load_cogs(self):\n for cog in self.__cogs.get():\n logging.info('loading %s', cog)\n self.load_extension(cog)","def test_register_with_another_extension(self):\n DummyLoader.register()\n DummyLoader.register(extensions=('.example2',))\n self.assertIs(getattr(sys, HOOK_NAME)['.example2'], DummyLoader)","def on_init(self):\n self.write_log(\"策略初始化\")\n\n self.load_bar(10)","def _register_application_extension(cls, extension):\n # Should skip registering AppExtensionBase, cannot use isinstance(),\n # referring to app_extension_hooks introduces a dependency cycle\n if extension.__name__ == 'AppExtensionBase':\n return\n\n if getattr(extension, 'init', None):\n extension.init()\n\n cls._set_hooks_for_application(extension)\n\n # Record application extension information\n hooks_info = cls._info.setdefault('AppExtension', [])\n hooks_info.append(extension.__name__) # type: ignore","def hook_adapter_script(self) -> HookAdapterScript:","async def load(self, ctx, *, extension: str):\r\n try:\r\n self.bot.load_extension(extension)\r\n await ctx.send(f\":ok_hand: Loaded module `{extension}`\")\r\n except Exception as e:\r\n await ctx.send(f\":sob: I-I'm sorry, I couldn't load the `{extension}` module >w< \"\r\n + f\"```py\\n{traceback.format_exc()}```\")","def extensions(self, global_step):\n return []","def extensions(self, global_step):\n return []","def pre_start_hook(self):\n\n LOG.debug(_('XManager pre_start_hook...'))\n\n pass","def test_load_with_enabled_by_default(self):\n class TestExtension(Extension):\n pass\n\n self.setup_extension(TestExtension, enable=False)\n\n self.assertEqual(self.manager.get_installed_extensions(),\n [TestExtension])\n\n enabled_extensions = self.manager.get_enabled_extensions()\n self.assertEqual(len(enabled_extensions), 1)\n self.assertIsInstance(enabled_extensions[0], TestExtension)\n\n self.assertTrue(hasattr(TestExtension, 'info'))\n self.assertEqual(TestExtension.info.name, self.test_project_name)\n self.assertIsNotNone(TestExtension.instance)\n self.assertTrue(hasattr(TestExtension, 'registration'))\n self.assertEqual(TestExtension.registration.name,\n self.test_project_name)\n self.assertTrue(TestExtension.registration.enabled)","def init():","def _setup(self) -> None:\n\t\treturn","def on_init(self):\n self.write_log(\"策略初始化\")\n self.load_bar(10)","def on_init(self):\n self.write_log(\"策略初始化\")\n self.load_bar(10)","def on_init(self):\n self.write_log(\"策略初始化\")\n self.exchange_load_bar(self.exchange)","def extra_init(self):\n pass","def post_start(self):","def startup(self):\n pass","def init():\n return _libsbml.LayoutExtension_init()","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def post_setup(self, context):\n pass","def reload_cogs(self):\n\n for extension in list(self.extensions):\n try:\n self.reload_extension(extension)\n except errors.NoEntryPointError:\n log.info(\"The extension {extension} has no setup function\")\n pass\n except errors.ExtensionAlreadyLoaded:\n pass\n\n log.info(f\"Reloaded {len(self.extensions)} cogs\")","def request_plugins(self):"],"string":"[\n \"def on_load(self):\\n pass\",\n \"def on_load(self):\\n pass\",\n \"def init_extensions(self, package, module):\\n\\n pass\",\n \"def on_load(self):\",\n \"def on_startup(self) -> None:\\n ...\",\n \"def on_load(self):\\n self.__init__()\",\n \"def __init_on_load__(self):\",\n \"def test_load(self):\\n class TestExtension(Extension):\\n pass\\n\\n self.setup_extension(TestExtension, enable=False)\\n\\n self.assertEqual(self.manager.get_installed_extensions(),\\n [TestExtension])\\n self.assertEqual(len(self.manager.get_enabled_extensions()), 0)\\n self.assertTrue(hasattr(TestExtension, 'info'))\\n self.assertEqual(TestExtension.info.name, self.test_project_name)\\n self.assertTrue(hasattr(TestExtension, 'registration'))\\n self.assertEqual(TestExtension.registration.name,\\n self.test_project_name)\",\n \"def plugin_loaded():\\n events.broadcast(\\\"plugin_loaded\\\")\",\n \"def extensions():\\n\\n pass\",\n \"def _post_load(self):\\n pass\",\n \"def get_loaded_extensions():\\n raise NotImplementedError()\",\n \"def init():\\n return _libsbml.CompExtension_init()\",\n \"def CompExtension_init():\\n return _libsbml.CompExtension_init()\",\n \"def OnStartup(cls, modName ):\\r\\n import sys\\r\\n targetMod = sys.modules[ modName ]\\r\\n cls.StartupVarsInjectToMod( targetMod )\\r\\n EasyIpyMagics.RegisterMagics()\\r\\n \\r\\n cls.RegisterPostExecute()\",\n \"def load_extensions(self):\\n extension_module_name = f\\\"{utils.get_project_name()}.cogs\\\"\\n for extension in CONF.LOADED_EXTENSIONS:\\n try:\\n self.load_extension(extension_module_name + \\\".\\\" + extension)\\n LOG.debug(f\\\"The extension '{extension.split('.')[0]}' has been successfully loaded\\\")\\n except Exception as e:\\n message = f\\\"Failed to load extension '{extension.split('.')[0]}'\\\"\\n LOG.exception(log.get_log_exception_message(message, e))\",\n \"def init():\\n return _libsbml.MultiExtension_init()\",\n \"def _afterInit(self):\\n pass\",\n \"def on_window_ready(self):\\n pass\",\n \"def onInit(self):\\n pass\",\n \"def load_ep(entry_point):\\n logger.debug('Loading extension: %s', entry_point)\\n try:\\n func = entry_point.load()\\n func()\\n except Exception as e:\\n msg = (f\\\"Numba extension module '{entry_point.module}' \\\"\\n f\\\"failed to load due to '{type(e).__name__}({str(e)})'.\\\")\\n warnings.warn(msg, stacklevel=3)\\n logger.debug('Extension loading failed for: %s', entry_point)\",\n \"def getExtension(self): #$NON-NLS-1$\\r\",\n \"def afterInit(self):\",\n \"def init_app(app):\\n app.load_extension(__name__)\",\n \"def MultiExtension_init():\\n return _libsbml.MultiExtension_init()\",\n \"def on_loaded(self, func):\\n self._on_loaded_funcs.append(func)\",\n \"def postLoad(self):\\n pass\",\n \"def init():\\n return _libsbml.QualExtension_init()\",\n \"def _add_extensions(self):\\n ext_cache_down = 'cache_downloading'\\n ext_cache_up = 'cache_uploading'\\n cmd_args = self.task_data.get('cmd_args', {})\\n if not isinstance(cmd_args, dict):\\n cmd_args = {}\\n if cmd_args.get('save_raw_pages', False):\\n self.required_signals[SIGNAL_SPIDER_OPENED]['wait'] += \\\\\\n EXTENSION_SIGNALS[ext_cache_up]\\n if cmd_args.get('load_raw_pages'):\\n self.required_signals[SIGNAL_SCRIPT_CLOSED]['wait'] += \\\\\\n EXTENSION_SIGNALS[ext_cache_down]\",\n \"def QualExtension_init():\\n return _libsbml.QualExtension_init()\",\n \"def handle_reload_toolbox(self):\",\n \"def init():\\n return _libsbml.FbcExtension_init()\",\n \"def init():\\n global PLUGIN_NAME\\n PLUGIN_NAME = inspect.currentframe().f_code.co_filename\",\n \"def mod_load(self):\\n raise NotImplementedError(\\\"Mod load isn't overriden\\\")\",\n \"def on_initialize(self) -> None:\\n pass\",\n \"def Extension_Init():\\n\\n # After calling this, we will be able to invoke glFogCoordEXT ()\\n if not glInitFogCoordEXT():\\n print(\\\"Help! No GL_EXT_ForCoord\\\")\\n sys.exit(1)\\n return False\\n return True\",\n \"def core_plugin(self):\\n pass\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def extension_hooks(self, global_step):\\n return []\",\n \"def __macroLoad(self):\\n self.activeWindow().macroLoad()\",\n \"def test_load_full_reload_hooks(self):\\n class TestExtension(Extension):\\n pass\\n\\n extension = self.setup_extension(TestExtension)\\n\\n self.assertEqual(len(self.manager.get_installed_extensions()), 1)\\n self.assertEqual(len(self.manager.get_enabled_extensions()), 1)\\n\\n URLHook(extension, ())\\n self.assertEqual(len(URLHook.hooks), 1)\\n self.assertEqual(URLHook.hooks[0].extension, extension)\\n\\n self.manager.load(full_reload=True)\\n\\n self.assertEqual(len(URLHook.hooks), 0)\",\n \"def _post_init(self):\\n pass\",\n \"def plugin_loaded():\\n # Required for sublime.packages_path().\\n # ST only \\\"loads resources\\\" from the Packages dir.\\n global _temp_path\\n packages_path = sublime.packages_path()\\n _temp_path = os.path.join(packages_path, _temp_dir_name)\\n\\n _remove_temp_path()\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def preReadyInitalizatize(self):\\n self.pbug(\\\"Pre Ready Initalization\\\")\\n self.xj(\\\"window.onerror = miteErrorCallback\\\")\\n for funcs in self.j_funcs:\\n if \\\"bind\\\" in funcs:\\n for bind in funcs[\\\"bind\\\"]:\\n self.pbug(\\\"Binding {0} function to #{1}\\\".format(bind, funcs[\\\"name\\\"]))\\n script = \\\"$('#{0}').attr('{1}', '{2}()');\\\".format(bind, funcs[\\\"event\\\"], funcs[\\\"name\\\"])\\n self.xj(script)\\n self.pbug(\\\"Mite Load Finished\\\")\",\n \"def inject_extensions(self, extensions: Dict[str, str]) -> None:\\n self.extensions = extensions\",\n \"def on_hook(self) -> None:\",\n \"def ready(self):\\n from django_sites_extensions import models\\n from django_sites_extensions import signals\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def on_start(self):\\n pass\",\n \"def force_load(self):\\n pass\",\n \"def onReload(self,moduleName=\\\"NeedleFinder\\\"):\\n if profiling : profbox()\\n #framework\\n globals()[moduleName] = slicer.util.reloadScriptedModule(moduleName)\",\n \"def FbcExtension_init():\\n return _libsbml.FbcExtension_init()\",\n \"def __init__(cls, *args, **kwargs):\\n super(ExtensionMeta, cls).__init__(*args, **kwargs)\\n scope = ExtensionMeta._get_extension_scope(cls)\\n\\n # Only register application extension here\\n if scope is ExtensionScope.APPLICATION:\\n ExtensionMeta._register_application_extension(cls)\",\n \"def findExtensions(self):\\n if SYSTEM_EXTENSIONS:\\n self._populateExtensions()\\n return\\n\\n pylabs.q.logger.log('Loading pylabs extensions from %s' % self.extensionsRootPath,7)\\n\\n #Add extensions base dir to sys.path\\n sys.path.append(self.extensionsRootPath)\\n\\n SYSTEM_EXTENSIONS.extend(self.findExtensionInfo())\\n\\n self._populateExtensions()\",\n \"def load_extension(self, name):\\n if name in self.__extensions.loaded_by_core:\\n raise commands.ExtensionAlreadyLoaded(name)\\n try:\\n cog_module = importlib.import_module(f'extensions.{name}.cogs')\\n except ImportError:\\n cog_module = importlib.import_module(f'hero.extensions.{name}.cogs')\\n\\n self.__settings[name] = self.__extensions[name].get_settings(self)\\n self.__controllers[name] = self.__extensions[name].get_controller(self)\\n\\n if hasattr(cog_module, 'setup'):\\n cog_module.setup(self, name)\\n else:\\n cog_classes = inspect.getmembers(cog_module, lambda member: isinstance(member, type) and\\n issubclass(member, hero.Cog) and member is not hero.Cog)\\n for _, _Cog in cog_classes:\\n if _Cog is None:\\n raise ImportError(f\\\"The {name} extension's cog module didn't have \\\"\\n f\\\"any Cog subclass and no setup function\\\")\\n self.add_cog(_Cog(self, self.__extensions[name]))\\n\\n self.__extensions.loaded_by_core.append(name)\\n return cog_module\",\n \"def _setup(self):\",\n \"def _setup(self):\",\n \"def setup_hooks(self):\\n pass\",\n \"def load(self):\\n self.__additionnal_datas.update({\\n 'hostname_fqdn': socket.getfqdn(),\\n 'hostname': socket.gethostname(),\\n 'ipcheck_version': self.__ipcheck_version,\\n })\\n # parse all trigger section in config file\\n for section in filter(lambda s: self.RE_EXTENSION_SECTION.match(s) is not None, self.cp.sections()):\\n conf = dict(self.cp.items(section))\\n conf['name'] = section.partition('.')[2].lower()\\n ext_name = conf['name']\\n # check if the trigger name contains only alpha caracters\\n if not ext_name.isalpha():\\n self.__logger.error('[extension] Extension name \\\"%s\\\" must contains only alphabetical caracters', ext_name)\\n continue\\n # import process\\n try:\\n m = __import__('ipcheckadvanced.extension.' + ext_name, fromlist=['Extension'])\\n ext = m.Extension()\\n if not isinstance(ext, ExtensionBase):\\n # inheritance error\\n self.__logger.error('[extension] Extension \\\"%s\\\" must inherit from TriggerHandler class',\\n ext_name)\\n continue\\n ext.logger = logging.getLogger('ipcheck.' + ext_name)\\n ext.configuration = conf\\n ext.event_receiver = self\\n if ext.load():\\n self.__extensions.append(ext)\\n self.__logger.debug('[extension] loaded extension %s', ext_name)\\n else:\\n # loading error\\n self.__logger.error('[extension] Extension \\\"%s\\\" cannot be loaded', ext_name)\\n except ImportError as e:\\n self.__logger.error('[extension] Extension \\\"%s\\\" name cannot be found in extension directory %s',\\n ext_name, str(e))\\n except NotImplementedError as e:\\n self.__logger.error('[extension] Extension \\\"%s\\\" must implement the method \\\"%s\\\"',\\n ext_name, str(e))\\n except KeyError as e:\\n self.__logger.error('[extension] Extension \\\"%s\\\" require %s missing parameters see extension documentation',\\n ext_name, str(e))\\n except Exception as e:\\n self.__logger.error('[extension] Extension \\\"%s\\\" has encountered an unknown error: %s',\\n ext_name, str(e))\\n self.__logger.exception(e)\\n # # return false if no trigger have been loaded\\n return self.hasExtensions()\",\n \"def extensions(self):\\n raise NotImplementedError()\",\n \"def ready(self):\\n # export app settings\\n self.export_settings()\\n # import the submodule with signal handlers\\n self.load_module('signals')\",\n \"def _hook(self):\",\n \"def _post_init(self) -> None:\\n return\",\n \"def on_start(self):\\n self.init()\",\n \"def on_modules_loaded(self, loader, callback=None):\\n enabled_list = self.get_enabled_modules()\\n \\n self.update_modules_priority(enabled_list)\\n \\n self._keybinder.connect(\\\"activated\\\", lambda k,t: self._emit_keybinding_activated(t))\\n self._emit_loaded()\\n \\n for mod in enabled_list:\\n modinst = self._module_list.get_module_instance_from_name( mod )\\n if modinst != None:\\n self._module_loader.initialize_module_async( modinst )\\n self._loaded_modules += 1\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n self.load_bar(1)\",\n \"def startup(self) -> None:\",\n \"def __load_cogs(self):\\n for cog in self.__cogs.get():\\n logging.info('loading %s', cog)\\n self.load_extension(cog)\",\n \"def test_register_with_another_extension(self):\\n DummyLoader.register()\\n DummyLoader.register(extensions=('.example2',))\\n self.assertIs(getattr(sys, HOOK_NAME)['.example2'], DummyLoader)\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n\\n self.load_bar(10)\",\n \"def _register_application_extension(cls, extension):\\n # Should skip registering AppExtensionBase, cannot use isinstance(),\\n # referring to app_extension_hooks introduces a dependency cycle\\n if extension.__name__ == 'AppExtensionBase':\\n return\\n\\n if getattr(extension, 'init', None):\\n extension.init()\\n\\n cls._set_hooks_for_application(extension)\\n\\n # Record application extension information\\n hooks_info = cls._info.setdefault('AppExtension', [])\\n hooks_info.append(extension.__name__) # type: ignore\",\n \"def hook_adapter_script(self) -> HookAdapterScript:\",\n \"async def load(self, ctx, *, extension: str):\\r\\n try:\\r\\n self.bot.load_extension(extension)\\r\\n await ctx.send(f\\\":ok_hand: Loaded module `{extension}`\\\")\\r\\n except Exception as e:\\r\\n await ctx.send(f\\\":sob: I-I'm sorry, I couldn't load the `{extension}` module >w< \\\"\\r\\n + f\\\"```py\\\\n{traceback.format_exc()}```\\\")\",\n \"def extensions(self, global_step):\\n return []\",\n \"def extensions(self, global_step):\\n return []\",\n \"def pre_start_hook(self):\\n\\n LOG.debug(_('XManager pre_start_hook...'))\\n\\n pass\",\n \"def test_load_with_enabled_by_default(self):\\n class TestExtension(Extension):\\n pass\\n\\n self.setup_extension(TestExtension, enable=False)\\n\\n self.assertEqual(self.manager.get_installed_extensions(),\\n [TestExtension])\\n\\n enabled_extensions = self.manager.get_enabled_extensions()\\n self.assertEqual(len(enabled_extensions), 1)\\n self.assertIsInstance(enabled_extensions[0], TestExtension)\\n\\n self.assertTrue(hasattr(TestExtension, 'info'))\\n self.assertEqual(TestExtension.info.name, self.test_project_name)\\n self.assertIsNotNone(TestExtension.instance)\\n self.assertTrue(hasattr(TestExtension, 'registration'))\\n self.assertEqual(TestExtension.registration.name,\\n self.test_project_name)\\n self.assertTrue(TestExtension.registration.enabled)\",\n \"def init():\",\n \"def _setup(self) -> None:\\n\\t\\treturn\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n self.load_bar(10)\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n self.load_bar(10)\",\n \"def on_init(self):\\n self.write_log(\\\"策略初始化\\\")\\n self.exchange_load_bar(self.exchange)\",\n \"def extra_init(self):\\n pass\",\n \"def post_start(self):\",\n \"def startup(self):\\n pass\",\n \"def init():\\n return _libsbml.LayoutExtension_init()\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def post_setup(self, context):\\n pass\",\n \"def reload_cogs(self):\\n\\n for extension in list(self.extensions):\\n try:\\n self.reload_extension(extension)\\n except errors.NoEntryPointError:\\n log.info(\\\"The extension {extension} has no setup function\\\")\\n pass\\n except errors.ExtensionAlreadyLoaded:\\n pass\\n\\n log.info(f\\\"Reloaded {len(self.extensions)} cogs\\\")\",\n \"def request_plugins(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73872864","0.73872864","0.7158644","0.6950948","0.6821005","0.6776726","0.67198926","0.66803163","0.66501784","0.6643111","0.657011","0.6525896","0.6503312","0.6479751","0.6448623","0.64208615","0.6371902","0.6362281","0.63427466","0.63366205","0.6320702","0.63095045","0.62999576","0.62532926","0.6250939","0.6248497","0.62379164","0.62136877","0.6139002","0.6125477","0.611848","0.61150116","0.61013246","0.6094539","0.6068728","0.60240096","0.599939","0.5994808","0.5994808","0.59835774","0.5962218","0.59550476","0.5954603","0.5954395","0.59543407","0.5941827","0.59189665","0.59090894","0.59071684","0.59071684","0.59071684","0.59071684","0.59071684","0.59071684","0.59071684","0.59071684","0.5901854","0.58886147","0.58837146","0.5874878","0.5868804","0.58653045","0.5858619","0.5858619","0.5850149","0.5828328","0.5815265","0.58106446","0.5806121","0.5804253","0.57884735","0.5781503","0.57759005","0.5765531","0.57482946","0.5730481","0.5728488","0.5727997","0.57267237","0.5717561","0.5714936","0.5714936","0.5709959","0.5701463","0.569693","0.56958944","0.5690917","0.5690917","0.5686481","0.5682834","0.56795365","0.56723326","0.56672007","0.56629723","0.56629723","0.56629723","0.56629723","0.56629723","0.56618387","0.5643806","0.5641266"],"string":"[\n \"0.73872864\",\n \"0.73872864\",\n \"0.7158644\",\n \"0.6950948\",\n \"0.6821005\",\n \"0.6776726\",\n \"0.67198926\",\n \"0.66803163\",\n \"0.66501784\",\n \"0.6643111\",\n \"0.657011\",\n \"0.6525896\",\n \"0.6503312\",\n \"0.6479751\",\n \"0.6448623\",\n \"0.64208615\",\n \"0.6371902\",\n \"0.6362281\",\n \"0.63427466\",\n \"0.63366205\",\n \"0.6320702\",\n \"0.63095045\",\n \"0.62999576\",\n \"0.62532926\",\n \"0.6250939\",\n \"0.6248497\",\n \"0.62379164\",\n \"0.62136877\",\n \"0.6139002\",\n \"0.6125477\",\n \"0.611848\",\n \"0.61150116\",\n \"0.61013246\",\n \"0.6094539\",\n \"0.6068728\",\n \"0.60240096\",\n \"0.599939\",\n \"0.5994808\",\n \"0.5994808\",\n \"0.59835774\",\n \"0.5962218\",\n \"0.59550476\",\n \"0.5954603\",\n \"0.5954395\",\n \"0.59543407\",\n \"0.5941827\",\n \"0.59189665\",\n \"0.59090894\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.59071684\",\n \"0.5901854\",\n \"0.58886147\",\n \"0.58837146\",\n \"0.5874878\",\n \"0.5868804\",\n \"0.58653045\",\n \"0.5858619\",\n \"0.5858619\",\n \"0.5850149\",\n \"0.5828328\",\n \"0.5815265\",\n \"0.58106446\",\n \"0.5806121\",\n \"0.5804253\",\n \"0.57884735\",\n \"0.5781503\",\n \"0.57759005\",\n \"0.5765531\",\n \"0.57482946\",\n \"0.5730481\",\n \"0.5728488\",\n \"0.5727997\",\n \"0.57267237\",\n \"0.5717561\",\n \"0.5714936\",\n \"0.5714936\",\n \"0.5709959\",\n \"0.5701463\",\n \"0.569693\",\n \"0.56958944\",\n \"0.5690917\",\n \"0.5690917\",\n \"0.5686481\",\n \"0.5682834\",\n \"0.56795365\",\n \"0.56723326\",\n \"0.56672007\",\n \"0.56629723\",\n \"0.56629723\",\n \"0.56629723\",\n \"0.56629723\",\n \"0.56629723\",\n \"0.56618387\",\n \"0.5643806\",\n \"0.5641266\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17084,"cells":{"query":{"kind":"string","value":"Function called when extension is unloaded."},"document":{"kind":"string","value":"def teardown(bot):\n bot.logger.debug(\n 'Removing extension \"Quiz\"'\n )\n bot.get_cog('Quiz').save_traking_data()\n bot.remove_cog(bot.get_cog('Quiz'))"},"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 unloaded():\n pass","def on_unload(self):\n pass","def unload_plugin(self):\n pass","async def unload(self, ctx, *, extension: str):\r\n self.bot.unload_extension(extension)\r\n await ctx.send(f\":ok_hand: Unloaded module `{extension}`\")","async def unload(self) -> None:","def __del__(self):\r\n self.debug(\"%s unloaded\" % self.name)","def unload(ctx):\n if not is_owner(ctx.update):\n return\n global cmds\n\n cmds.unload_ext(ctx.args[0])","def deregister(ext_id):\n extensions.pop(ext_id, None)","def cleanup(self):\n\t\tself.loader.cleanup()\n\t\tself.Loaded = False","def cleanup(self):\r\n pass","def cog_unload(self):\n self.bot.lavalink._event_hooks.clear()","def cog_unload(self):\n self.bot.lavalink_event_hooks.clear()","def deinit(self):\n pass","def deinit(self):\n pass","def cleanup(self):","def cleanup(self):","def cleanup(self):","def _unbind_observers(self):\n workbench = self.workbench\n point = workbench.get_extension_point(CLOSING_POINT)\n point.unobserve('extensions', self._on_closing_checks_updated)","def unload(self):\n main.msgQ.removeEvent(Constants.CMSG_CHANGE_AVATAR_TYPE)\n main.msgQ.removeEvent(Constants.CMSG_CHANGE_TEAM_PVP)\n main.msgQ.removeEvent(Constants.CMSG_START_TO_READY_GAME)\n main.msgQ.removeEvent(Constants.CMSG_CANCEL_TO_JOIN_GAME)\n main.msgQ.removeEvent(Constants.CMSG_START_SIXTY_SECONDS_COUNTER)\n self.mainFrame.destroy()","def clear_extensions(self):\n self.extensions = set()","async def unload(self, *, module : str):\n try:\n self.bot.unload_extension(module)\n except Exception as e:\n await self.bot.say('<:vpRedTick:257437215615877129> `{}: {}`'.format(type(e).__name__, e))\n else:\n await self.bot.say('<:vpGreenTick:257437292820561920>')","def shuttingDown(self):\n extension_name = self.objectName()\n # write_setting(extension_name, \"setting_name\", value)","def unload_ipython_extension(ip):\n del ip.magics_manager.magics[\"cell\"][Constants.MAGIC_NAME]\n del ip.magics_manager.magics[\"line\"][Constants.MAGIC_NAME]\n for alias in Constants.MAGIC_ALIASES:\n del ip.magics_manager.magics[\"cell\"][alias]\n del ip.magics_manager.magics[\"line\"][alias]","def teardown_function(self):\r\n raise AppModule.Unimplemented()","def unload(self, name):\n\t\tself.__plugins[name].finish()\n\t\tdel self.__plugins[name]","def unload_all():\n module_utils.unload_package_modules(__name__)","def slot_before_unload(self, _sender, _data):\r\n pass","def cleanup(self):\r\n pass","def cleanup(self):\r\n pass","def unload_ipython_extension(ip):\n print 'not implemented yet'","def prepareUnload(self):\n if self.__projectHelperObject:\n self.__projectHelperObject.removeToolbar(\n self.__ui, e5App().getObject(\"ToolbarManager\"))\n e5App().unregisterPluginObject(pluginTypename)","def on_cleanup(self):\n raise NotImplementedError","async def tool_unload(self, ctx, *, cog: str):\n\n try:\n self.bot.unload_extension(cog)\n except Exception as e:\n await zb.bot_errors(ctx,sp.format(e))\n else:\n await ctx.send('**`SUCCESS`**')","def _unbind_observers(self):\n workbench = self.workbench\n point = workbench.get_extension_point(PREFS_POINT)\n point.unobserve('extensions', self._on_pref_decls_updated)","def __del__(self):\r\n del self.addons","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\r\n #self.removeObservers()\r\n pass","def TearDown(self):\n raise NotImplementedError(\n 'No runtime tear down defined for %s' % self.__class__.__name__)","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def cleanup (self):\n pass","def cleanup(self):\n self.removeObservers()","def unloadaddon(self, addonName):\r\n es.unload(\"%s/addons/%s\" % (info.basename, addonName))","def cleanup():","def cleanup(self):\r\n print(\"Cleanup not implemented\")","def _cleanup(self):\n pass","def deinit(self) -> None:\n ...","def deinit(self) -> None:\n ...","def _cleanup(self):\n # If module object not yet created, return\n if getattr(self, \"this\", None) is None:\n return\n\n deallocate = getattr(self, \"deallocate\", None)\n if callable(deallocate):\n deallocate()","def post_cleanup(self):\n pass","def cleanup(self):\n\n pass","def script_unload():\n log_threadsafe(obs.LOG_DEBUG, 'Plugin unloaded')\n \n global state\n \n if state != 0:\n with mutex_state_sending:\n state = 0\n pipe_send_state(should_seek_new_client_on_fail=False)\n \n win32file.CloseHandle(pipe)","def __del__(self):\n self.appdoc.Close()\n self.app.Stop()\n glab_instrument.Glab_Instrument.__del__(self)","def unload(self):\n \n ImajnetLog.info(\"** UNLOAD QGisImajnetPlugin\")\n\n if self.pluginIsActive:\n self.onClosePlugin(False)\n \n for action in self.actions:\n self.iface.removePluginWebMenu(\n self.tr(u'&Imajnet'),\n action)\n self.iface.removeToolBarIcon(action)\n \n \n # remove the toolbar\n del self.toolbar\n \n if self.aboutDialog :\n self.aboutDialog = None\n #del self.aboutDialog\n \n self.pluginLayerRegistry.removePluginLayerType(ImajnetOpenlayersLayer.LAYER_TYPE)\n #ImajnetLog.error(\"** UNLOADED\")\n ImajnetLog.close()","def cleanup(self):\n\t\tself.removeObservers()\n\t\tself.active = False","def __del__(self):\r\n if self.coreInst:\r\n for mod in self.coreInst.keys():\r\n self.coreInst[mod][plug_key].stop()","def clear_loaded_modules(self):\n self._loaded_modules = []","def _unload_opengl(self):\r\n pass","def __del__(self):\n if self.xc_func is None:\n return\n\n if self._xc_func_init:\n core.xc_func_end(self.xc_func)\n\n core.xc_func_free(self.xc_func)","def teardown_module():\n common_teardown_module()","def shutdown_plugin(self):\n pass","def _on_finalize(self):\n pass","def cleanup(self):\n self.GP.cleanup()","def unload(self):\r\n self.gox.signal_strategy_unload(self, None)\r\n self.strategy_object_list = []","def teardown_appcontext(self):\n storage.close()","async def unload_cog(self, ctx, *, cog: str):\n\n try:\n self.bot.unload_extension(cog)\n except Exception as e:\n await ctx.send(f'**`ERROR:`** {type(e).__name__} - {e}')\n else:\n await ctx.send('**`SUCCESS`**')","def unloadPlugin(*args, addCallback: Script=None, force: bool=True, removeCallback: Script=None,\n **kwargs)->List[AnyStr]:\n pass","def teardown(self) -> None:","def teardown(self) -> None:","def teardown(self) -> None:","def on_unload(self):\n self.entity.on_unload()\n del self.server.entity_list[self.entity.id]","def teardown_function():\n\n # Force module reload as the default test settings have been restored\n importlib.reload(defaults)","def teardown(self):","def teardown(self):","def teardown(self):","def __del__(self):\r\n self.cleanup()","def plugin_unloaded():\n if cancel_thread is not None:\n cancel_thread()","def prepareUninstall(self):\n e5App().unregisterPluginObject(pluginTypename)","def finalize(self):\n print('Cleaning up...')","def delete_plugin_data(self):","def cleanup(self):\n logging.debug(\"TrackerPlugin.cleanup\")","def on_cleanup(self):\n\n pygame.quit()"],"string":"[\n \"def unloaded():\\n pass\",\n \"def on_unload(self):\\n pass\",\n \"def unload_plugin(self):\\n pass\",\n \"async def unload(self, ctx, *, extension: str):\\r\\n self.bot.unload_extension(extension)\\r\\n await ctx.send(f\\\":ok_hand: Unloaded module `{extension}`\\\")\",\n \"async def unload(self) -> None:\",\n \"def __del__(self):\\r\\n self.debug(\\\"%s unloaded\\\" % self.name)\",\n \"def unload(ctx):\\n if not is_owner(ctx.update):\\n return\\n global cmds\\n\\n cmds.unload_ext(ctx.args[0])\",\n \"def deregister(ext_id):\\n extensions.pop(ext_id, None)\",\n \"def cleanup(self):\\n\\t\\tself.loader.cleanup()\\n\\t\\tself.Loaded = False\",\n \"def cleanup(self):\\r\\n pass\",\n \"def cog_unload(self):\\n self.bot.lavalink._event_hooks.clear()\",\n \"def cog_unload(self):\\n self.bot.lavalink_event_hooks.clear()\",\n \"def deinit(self):\\n pass\",\n \"def deinit(self):\\n pass\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def _unbind_observers(self):\\n workbench = self.workbench\\n point = workbench.get_extension_point(CLOSING_POINT)\\n point.unobserve('extensions', self._on_closing_checks_updated)\",\n \"def unload(self):\\n main.msgQ.removeEvent(Constants.CMSG_CHANGE_AVATAR_TYPE)\\n main.msgQ.removeEvent(Constants.CMSG_CHANGE_TEAM_PVP)\\n main.msgQ.removeEvent(Constants.CMSG_START_TO_READY_GAME)\\n main.msgQ.removeEvent(Constants.CMSG_CANCEL_TO_JOIN_GAME)\\n main.msgQ.removeEvent(Constants.CMSG_START_SIXTY_SECONDS_COUNTER)\\n self.mainFrame.destroy()\",\n \"def clear_extensions(self):\\n self.extensions = set()\",\n \"async def unload(self, *, module : str):\\n try:\\n self.bot.unload_extension(module)\\n except Exception as e:\\n await self.bot.say('<:vpRedTick:257437215615877129> `{}: {}`'.format(type(e).__name__, e))\\n else:\\n await self.bot.say('<:vpGreenTick:257437292820561920>')\",\n \"def shuttingDown(self):\\n extension_name = self.objectName()\\n # write_setting(extension_name, \\\"setting_name\\\", value)\",\n \"def unload_ipython_extension(ip):\\n del ip.magics_manager.magics[\\\"cell\\\"][Constants.MAGIC_NAME]\\n del ip.magics_manager.magics[\\\"line\\\"][Constants.MAGIC_NAME]\\n for alias in Constants.MAGIC_ALIASES:\\n del ip.magics_manager.magics[\\\"cell\\\"][alias]\\n del ip.magics_manager.magics[\\\"line\\\"][alias]\",\n \"def teardown_function(self):\\r\\n raise AppModule.Unimplemented()\",\n \"def unload(self, name):\\n\\t\\tself.__plugins[name].finish()\\n\\t\\tdel self.__plugins[name]\",\n \"def unload_all():\\n module_utils.unload_package_modules(__name__)\",\n \"def slot_before_unload(self, _sender, _data):\\r\\n pass\",\n \"def cleanup(self):\\r\\n pass\",\n \"def cleanup(self):\\r\\n pass\",\n \"def unload_ipython_extension(ip):\\n print 'not implemented yet'\",\n \"def prepareUnload(self):\\n if self.__projectHelperObject:\\n self.__projectHelperObject.removeToolbar(\\n self.__ui, e5App().getObject(\\\"ToolbarManager\\\"))\\n e5App().unregisterPluginObject(pluginTypename)\",\n \"def on_cleanup(self):\\n raise NotImplementedError\",\n \"async def tool_unload(self, ctx, *, cog: str):\\n\\n try:\\n self.bot.unload_extension(cog)\\n except Exception as e:\\n await zb.bot_errors(ctx,sp.format(e))\\n else:\\n await ctx.send('**`SUCCESS`**')\",\n \"def _unbind_observers(self):\\n workbench = self.workbench\\n point = workbench.get_extension_point(PREFS_POINT)\\n point.unobserve('extensions', self._on_pref_decls_updated)\",\n \"def __del__(self):\\r\\n del self.addons\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\r\\n #self.removeObservers()\\r\\n pass\",\n \"def TearDown(self):\\n raise NotImplementedError(\\n 'No runtime tear down defined for %s' % self.__class__.__name__)\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def cleanup (self):\\n pass\",\n \"def cleanup(self):\\n self.removeObservers()\",\n \"def unloadaddon(self, addonName):\\r\\n es.unload(\\\"%s/addons/%s\\\" % (info.basename, addonName))\",\n \"def cleanup():\",\n \"def cleanup(self):\\r\\n print(\\\"Cleanup not implemented\\\")\",\n \"def _cleanup(self):\\n pass\",\n \"def deinit(self) -> None:\\n ...\",\n \"def deinit(self) -> None:\\n ...\",\n \"def _cleanup(self):\\n # If module object not yet created, return\\n if getattr(self, \\\"this\\\", None) is None:\\n return\\n\\n deallocate = getattr(self, \\\"deallocate\\\", None)\\n if callable(deallocate):\\n deallocate()\",\n \"def post_cleanup(self):\\n pass\",\n \"def cleanup(self):\\n\\n pass\",\n \"def script_unload():\\n log_threadsafe(obs.LOG_DEBUG, 'Plugin unloaded')\\n \\n global state\\n \\n if state != 0:\\n with mutex_state_sending:\\n state = 0\\n pipe_send_state(should_seek_new_client_on_fail=False)\\n \\n win32file.CloseHandle(pipe)\",\n \"def __del__(self):\\n self.appdoc.Close()\\n self.app.Stop()\\n glab_instrument.Glab_Instrument.__del__(self)\",\n \"def unload(self):\\n \\n ImajnetLog.info(\\\"** UNLOAD QGisImajnetPlugin\\\")\\n\\n if self.pluginIsActive:\\n self.onClosePlugin(False)\\n \\n for action in self.actions:\\n self.iface.removePluginWebMenu(\\n self.tr(u'&Imajnet'),\\n action)\\n self.iface.removeToolBarIcon(action)\\n \\n \\n # remove the toolbar\\n del self.toolbar\\n \\n if self.aboutDialog :\\n self.aboutDialog = None\\n #del self.aboutDialog\\n \\n self.pluginLayerRegistry.removePluginLayerType(ImajnetOpenlayersLayer.LAYER_TYPE)\\n #ImajnetLog.error(\\\"** UNLOADED\\\")\\n ImajnetLog.close()\",\n \"def cleanup(self):\\n\\t\\tself.removeObservers()\\n\\t\\tself.active = False\",\n \"def __del__(self):\\r\\n if self.coreInst:\\r\\n for mod in self.coreInst.keys():\\r\\n self.coreInst[mod][plug_key].stop()\",\n \"def clear_loaded_modules(self):\\n self._loaded_modules = []\",\n \"def _unload_opengl(self):\\r\\n pass\",\n \"def __del__(self):\\n if self.xc_func is None:\\n return\\n\\n if self._xc_func_init:\\n core.xc_func_end(self.xc_func)\\n\\n core.xc_func_free(self.xc_func)\",\n \"def teardown_module():\\n common_teardown_module()\",\n \"def shutdown_plugin(self):\\n pass\",\n \"def _on_finalize(self):\\n pass\",\n \"def cleanup(self):\\n self.GP.cleanup()\",\n \"def unload(self):\\r\\n self.gox.signal_strategy_unload(self, None)\\r\\n self.strategy_object_list = []\",\n \"def teardown_appcontext(self):\\n storage.close()\",\n \"async def unload_cog(self, ctx, *, cog: str):\\n\\n try:\\n self.bot.unload_extension(cog)\\n except Exception as e:\\n await ctx.send(f'**`ERROR:`** {type(e).__name__} - {e}')\\n else:\\n await ctx.send('**`SUCCESS`**')\",\n \"def unloadPlugin(*args, addCallback: Script=None, force: bool=True, removeCallback: Script=None,\\n **kwargs)->List[AnyStr]:\\n pass\",\n \"def teardown(self) -> None:\",\n \"def teardown(self) -> None:\",\n \"def teardown(self) -> None:\",\n \"def on_unload(self):\\n self.entity.on_unload()\\n del self.server.entity_list[self.entity.id]\",\n \"def teardown_function():\\n\\n # Force module reload as the default test settings have been restored\\n importlib.reload(defaults)\",\n \"def teardown(self):\",\n \"def teardown(self):\",\n \"def teardown(self):\",\n \"def __del__(self):\\r\\n self.cleanup()\",\n \"def plugin_unloaded():\\n if cancel_thread is not None:\\n cancel_thread()\",\n \"def prepareUninstall(self):\\n e5App().unregisterPluginObject(pluginTypename)\",\n \"def finalize(self):\\n print('Cleaning up...')\",\n \"def delete_plugin_data(self):\",\n \"def cleanup(self):\\n logging.debug(\\\"TrackerPlugin.cleanup\\\")\",\n \"def on_cleanup(self):\\n\\n pygame.quit()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78926325","0.7739239","0.7379189","0.7115593","0.6993464","0.68589085","0.6789264","0.677395","0.6731156","0.66316205","0.6624827","0.66196173","0.6605904","0.6605904","0.6562715","0.6562715","0.6562715","0.656185","0.65453285","0.6543707","0.6531165","0.65120786","0.65119463","0.64840555","0.64651096","0.6461516","0.64531416","0.64499784","0.64499784","0.64464414","0.6429156","0.6414864","0.64041924","0.63983405","0.63905364","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.6369427","0.63490117","0.6340603","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6332105","0.6317899","0.6307946","0.6302007","0.62920105","0.6276721","0.626578","0.6259926","0.6259926","0.6249133","0.6236164","0.62261504","0.6220651","0.62179124","0.6217835","0.6208038","0.6207007","0.62031215","0.61908","0.6187311","0.61797047","0.6171518","0.61696994","0.6168674","0.6164331","0.6125298","0.6113794","0.61135167","0.6102196","0.6102196","0.6102196","0.60956085","0.6091098","0.6091006","0.6091006","0.6091006","0.6066342","0.6051593","0.60481507","0.60475326","0.6040676","0.60352415","0.60338795"],"string":"[\n \"0.78926325\",\n \"0.7739239\",\n \"0.7379189\",\n \"0.7115593\",\n \"0.6993464\",\n \"0.68589085\",\n \"0.6789264\",\n \"0.677395\",\n \"0.6731156\",\n \"0.66316205\",\n \"0.6624827\",\n \"0.66196173\",\n \"0.6605904\",\n \"0.6605904\",\n \"0.6562715\",\n \"0.6562715\",\n \"0.6562715\",\n \"0.656185\",\n \"0.65453285\",\n \"0.6543707\",\n \"0.6531165\",\n \"0.65120786\",\n \"0.65119463\",\n \"0.64840555\",\n \"0.64651096\",\n \"0.6461516\",\n \"0.64531416\",\n \"0.64499784\",\n \"0.64499784\",\n \"0.64464414\",\n \"0.6429156\",\n \"0.6414864\",\n \"0.64041924\",\n \"0.63983405\",\n \"0.63905364\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.6369427\",\n \"0.63490117\",\n \"0.6340603\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6332105\",\n \"0.6317899\",\n \"0.6307946\",\n \"0.6302007\",\n \"0.62920105\",\n \"0.6276721\",\n \"0.626578\",\n \"0.6259926\",\n \"0.6259926\",\n \"0.6249133\",\n \"0.6236164\",\n \"0.62261504\",\n \"0.6220651\",\n \"0.62179124\",\n \"0.6217835\",\n \"0.6208038\",\n \"0.6207007\",\n \"0.62031215\",\n \"0.61908\",\n \"0.6187311\",\n \"0.61797047\",\n \"0.6171518\",\n \"0.61696994\",\n \"0.6168674\",\n \"0.6164331\",\n \"0.6125298\",\n \"0.6113794\",\n \"0.61135167\",\n \"0.6102196\",\n \"0.6102196\",\n \"0.6102196\",\n \"0.60956085\",\n \"0.6091098\",\n \"0.6091006\",\n \"0.6091006\",\n \"0.6091006\",\n \"0.6066342\",\n \"0.6051593\",\n \"0.60481507\",\n \"0.60475326\",\n \"0.6040676\",\n \"0.60352415\",\n \"0.60338795\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6474187"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":17085,"cells":{"query":{"kind":"string","value":"Setup local flowables database with flows that require special handling. Also loads the flowables file. When overriding this function, place the super() call between preload and postload activities."},"document":{"kind":"string","value":"def _configure_flowables(self, flowables):\n if flowables is None:\n flowables = DEFAULT_FLOWABLES\n\n # FlowablesDict-- mainly to upsample CAS numbers for matching\n self._fm = FlowablesDict()\n\n self._fm.new_entry('carbon dioxide', '124-38-9')\n self._fm.new_entry('Water', '7732-18-5')\n # we store the child object and use it to signify biogenic CO2 to optionally quell\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\n\n # now load + merge from file\n self._fm.load(flowables)\n\n # now add all known \"biotic\" synonyms for CO2 to the biotic child\n for k in self._fm.synonyms('124-38-9'):\n if bool(biogenic.search(k)):\n self._bio_co2.add_term(k)\n self._fq_map = {fb: set() for fb in self._fm.objects}"},"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 setup(cls):\n super().setup()\n cls.db = DBCommunication()","def _pre_setup(self):\n apps.clear_cache()\n call_command('migrate', interactive=False, verbosity=0)\n call_command('loaddata', 'initial_data', verbosity=0)\n super(DatatableViewTestCase, self)._pre_setup()","def initDatabase(self):\n\n try:\n self.dbase = workflowManager(self.wf_name)\n\n working = self.config['working_d']\n self.dbase.initWorkflow(self.wf_name, working)\n\n except sqlite3.Error as error:\n self.logger.warning('Database %s: %s', self.wf_name, error.args)\n #print('Database %s: %s', self.wf_name, error.args)\n\n return","def setup():\n load_app()\n setup_db()","def _post_load(self):\n pass","def postLoad(self):\n pass","def _load(self):\n if os.path.exists(DEFAULT_STACK):\n self.stack = TasksInProgress.load(DEFAULT_STACK)\n else:\n self.stack = TasksInProgress()\n\n if os.path.exists(DEFAULT_QUEUE):\n self.backlog = TaskBacklog.load(DEFAULT_QUEUE)\n else:\n self.backlog = TaskBacklog()\n\n self.blocked = TaskLimbo(callback=self.stack.push)\n # FIXME: implement serialization for TaskLimbo\n # if os.path.exists(DEFAULT_LIMBO):\n # self.blocked.load(DEFAULT_LIMBO)\n\n if os.path.exists(DEFAULT_DORM):\n self.sleeping = TaskDorm.load(DEFAULT_DORM)\n self.sleeping.set_callback(self.stack.push)\n else:\n self.sleeping = TaskDorm(callback=self.stack.push)","def preload_all(self):\n for tp in self.tps:\n for f in self.featurefiles + self.maskfiles:\n file = os.path.join(tp, f)\n print('preloading {}'.format(file))\n self.load(file, lazy=False)","def setup(self):\n #print \"Creating test database...\"\n files = glob.glob(os.path.join(self.home_dir, 'sqlFiles', '*.sql'))\n for fls in files:\n loc = fls.rfind('/')\n #print(\" \" + fls.replace('.sql', '')[loc + 1:])\n flh = open(fls, 'r')\n curs = self.cursor()\n curs.executescript(flh.read())\n self.commit()\n curs.close()\n flh.close()\n for fls in ['INSERTS', 'TRIGGERS']:\n #print(fls)\n flh = open(os.path.join(self.home_dir, 'sqlFiles', fls), 'r')\n curs = self.cursor()\n curs.executescript(flh.read())\n self.commit()\n curs.close()\n flh.close()","def setup(self):\n # Call the baseclass setup to resolve any selections\n super().setup()\n\n # Load the requested file\n cont = self._load_file(self.filename)\n\n # Set the done attribute so the pipeline recognizes this task is finished\n self.done = True\n\n return cont","def force_load(self):\n pass","def initialise(self):\n\n if self.db_type == 'sqlite':\n try:\n # Attempt to create schema if not present, to cope with fresh DB file\n BaseSQLite.metadata.create_all(self.engine)\n except OperationalError:\n print(\"Error creating database schema, possible invalid path? ('\" + self.db_name + \"'). Quitting\")\n exit()\n elif self.db_type == 'postgres':\n try:\n # ensure that create schema scripts created before create table scripts\n event.listen(BasePostgres.metadata, 'before_create', CreateSchema('datastore_schema'))\n BasePostgres.metadata.create_all(self.engine)\n except OperationalError:\n print(f\"Error creating database({self.db_name})! Quitting\")\n exit()","def _init(self):\n if os.path.exists(self.fname):\n with open(self.fname, \"rb\") as fh:\n self.db = pickle.load(fh)\n else:\n self.db = {}\n print(\"DB loaded, len\", len(self.db))","def on_load(self):\n self.__init__()","def setUp(self):\n try:\n # Get default data from medical_forum_data_dump.sql, populate tables and connect to DB\n ENGINE.populate_tables()\n self.connection = ENGINE.connect()\n\n # In case of error/exception in populating tables, clear all tables data\n except Exception as exception:\n print(exception)\n ENGINE.clear()","def init(self):\n\t\tfrom splat_to_db import splat_to_db\n\t\tfrom visualize.clustering_test import clustering_test\n\t\tfrom codense.codense2db import codense2db\n\t\tself.splat_to_db_instance = splat_to_db()\n\t\tself.clustering_test_instance = clustering_test()\n\t\tself.codense2db_instance = codense2db()\n\t\t\n\t\tif not os.path.isdir(self.dir_files):\n\t\t\tos.makedirs(self.dir_files)\n\t\telse:\n\t\t\tsys.stderr.write(\"Warning, directory %s already exists.\\n\"%(self.dir_files))\n\t\tself.tmpinfname = os.path.join(self.dir_files, 'input')\n\t\tself.tmpoutfname = os.path.join(self.dir_files, 'output')\n\t\t\n\t\tself.crack_dict = {1: crack_by_modes(self.debug),\n\t\t\t2:crack_by_splat(self.debug)}\n\t\tself.argument1_dict = {1: self.clustering_test_instance,\n\t\t\t2: self.splat_to_db_instance}\n\t\t\n\t\t#two descending tables\n\t\tself.splat_table = '%ss'%self.table\n\t\tself.mcl_table = self.splat_table.replace('splat','mcl')\n\t\tif self.mcl_table == self.splat_table:\n\t\t\tsys.stderr.write(\"Error: new splat and mcl tables have the same name, %s\\n\"%self.splat_table)\n\t\t\tsys.exit(2)","def setUp(self) -> None:\n self.sqlite_db = setup_sqlite_in_memory_db()\n create_tables(self.sqlite_db)\n seed_all_distributions()\n container_flow_generation_manager = ContainerFlowGenerationManager()\n container_flow_generation_manager.set_properties(\n name=\"Test previews\",\n start_date=datetime.datetime.now().date(),\n end_date=datetime.datetime.now().date() + datetime.timedelta(days=21)\n )","def preloop(self):\n\n self.manager = FacilityManager()","def batch_load(self, setup_list):\n players = 1\n default = (self.mission.enemy_faction.default_ship.id, 1, 'A')\n for s in setup_list:\n if not s: s = default\n action = s[2]\n init = s[1]\n chassis = s[0]\n self.mission.fgsetup_set.create(flight_group=self, chassis_id=chassis, action=action, players=players, init=init)","def pre_init(self) -> None:\n self._check_and_set_network()\n self._check_and_apply_migrations()","def setUp(self):\n super(InfiniteFeedTests, self).setUp()\n self.db_set_up()","def __init__(self, datacfg_file=None, envcfg_file=None, resources_file=None):\n\n super(LoadHandler, self).__init__(datacfg_file, envcfg_file, resources_file)\n\n logkv(logger, {\"msg\": \"Starting load\",\n \"dataset\": self.get_config(\"dataset_name\")}, \"info\")\n\n # Initialize fields that will be filled in methods of this class.\n self.propfile = None\n self.newdirs = None\n self.locked = False\n self.load_type = None\n\n # Get primary HDFS namenode before proceeding with load\n namenodes = self.get_config(\"webhdfs_root\").split(\",\")\n try:\n self.primary_namenode = \\\n self.hdfs_mgr.get_primary_namenode(namenodes,\n self.get_config(\"hdfs_root\"),\n self.get_config(\"hdfs_user\"))\n except HdfsManagerException as ex:\n logkv(logger, {\"msg\": \"Failed to get primary namenode\"}, \"error\", ex)\n raise LoadHandlerException()\n\n # Instantiate Oozie manager\n self.oozie_mgr = OozieManager()\n\n # Get folder processing delay\n try:\n self.process_delay = float(self.get_config(\"folder_processing_delay\"))\n except ValueError as ex:\n logkv(logger,\n {\"msg\": \"Could not parse folder_processing_delay as a float\"},\n \"error\")\n raise LoadHandlerException()\n\n # # Instantiate NewRelic manager\n # try:\n # self.newrelic_mgr = NewRelicManager(self.get_config(\"newrelic_api_key\", configtype=\"env\"),\n # self.get_config(\"newrelic_dataset_name\"),\n # self.get_config(\"newrelic_url\"))\n #\n # except Exception as ex:\n # logkv(logger, {\"msg\": \"Failed to initialize NewRelic Manager\"}, \"error\")\n # raise LoadHandlerException()","def __post_init__(self):\n # ------------------------------------------------------------ 01\n # if path exists load data dict from it\n # that is sync with contents on disk\n if self.path.exists():\n _hashable_dict_from_disk = \\\n m.FrozenDict.from_yaml(self.path.read_text())\n # update internal dict from HashableDict loaded from disk\n self.__dict__.update(\n _hashable_dict_from_disk.get()\n )\n\n # ------------------------------------------------------------ 02\n # start syncing i.e. any updates via __setattr__ will be synced\n # to disc\n self.internal.start_syncing = True","def __init_on_load__(self):","def preload_local_schemas(self):\n schemas = [self.SCHEMA_PACKAGE_DESCRIPTOR,\n self.SCHEMA_SERVICE_DESCRIPTOR,\n self.SCHEMA_FUNCTION_DESCRIPTOR]\n\n for schema in schemas:\n schema_file = self._schemas[schema]['local']\n if not os.path.isfile(schema_file):\n continue\n try:\n self._schemas_library[schema] = load_local_schema(schema_file)\n except FileNotFoundError:\n continue","def __init__(self, base_path):\n super(FileSystemDatastore, self).__init__(base_path)","def preloop(self):\n self.banner()\n self.db = CrashDBConnector('fuzz.db')","def setUp(self):\n self.setup_model()\n self.sess = tf.Session(\n config=tf.ConfigProto(\n allow_soft_placement=True,\n gpu_options=tf.GPUOptions(allow_growth=True),\n log_device_placement=self.params['log_device_placement'],\n ))\n\n # TODO: Determine whether this should be called here or\n # in dbinterface.initialize()\n self.sess.run(tf.global_variables_initializer())\n\n self.dbinterface = DBInterface(\n sess=self.sess,\n params=self.params,\n cache_dir=self.CACHE_DIR,\n save_params=self.save_params,\n load_params=self.load_params)\n\n self.step = 0","def initialize_context(self):\n # a task's workdir == context.flow_workdir / context.flow_config.workdir / context.task_config.workdir\n # If any of the above dirs is absolute dir, then use it instead\n super().initialize_context()\n # only inject the up-most flow's info\n if not flowsaber.context.up_flow:\n flow_workdir = self.config_dict['workdir']\n if not Path(flow_workdir).is_absolute():\n flow_workdir = str(Path().resolve().absolute())\n self.context.update({\n 'flow_id': self.config_dict['id'],\n 'flow_name': self.config_dict['name'],\n 'flow_full_name': self.config_dict['full_name'],\n 'flow_labels': self.config_dict['labels'],\n 'flow_workdir': flow_workdir,\n 'top_flow_config': self.config_dict\n })","def __post_init__(self):\n self.dbase = databases.Database(\n self.dsn,\n min_size=self.min_size,\n max_size=self.max_size\n )\n self.engine, self.meta = self.get_engine_metadata()","def setup(self) -> None:\n mlflow.set_tracking_uri('file://' + hutils.get_original_cwd() + '/mlruns')\n if self.log_mlflow:\n mlflow.set_experiment(self.config.runner.exp_name)\n \n if self.log_mlflow:\n self.log_parameters(self.config)\n mlflow.log_param('node', os.uname()[1])","def setUp(self):\n self.data = DatabaseIntermediary()","def setUpClass(cls):\n cls.database_connection = DatabaseHandler(database_path)\n cls.database_connection.connect()\n processing.create_table_if_not_exist(cls.database_connection, table_name)\n cls.database_connection.close()","def setUp(self) -> None:\n sqlite_db = setup_sqlite_in_memory_db()\n sqlite_db.create_tables([\n Schedule,\n Destination\n ])\n self.schedule_factory = ScheduleFactory()","def setup_class(self):\n self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()\n app.config['TESTING'] = True\n self.app = app.test_client()\n init_db()","def init():\n database.create_tables([Tracker])\n database.commit()","def _load_db(self):\n for type_ in self._types:\n try:\n type_.table(self._metadata)\n except InvalidRequestError:\n pass\n # Reflect metadata so auto-mapping works\n self._metadata.reflect(self._engine)\n # Make sure the tables exist\n self._metadata.create_all()","def on_load(self):\n pass","def on_load(self):\n pass","def setUp(self):\n input_files = glob.glob(PATH_TO_INPUT_FILES) # Read input (csv) files from current (sw/test) directory.\n if not self.sessionizing:\n self.sessionizing = Sessionizing()\n self.sessionizing.initialize(*input_files)\n if not self.sites_session_counter:\n self.merge_and_sort_input_files(*input_files)\n self.process_input_files()","def preload(self):\n # load the objects\n for otype, fname in self.TYPE2NAME.items():\n if fname:\n path = os.path.join(self.anodir, fname + \".gz\")\n if os.path.isfile(path):\n with gzip.open(path, \"rt\") as handler:\n for line in handler:\n omap = json.loads(line)\n cls = self.TYPE2CLASS[otype]\n item = cls.from_map(omap, self)\n self.caches[otype][item.id] = item","def load(self):\n self._really_load()","def _setup(self) -> None:\n try:\n coverage = []\n if (\n self._config\n and \"restore_state\" in self._config[\"core\"]\n and self._config[\"core\"][\"restore_state\"]\n ):\n coverage = [\n \"tracklist\",\n \"mode\",\n \"play-last\",\n \"mixer\",\n \"history\",\n ]\n if len(coverage):\n self._load_state(coverage)\n except Exception as e:\n logger.warning(\"Restore state: Unexpected error: %s\", str(e))","def initialise(self):\n self.set_up()","def _pre_setup(self):\r\n\r\n # Flush the Mongo modulestore\r\n ModuleStoreTestCase.drop_mongo_collections()\r\n\r\n # Call superclass implementation\r\n super(ModuleStoreTestCase, self)._pre_setup()","def setUp(self):\n self.ds = DictionaryStore(Camper)\n self.engine = Engine(self.ds)","def post_setup(self, context):\n pass","def setup(self) -> None:\n self.setup_logging()\n self.setup_plugins()\n self.post_setup()","def Start(self):\n self.state.hist_count = 0\n self.state.history_paths = []\n\n if self.args.history_path:\n self.state.history_paths.append(self.args.history_path)\n else:\n self.state.history_paths = self.GuessHistoryPaths(self.args.username)\n\n if not self.state.history_paths:\n raise flow_base.FlowError(\"Could not find valid History paths.\")\n\n filename = \"places.sqlite\"\n for path in self.state.history_paths:\n self.CallFlow(\n file_finder.FileFinder.__name__,\n paths=[os.path.join(path, \"**2\", filename)],\n pathtype=self.args.pathtype,\n action=rdf_file_finder.FileFinderAction.Download(),\n next_state=self.ParseFiles.__name__)","def _db_setup(self):\n self.get_connection()\n sql_file = open(db_config.DATABASE_TABLES_SETUP_FILE, 'r')\n with self.conn.cursor() as cur:\n cur.execute(sql_file.read())\n self.conn.commit()\n logger.info(f'The script {db_config.DATABASE_TABLES_SETUP_FILE} has run.')","def _set_up(self):\n # Also recreates any attributes not in _io_attrs on load from input file.\n # See IOAble class docstring for more info.\n self._enforce_symmetry()\n self._sort_modes()\n self._create_idx()","def boot():\n\t\tcreate_project_url_dir(Spider.project_name)\n\t\tcreate_url_data(Spider.project_name, Spider.base_url)\n\t\tSpider.queue = file_to_set(Spider.queue_file)\n\t\tSpider.crawled = file_to_set(Spider.crawled_file)","def __init__(self):\n self._setup()\n # Encryption/decryption cipher handler\n self.__cipher = self.__get_cipher()\n # Setup the engine for the sqlite database\n self._engine = create_engine(self.db_uri)\n # Configure the SQLAlchemy metadata\n self._metadata = MetaData()\n self._metadata.bind = self._engine\n self._load_db()\n # Configure the auto-mapping base model\n self._base = automap_base(metadata=self._metadata)\n self._base.prepare()\n # Setup a session generator for database connections\n self._session = sessionmaker(bind=self._engine)","def connect(self):\n super(NERDmLoader, self).connect()\n self.lateloadr._client = self._client\n self.lateloadr._db = self._db\n self.relloadr._client = self._client\n self.relloadr._db = self._db","def _fixture_setup(self):\n pass","def _pre_load(self):\n urdfloader_config = dict(\n pybullet_client=self._pybullet_client,\n urdf_path=pupper_constants.URDF_PATH,\n constrained_base=True,\n # Hang the robot in the air.\n enable_self_collision=True,\n # Makes the simulated robot haning higher from the ground.\n init_base_position=np.array(pupper_constants.INIT_POSITION) + np.array(\n (0, 0, 0.5)),\n init_base_orientation_quaternion=pupper_constants.INIT_ORIENTATION,\n init_joint_angles=pupper_constants.INIT_JOINT_ANGLES,\n joint_offsets=pupper_constants.JOINT_OFFSETS,\n joint_directions=pupper_constants.JOINT_DIRECTIONS,\n motor_names=pupper_constants.MOTOR_NAMES,\n end_effector_names=pupper_constants.END_EFFECTOR_NAMES,\n user_group=pupper_constants.MOTOR_GROUP)\n config_keys = list(urdfloader_config.keys())\n gin_config = gin.config_str()\n for i in range(len(config_keys)):\n if config_keys[i] in gin_config:\n urdfloader_config.pop(config_keys[i])\n\n self._urdf_loader = robot_urdf_loader.RobotUrdfLoader(\n **urdfloader_config\n )","def setUp(self):\n self.app = load_app(self.application_under_test)\n\n try:\n teardown_db()\n except Exception as e:\n print('-> err ({})'.format(e.__str__()))\n\n setup_app(section_name=self.application_under_test)\n setup_db()\n\n fixtures_loader = FixturesLoader([BaseFixture]) # BaseFixture is already loaded in bootstrap\n fixtures_loader.loads(self.fixtures)","def _setup(self) -> None:\n\t\treturn","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def _setup(self):\n pass","def init_database(self):\n # init_database(self.engine)","def __initDataFromImages(self):\n #Check if the local_db exist\n initial_dirs = os.listdir(os.getcwd())\n is_db_empty = False\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\n [images_dir] = os.listdir(self.base_dir)\n is_db_empty = images_dir == cfg.local[\"IMG_DIR\"]\n if cfg.local[\"DEFAULT_IMGS_DIR\"] in initial_dirs and is_db_empty:\n default_path = os.path.join(os.getcwd(), cfg.local[\"DEFAULT_IMGS_DIR\"])\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\n self.le = LabelEncoder()\n #Nothing relate to mapping name to dir here, we don't care about\n #This data because of the user doesn't exist in the database\n self.__savePreProcessedData()","def initialize_database():\n # TODO: Refactor the funtime library\n this.db = Store(this.host).create_lib(this.store_name).get_store()","def setup(self):\n return self.setupDatabases()","def _manual_setup(self):\n # If self.cache is None, then all caching should be skipped\n if self.name_to_index_dict is None:\n self.name_to_index_dict = {name:i for i, name in enumerate(self.input_fields)}\n self.task_label_index = self.name_to_index_dict[self.task_name]\n if self.cache is not None:\n self.setup_cache()","def bootstrap(self, datafile):\n import sqlite3\n # Try fetching a value from the table, if we get an OperationalError\n # we assume that the table doesn't exist, and create it.\n try:\n self.get(\"foo\")\n return\n except KeyError:\n return\n except sqlite3.OperationalError:\n print \" >> Bootstrapping local store: %s\" % datafile\n c = self.conn.cursor()\n c.execute(\"CREATE TABLE metastore (k varchar(255), v \"\n \"text, primary key(k));\")\n self.conn.commit()","def work(self):\n self.config_file = self.args.config\n self.init_config()\n self.init_db()\n\n self.kickoff()","def init_data_base_activity(path):\n\n conn = sqlite3.connect(path)\n c = conn.cursor()\n\n c.execute(\"DROP TABLE IF EXISTS Activity\")\n c.execute('''CREATE TABLE Activity\n (\n inseeNb TEXT, comLib TEXT, equipementId TEXT,\n equNbEquIdentique TEXT, actCode TEXT,actLib TEXT,\n equActivitePraticable TEXT, equActivitePratique TEXT,\n equActiviteSalleSpe TEXT, actNivLib TEXT\n )'''\n )\n\n conn.commit()\n conn.close()","def on_worker_init(self):\n self.import_default_modules()\n\n self.close_database()\n self.close_cache()","def setUp(self):\n client = utils.create_test_datastore_client()\n self.resource = import_attempt.ImportAttemptByID(client)\n list_resource = import_attempt_list.ImportAttemptList(client)\n run_list_resource = system_run_list.SystemRunList(client)\n attempts = [{\n _ATTEMPT.provenance_url: 'google.com'\n }, {\n _ATTEMPT.provenance_url: 'facebook.com'\n }, {\n _ATTEMPT.provenance_url: 'bing.com'\n }]\n self.attempts = utils.ingest_import_attempts(run_list_resource,\n list_resource, attempts)","def prepare(self):\n if self.opts['verbose']:\n print(\"Preparing dataset (one-time operation)...\")\n # Create paths files and load them back in\n self._build_ID_sets()\n self._create_ID_files()\n self._load_ID_files()\n if self.opts['verbose']:\n print(\"... done with preparing the dataset.\")","def setup(self):\n self.config = pau.IConfig\n self.session = pau.ISession\n pau.resolve(self)\n\n self.session.assets = Assets()\n self.config.db = self.db_name\n\n self.db = pau.IDb\n pau.resolve(self)\n\n # Instance\n i = Setup()\n pau.resolve(i)\n return i","def init_database(self):\n init_database(self.engine)","def importData():\n #importChallengeDataToDB()\n importTrendingDataToDB()","def __init__(self, persistent=True):\n super().__init__()\n self.name_cache = {}\n self.run_cache = {}\n self.row_cache = {}\n self.persistent = persistent\n\n if self.persistent:\n self.load_cache()","def database_setup():\n Base.metadata.create_all(bind=engine)\n db = LocalSession()\n try:\n populate_from_json(db, Vector, str(VECTORS))\n populate_from_json(db, Gender, str(GENDERS))\n populate_from_json(db, Tag, str(TAGS))\n finally:\n db.close()","def _precache_reference_files(self, input_file):\n from .. import datamodels\n gc.collect()\n if self._is_association_file(input_file):\n return\n try:\n with datamodels.open(input_file) as model:\n pass\n except (ValueError, TypeError, IOError):\n self.log.info(\n 'First argument {0} does not appear to be a '\n 'model'.format(input_file))\n else:\n super(Pipeline, self)._precache_reference_files(input_file)\n for name in self.step_defs.keys():\n step = getattr(self, name)\n step._precache_reference_files(input_file)\n gc.collect()","def prepare(self):\n raise NotImplementedError('ContextSourceInterface.setup')","def init(self, **kwargs):\n self._d = {}\n self._th = None\n self._run = True\n self.load()","def setup(db_name = 'net.db', **extra_params):\n global db_run # Imports the DB from the simulator\n \n# # If the file already exists delete it\n if DEBUG: print \"[ pyNN ] : Opening DB\", os.path.abspath(db_name)\n if os.path.exists(db_name):\n if DEBUG: print \"[ pyNN ] : DB already initialized... cleaning up... removing file %s\" % db_name\n os.remove(db_name)\n db_run = db(db_name) # Creates the DB \n db_run.init_db() # Initializes the DB\n return(db_run)","def _preprocess(self) -> None:\n self.cache = Cache(self._db, self._collection)","def __init__(self):\n\n self.this_dir = os.path.dirname(os.path.abspath(__file__))\n self.db_path = self._discover_in_dir(self.this_dir)","def init_db(self):\n self.db_config = databaseutils.process_db_config(self.config['db'])\n\n from sqlalchemy import create_engine\n from sqlalchemy.orm import sessionmaker, scoped_session\n self.engine = create_engine(self.db_config.constr, pool_recycle=3600)\n self.session = scoped_session(sessionmaker(bind=self.engine))\n\n # Make sure tables are created\n DB_Base.metadata.create_all(self.engine)\n\n if self.sqlite_file is not None:\n dbname = 'sqlite:///%s' % self.sqlite_file\n self.sqlite_engine = create_engine(dbname, echo=False)\n self.sqlite_session = scoped_session(sessionmaker(bind=self.sqlite_engine))\n DB_Base.metadata.create_all(self.sqlite_engine)\n logger.info('Using SQLite %s' % self.sqlite_engine)","def setUp(self):\n self.conn = self.dbi.connection()\n self.file_lumi_insert = FileLumiInsert(self.logger, self.dbi, self.dbowner)\n self.file_id = FileID(self.logger, self.dbi, self.dbowner)","def init():\n global __dbChanged\n __dbChanged = False\n loadItemsFromFile()\n global __isInitialized\n if __isInitialized == True:\n return\n\n Report.trace(\"itemdatabase\", \"Initializing the item database.\")\n returnCode = FilterManager.executeFiltersForEvent(\"preInitializeItemDatabase\")\n if returnCode == FilterManager.FINISHED:\n Report.trace(\"itemdatabase\", \"Item database initialized.\")\n __isInitialized = True\n return\n\n for item in Items.items:\n addItem(item)\n\n FilterManager.executeFiltersForEvent(\"postInitializeItemDatabase\")\n __isInitialized = True\n Report.trace(\"itemdatabase\", \"Item database initialized.\")","def load_models(self, episode):\r\n self.actor.load_state_dict(self.target_actor.state_dict())\r\n self.critic.load_state_dict(self.target_critic.state_dict())\r\n hard_update(self.target_actor, self.actor)\r\n hard_update(self.target_critic, self.critic)","async def bootstrap(self, app, db):\n await self.factory.prepare(db)","def setUp(self):\n\n PyFunceble.load_config(\n generate_directory_structure=False, custom={\"db_type\": \"json\"}\n )\n\n self.file_to_test = \"this_is_a_ghost\"\n self.storage_file = (\n PyFunceble.CONFIG_DIRECTORY + PyFunceble.OUTPUTS.default_files.inactive_db\n )\n\n self.time_past = str(int((datetime.utcnow() - timedelta(days=365)).timestamp()))\n self.time_future = str(\n int((datetime.utcnow() + timedelta(days=365)).timestamp())\n )\n\n self.inactive_db = InactiveDB(self.file_to_test, parent_process=True)\n\n PyFunceble.helpers.File(self.storage_file).delete()","def __init__(self):\n self.filepath = os.path.dirname(__file__)\n self.filepath = os.path.join(self.filepath, \"Datenbank\")\n self.filepath_render_database = os.path.join(self.filepath, self.render_database)\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\n self.create_database()","def load_trainer(self):\n super().load_trainer()\n\n logging.info(\"[Server #%d] Loading a pre-trained model.\", os.getpid())\n self.trainer.load_model()","def setUp(self):\n # Drop directory if it exists\n if os.path.isdir(SERVER_DIR):\n shutil.rmtree(SERVER_DIR)\n os.makedirs(SERVER_DIR)\n self.processor = MimirProcessor()\n self.datastore = MimirDatastore(DATASTORE_DIR)\n self.filestore = FileSystemFilestore(FILESTORE_DIR)\n self.available_lenses = set(mimir.getAvailableLensTypes())","def main():\n # Create the flow\n with Flow('pickle flow') as flow:\n db_table = create_table()\n weather_data = get_weather(LAT_NYC, LON_NYC, 2018)\n parsed_data = parse_weather(weather_data)\n populated_table = store_weather(parsed_data)\n populated_table.set_upstream(db_table)\n\n # Run the flow\n flow.run()","def load_static():\n\n for i, row in enumerate(open(\"seed_data/homepage_feature.static\")):\n row = row.rstrip()\n title, body, img_path_xs, img_path_sm, img_path_md, img_path_lg, is_active = row.split(\"|\")\n homepage_feature = HomepageFeatureModel(title=title,\n body=body,\n img_path_xs=img_path_xs,\n img_path_sm=img_path_sm,\n img_path_md=img_path_md,\n img_path_lg=img_path_lg,\n is_active=is_active)\n db.session.add(homepage_feature)\n\n for i, row in enumerate(open(\"seed_data/help_article.static\")):\n row = row.rstrip()\n title, description, body = row.split(\"|\")\n help_article = HelpArticleModel(title=title, \n description=description, \n body=body)\n db.session.add(help_article)\n\n db.session.commit()","def __init__(self, workflow, **kwds):\n self.kwds = kwds\n self.url = self.get('url', 'cmsweb.cern.ch')\n WorkflowManager.__init__(self, workflow, self.url)\n self.workload = getWorkload(self.url, workflow)\n self.cacheID = self.winfo.get('StepOneConfigCacheID', '')\n self.config = getConfig(self.url, self.cacheID)\n self.pileup_dataset = self._pileup_dataset()\n self.priority = self._priority()\n self.era = self.get('era', 'Summer12')\n self.lfn = self.get('lfn', '/store/mc')\n self.special_name = self.get('specialName', '')\n self.max_rss = self.get('maxRSS', 2300000)\n self.max_vsize = self.get('maxVSize', 4100000000)\n self.input_dataset = ''\n self.pileup_scenario = ''\n self.global_tag = self.get('globalTag', '')\n self.campaign = self.get('campaign', '')\n self.max_merge_events = self.get('maxMergeEvents', 50000)\n self.activity = self.get('activity', 'reprocessing')\n self.restrict = self.get('restrict', 'None')\n self.site_use = self.get('site', None)\n self.site_cust = self.get('site_cust', None)\n self.xrootd = self.get('xrootd', 0)\n self.ext_tag = self.get('ext', '')\n self.team = self.get('team', '')\n\n # perform various initialization\n self._init()\n\n # custom settings\n # Construct processed dataset version\n if self.pileup_scenario:\n self.pileup_scenario = self.pileup_scenario+'_' \n\n specialprocstring = kwds.get('specialName', '')\n if specialprocstring:\n self.special_name = specialprocstring + '_'\n\n # ProcessingString\n inprocstring = kwds.get('procstring', '')\n if inprocstring:\n self.procstring = inprocstring\n else:\n self.procstring = self.special_name + self.pileup_scenario +\\\n self.global_tag + self.ext_tag\n\n # ProcessingVersion\n inprocversion = kwds.get('procversion', '')\n if inprocversion:\n self.procversion = inprocversion\n else:\n self.procversion = self.dataset_version(self.era, self.procstring)","def initialize(self, context):\n\n properties = context.system_properties\n self.map_location = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n self.device = torch.device(\n self.map_location + \":\" + str(properties.get(\"gpu_id\"))\n if torch.cuda.is_available()\n else self.map_location\n )\n self.manifest = context.manifest\n\n model_dir = properties.get(\"model_dir\")\n self.batch_size = properties.get(\"batch_size\")\n serialized_file = self.manifest[\"model\"][\"serializedFile\"]\n model_pt_path = os.path.join(model_dir, serialized_file)\n\n if not os.path.isfile(model_pt_path):\n raise RuntimeError(\"Missing the model.pt file\")\n\n logger.debug(\"Loading torchscript model\")\n self.model = self._load_torchscript_model(model_pt_path)\n\n self.model.to(self.device)\n self.model.eval()\n\n logger.debug(\"Model file %s loaded successfully\", model_pt_path)\n\n self.initialized = True","def initialise_bdd(self):\n print(fr.FR[1])\n self.base.create_database(\"sql/p5.sql\")\n print(fr.FR[2])\n self.category_table.save_category()\n print(fr.FR[3])","def setUp(self):\n self.db_fd, closet.app.config['DATABASE'] = tempfile.mkstemp()\n closet.app.config['TESTING'] = True\n self.app = closet.app.test_client()\n closet.init_db()"],"string":"[\n \"def setup(cls):\\n super().setup()\\n cls.db = DBCommunication()\",\n \"def _pre_setup(self):\\n apps.clear_cache()\\n call_command('migrate', interactive=False, verbosity=0)\\n call_command('loaddata', 'initial_data', verbosity=0)\\n super(DatatableViewTestCase, self)._pre_setup()\",\n \"def initDatabase(self):\\n\\n try:\\n self.dbase = workflowManager(self.wf_name)\\n\\n working = self.config['working_d']\\n self.dbase.initWorkflow(self.wf_name, working)\\n\\n except sqlite3.Error as error:\\n self.logger.warning('Database %s: %s', self.wf_name, error.args)\\n #print('Database %s: %s', self.wf_name, error.args)\\n\\n return\",\n \"def setup():\\n load_app()\\n setup_db()\",\n \"def _post_load(self):\\n pass\",\n \"def postLoad(self):\\n pass\",\n \"def _load(self):\\n if os.path.exists(DEFAULT_STACK):\\n self.stack = TasksInProgress.load(DEFAULT_STACK)\\n else:\\n self.stack = TasksInProgress()\\n\\n if os.path.exists(DEFAULT_QUEUE):\\n self.backlog = TaskBacklog.load(DEFAULT_QUEUE)\\n else:\\n self.backlog = TaskBacklog()\\n\\n self.blocked = TaskLimbo(callback=self.stack.push)\\n # FIXME: implement serialization for TaskLimbo\\n # if os.path.exists(DEFAULT_LIMBO):\\n # self.blocked.load(DEFAULT_LIMBO)\\n\\n if os.path.exists(DEFAULT_DORM):\\n self.sleeping = TaskDorm.load(DEFAULT_DORM)\\n self.sleeping.set_callback(self.stack.push)\\n else:\\n self.sleeping = TaskDorm(callback=self.stack.push)\",\n \"def preload_all(self):\\n for tp in self.tps:\\n for f in self.featurefiles + self.maskfiles:\\n file = os.path.join(tp, f)\\n print('preloading {}'.format(file))\\n self.load(file, lazy=False)\",\n \"def setup(self):\\n #print \\\"Creating test database...\\\"\\n files = glob.glob(os.path.join(self.home_dir, 'sqlFiles', '*.sql'))\\n for fls in files:\\n loc = fls.rfind('/')\\n #print(\\\" \\\" + fls.replace('.sql', '')[loc + 1:])\\n flh = open(fls, 'r')\\n curs = self.cursor()\\n curs.executescript(flh.read())\\n self.commit()\\n curs.close()\\n flh.close()\\n for fls in ['INSERTS', 'TRIGGERS']:\\n #print(fls)\\n flh = open(os.path.join(self.home_dir, 'sqlFiles', fls), 'r')\\n curs = self.cursor()\\n curs.executescript(flh.read())\\n self.commit()\\n curs.close()\\n flh.close()\",\n \"def setup(self):\\n # Call the baseclass setup to resolve any selections\\n super().setup()\\n\\n # Load the requested file\\n cont = self._load_file(self.filename)\\n\\n # Set the done attribute so the pipeline recognizes this task is finished\\n self.done = True\\n\\n return cont\",\n \"def force_load(self):\\n pass\",\n \"def initialise(self):\\n\\n if self.db_type == 'sqlite':\\n try:\\n # Attempt to create schema if not present, to cope with fresh DB file\\n BaseSQLite.metadata.create_all(self.engine)\\n except OperationalError:\\n print(\\\"Error creating database schema, possible invalid path? ('\\\" + self.db_name + \\\"'). Quitting\\\")\\n exit()\\n elif self.db_type == 'postgres':\\n try:\\n # ensure that create schema scripts created before create table scripts\\n event.listen(BasePostgres.metadata, 'before_create', CreateSchema('datastore_schema'))\\n BasePostgres.metadata.create_all(self.engine)\\n except OperationalError:\\n print(f\\\"Error creating database({self.db_name})! Quitting\\\")\\n exit()\",\n \"def _init(self):\\n if os.path.exists(self.fname):\\n with open(self.fname, \\\"rb\\\") as fh:\\n self.db = pickle.load(fh)\\n else:\\n self.db = {}\\n print(\\\"DB loaded, len\\\", len(self.db))\",\n \"def on_load(self):\\n self.__init__()\",\n \"def setUp(self):\\n try:\\n # Get default data from medical_forum_data_dump.sql, populate tables and connect to DB\\n ENGINE.populate_tables()\\n self.connection = ENGINE.connect()\\n\\n # In case of error/exception in populating tables, clear all tables data\\n except Exception as exception:\\n print(exception)\\n ENGINE.clear()\",\n \"def init(self):\\n\\t\\tfrom splat_to_db import splat_to_db\\n\\t\\tfrom visualize.clustering_test import clustering_test\\n\\t\\tfrom codense.codense2db import codense2db\\n\\t\\tself.splat_to_db_instance = splat_to_db()\\n\\t\\tself.clustering_test_instance = clustering_test()\\n\\t\\tself.codense2db_instance = codense2db()\\n\\t\\t\\n\\t\\tif not os.path.isdir(self.dir_files):\\n\\t\\t\\tos.makedirs(self.dir_files)\\n\\t\\telse:\\n\\t\\t\\tsys.stderr.write(\\\"Warning, directory %s already exists.\\\\n\\\"%(self.dir_files))\\n\\t\\tself.tmpinfname = os.path.join(self.dir_files, 'input')\\n\\t\\tself.tmpoutfname = os.path.join(self.dir_files, 'output')\\n\\t\\t\\n\\t\\tself.crack_dict = {1: crack_by_modes(self.debug),\\n\\t\\t\\t2:crack_by_splat(self.debug)}\\n\\t\\tself.argument1_dict = {1: self.clustering_test_instance,\\n\\t\\t\\t2: self.splat_to_db_instance}\\n\\t\\t\\n\\t\\t#two descending tables\\n\\t\\tself.splat_table = '%ss'%self.table\\n\\t\\tself.mcl_table = self.splat_table.replace('splat','mcl')\\n\\t\\tif self.mcl_table == self.splat_table:\\n\\t\\t\\tsys.stderr.write(\\\"Error: new splat and mcl tables have the same name, %s\\\\n\\\"%self.splat_table)\\n\\t\\t\\tsys.exit(2)\",\n \"def setUp(self) -> None:\\n self.sqlite_db = setup_sqlite_in_memory_db()\\n create_tables(self.sqlite_db)\\n seed_all_distributions()\\n container_flow_generation_manager = ContainerFlowGenerationManager()\\n container_flow_generation_manager.set_properties(\\n name=\\\"Test previews\\\",\\n start_date=datetime.datetime.now().date(),\\n end_date=datetime.datetime.now().date() + datetime.timedelta(days=21)\\n )\",\n \"def preloop(self):\\n\\n self.manager = FacilityManager()\",\n \"def batch_load(self, setup_list):\\n players = 1\\n default = (self.mission.enemy_faction.default_ship.id, 1, 'A')\\n for s in setup_list:\\n if not s: s = default\\n action = s[2]\\n init = s[1]\\n chassis = s[0]\\n self.mission.fgsetup_set.create(flight_group=self, chassis_id=chassis, action=action, players=players, init=init)\",\n \"def pre_init(self) -> None:\\n self._check_and_set_network()\\n self._check_and_apply_migrations()\",\n \"def setUp(self):\\n super(InfiniteFeedTests, self).setUp()\\n self.db_set_up()\",\n \"def __init__(self, datacfg_file=None, envcfg_file=None, resources_file=None):\\n\\n super(LoadHandler, self).__init__(datacfg_file, envcfg_file, resources_file)\\n\\n logkv(logger, {\\\"msg\\\": \\\"Starting load\\\",\\n \\\"dataset\\\": self.get_config(\\\"dataset_name\\\")}, \\\"info\\\")\\n\\n # Initialize fields that will be filled in methods of this class.\\n self.propfile = None\\n self.newdirs = None\\n self.locked = False\\n self.load_type = None\\n\\n # Get primary HDFS namenode before proceeding with load\\n namenodes = self.get_config(\\\"webhdfs_root\\\").split(\\\",\\\")\\n try:\\n self.primary_namenode = \\\\\\n self.hdfs_mgr.get_primary_namenode(namenodes,\\n self.get_config(\\\"hdfs_root\\\"),\\n self.get_config(\\\"hdfs_user\\\"))\\n except HdfsManagerException as ex:\\n logkv(logger, {\\\"msg\\\": \\\"Failed to get primary namenode\\\"}, \\\"error\\\", ex)\\n raise LoadHandlerException()\\n\\n # Instantiate Oozie manager\\n self.oozie_mgr = OozieManager()\\n\\n # Get folder processing delay\\n try:\\n self.process_delay = float(self.get_config(\\\"folder_processing_delay\\\"))\\n except ValueError as ex:\\n logkv(logger,\\n {\\\"msg\\\": \\\"Could not parse folder_processing_delay as a float\\\"},\\n \\\"error\\\")\\n raise LoadHandlerException()\\n\\n # # Instantiate NewRelic manager\\n # try:\\n # self.newrelic_mgr = NewRelicManager(self.get_config(\\\"newrelic_api_key\\\", configtype=\\\"env\\\"),\\n # self.get_config(\\\"newrelic_dataset_name\\\"),\\n # self.get_config(\\\"newrelic_url\\\"))\\n #\\n # except Exception as ex:\\n # logkv(logger, {\\\"msg\\\": \\\"Failed to initialize NewRelic Manager\\\"}, \\\"error\\\")\\n # raise LoadHandlerException()\",\n \"def __post_init__(self):\\n # ------------------------------------------------------------ 01\\n # if path exists load data dict from it\\n # that is sync with contents on disk\\n if self.path.exists():\\n _hashable_dict_from_disk = \\\\\\n m.FrozenDict.from_yaml(self.path.read_text())\\n # update internal dict from HashableDict loaded from disk\\n self.__dict__.update(\\n _hashable_dict_from_disk.get()\\n )\\n\\n # ------------------------------------------------------------ 02\\n # start syncing i.e. any updates via __setattr__ will be synced\\n # to disc\\n self.internal.start_syncing = True\",\n \"def __init_on_load__(self):\",\n \"def preload_local_schemas(self):\\n schemas = [self.SCHEMA_PACKAGE_DESCRIPTOR,\\n self.SCHEMA_SERVICE_DESCRIPTOR,\\n self.SCHEMA_FUNCTION_DESCRIPTOR]\\n\\n for schema in schemas:\\n schema_file = self._schemas[schema]['local']\\n if not os.path.isfile(schema_file):\\n continue\\n try:\\n self._schemas_library[schema] = load_local_schema(schema_file)\\n except FileNotFoundError:\\n continue\",\n \"def __init__(self, base_path):\\n super(FileSystemDatastore, self).__init__(base_path)\",\n \"def preloop(self):\\n self.banner()\\n self.db = CrashDBConnector('fuzz.db')\",\n \"def setUp(self):\\n self.setup_model()\\n self.sess = tf.Session(\\n config=tf.ConfigProto(\\n allow_soft_placement=True,\\n gpu_options=tf.GPUOptions(allow_growth=True),\\n log_device_placement=self.params['log_device_placement'],\\n ))\\n\\n # TODO: Determine whether this should be called here or\\n # in dbinterface.initialize()\\n self.sess.run(tf.global_variables_initializer())\\n\\n self.dbinterface = DBInterface(\\n sess=self.sess,\\n params=self.params,\\n cache_dir=self.CACHE_DIR,\\n save_params=self.save_params,\\n load_params=self.load_params)\\n\\n self.step = 0\",\n \"def initialize_context(self):\\n # a task's workdir == context.flow_workdir / context.flow_config.workdir / context.task_config.workdir\\n # If any of the above dirs is absolute dir, then use it instead\\n super().initialize_context()\\n # only inject the up-most flow's info\\n if not flowsaber.context.up_flow:\\n flow_workdir = self.config_dict['workdir']\\n if not Path(flow_workdir).is_absolute():\\n flow_workdir = str(Path().resolve().absolute())\\n self.context.update({\\n 'flow_id': self.config_dict['id'],\\n 'flow_name': self.config_dict['name'],\\n 'flow_full_name': self.config_dict['full_name'],\\n 'flow_labels': self.config_dict['labels'],\\n 'flow_workdir': flow_workdir,\\n 'top_flow_config': self.config_dict\\n })\",\n \"def __post_init__(self):\\n self.dbase = databases.Database(\\n self.dsn,\\n min_size=self.min_size,\\n max_size=self.max_size\\n )\\n self.engine, self.meta = self.get_engine_metadata()\",\n \"def setup(self) -> None:\\n mlflow.set_tracking_uri('file://' + hutils.get_original_cwd() + '/mlruns')\\n if self.log_mlflow:\\n mlflow.set_experiment(self.config.runner.exp_name)\\n \\n if self.log_mlflow:\\n self.log_parameters(self.config)\\n mlflow.log_param('node', os.uname()[1])\",\n \"def setUp(self):\\n self.data = DatabaseIntermediary()\",\n \"def setUpClass(cls):\\n cls.database_connection = DatabaseHandler(database_path)\\n cls.database_connection.connect()\\n processing.create_table_if_not_exist(cls.database_connection, table_name)\\n cls.database_connection.close()\",\n \"def setUp(self) -> None:\\n sqlite_db = setup_sqlite_in_memory_db()\\n sqlite_db.create_tables([\\n Schedule,\\n Destination\\n ])\\n self.schedule_factory = ScheduleFactory()\",\n \"def setup_class(self):\\n self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()\\n app.config['TESTING'] = True\\n self.app = app.test_client()\\n init_db()\",\n \"def init():\\n database.create_tables([Tracker])\\n database.commit()\",\n \"def _load_db(self):\\n for type_ in self._types:\\n try:\\n type_.table(self._metadata)\\n except InvalidRequestError:\\n pass\\n # Reflect metadata so auto-mapping works\\n self._metadata.reflect(self._engine)\\n # Make sure the tables exist\\n self._metadata.create_all()\",\n \"def on_load(self):\\n pass\",\n \"def on_load(self):\\n pass\",\n \"def setUp(self):\\n input_files = glob.glob(PATH_TO_INPUT_FILES) # Read input (csv) files from current (sw/test) directory.\\n if not self.sessionizing:\\n self.sessionizing = Sessionizing()\\n self.sessionizing.initialize(*input_files)\\n if not self.sites_session_counter:\\n self.merge_and_sort_input_files(*input_files)\\n self.process_input_files()\",\n \"def preload(self):\\n # load the objects\\n for otype, fname in self.TYPE2NAME.items():\\n if fname:\\n path = os.path.join(self.anodir, fname + \\\".gz\\\")\\n if os.path.isfile(path):\\n with gzip.open(path, \\\"rt\\\") as handler:\\n for line in handler:\\n omap = json.loads(line)\\n cls = self.TYPE2CLASS[otype]\\n item = cls.from_map(omap, self)\\n self.caches[otype][item.id] = item\",\n \"def load(self):\\n self._really_load()\",\n \"def _setup(self) -> None:\\n try:\\n coverage = []\\n if (\\n self._config\\n and \\\"restore_state\\\" in self._config[\\\"core\\\"]\\n and self._config[\\\"core\\\"][\\\"restore_state\\\"]\\n ):\\n coverage = [\\n \\\"tracklist\\\",\\n \\\"mode\\\",\\n \\\"play-last\\\",\\n \\\"mixer\\\",\\n \\\"history\\\",\\n ]\\n if len(coverage):\\n self._load_state(coverage)\\n except Exception as e:\\n logger.warning(\\\"Restore state: Unexpected error: %s\\\", str(e))\",\n \"def initialise(self):\\n self.set_up()\",\n \"def _pre_setup(self):\\r\\n\\r\\n # Flush the Mongo modulestore\\r\\n ModuleStoreTestCase.drop_mongo_collections()\\r\\n\\r\\n # Call superclass implementation\\r\\n super(ModuleStoreTestCase, self)._pre_setup()\",\n \"def setUp(self):\\n self.ds = DictionaryStore(Camper)\\n self.engine = Engine(self.ds)\",\n \"def post_setup(self, context):\\n pass\",\n \"def setup(self) -> None:\\n self.setup_logging()\\n self.setup_plugins()\\n self.post_setup()\",\n \"def Start(self):\\n self.state.hist_count = 0\\n self.state.history_paths = []\\n\\n if self.args.history_path:\\n self.state.history_paths.append(self.args.history_path)\\n else:\\n self.state.history_paths = self.GuessHistoryPaths(self.args.username)\\n\\n if not self.state.history_paths:\\n raise flow_base.FlowError(\\\"Could not find valid History paths.\\\")\\n\\n filename = \\\"places.sqlite\\\"\\n for path in self.state.history_paths:\\n self.CallFlow(\\n file_finder.FileFinder.__name__,\\n paths=[os.path.join(path, \\\"**2\\\", filename)],\\n pathtype=self.args.pathtype,\\n action=rdf_file_finder.FileFinderAction.Download(),\\n next_state=self.ParseFiles.__name__)\",\n \"def _db_setup(self):\\n self.get_connection()\\n sql_file = open(db_config.DATABASE_TABLES_SETUP_FILE, 'r')\\n with self.conn.cursor() as cur:\\n cur.execute(sql_file.read())\\n self.conn.commit()\\n logger.info(f'The script {db_config.DATABASE_TABLES_SETUP_FILE} has run.')\",\n \"def _set_up(self):\\n # Also recreates any attributes not in _io_attrs on load from input file.\\n # See IOAble class docstring for more info.\\n self._enforce_symmetry()\\n self._sort_modes()\\n self._create_idx()\",\n \"def boot():\\n\\t\\tcreate_project_url_dir(Spider.project_name)\\n\\t\\tcreate_url_data(Spider.project_name, Spider.base_url)\\n\\t\\tSpider.queue = file_to_set(Spider.queue_file)\\n\\t\\tSpider.crawled = file_to_set(Spider.crawled_file)\",\n \"def __init__(self):\\n self._setup()\\n # Encryption/decryption cipher handler\\n self.__cipher = self.__get_cipher()\\n # Setup the engine for the sqlite database\\n self._engine = create_engine(self.db_uri)\\n # Configure the SQLAlchemy metadata\\n self._metadata = MetaData()\\n self._metadata.bind = self._engine\\n self._load_db()\\n # Configure the auto-mapping base model\\n self._base = automap_base(metadata=self._metadata)\\n self._base.prepare()\\n # Setup a session generator for database connections\\n self._session = sessionmaker(bind=self._engine)\",\n \"def connect(self):\\n super(NERDmLoader, self).connect()\\n self.lateloadr._client = self._client\\n self.lateloadr._db = self._db\\n self.relloadr._client = self._client\\n self.relloadr._db = self._db\",\n \"def _fixture_setup(self):\\n pass\",\n \"def _pre_load(self):\\n urdfloader_config = dict(\\n pybullet_client=self._pybullet_client,\\n urdf_path=pupper_constants.URDF_PATH,\\n constrained_base=True,\\n # Hang the robot in the air.\\n enable_self_collision=True,\\n # Makes the simulated robot haning higher from the ground.\\n init_base_position=np.array(pupper_constants.INIT_POSITION) + np.array(\\n (0, 0, 0.5)),\\n init_base_orientation_quaternion=pupper_constants.INIT_ORIENTATION,\\n init_joint_angles=pupper_constants.INIT_JOINT_ANGLES,\\n joint_offsets=pupper_constants.JOINT_OFFSETS,\\n joint_directions=pupper_constants.JOINT_DIRECTIONS,\\n motor_names=pupper_constants.MOTOR_NAMES,\\n end_effector_names=pupper_constants.END_EFFECTOR_NAMES,\\n user_group=pupper_constants.MOTOR_GROUP)\\n config_keys = list(urdfloader_config.keys())\\n gin_config = gin.config_str()\\n for i in range(len(config_keys)):\\n if config_keys[i] in gin_config:\\n urdfloader_config.pop(config_keys[i])\\n\\n self._urdf_loader = robot_urdf_loader.RobotUrdfLoader(\\n **urdfloader_config\\n )\",\n \"def setUp(self):\\n self.app = load_app(self.application_under_test)\\n\\n try:\\n teardown_db()\\n except Exception as e:\\n print('-> err ({})'.format(e.__str__()))\\n\\n setup_app(section_name=self.application_under_test)\\n setup_db()\\n\\n fixtures_loader = FixturesLoader([BaseFixture]) # BaseFixture is already loaded in bootstrap\\n fixtures_loader.loads(self.fixtures)\",\n \"def _setup(self) -> None:\\n\\t\\treturn\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def _setup(self):\\n pass\",\n \"def init_database(self):\\n # init_database(self.engine)\",\n \"def __initDataFromImages(self):\\n #Check if the local_db exist\\n initial_dirs = os.listdir(os.getcwd())\\n is_db_empty = False\\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\\n [images_dir] = os.listdir(self.base_dir)\\n is_db_empty = images_dir == cfg.local[\\\"IMG_DIR\\\"]\\n if cfg.local[\\\"DEFAULT_IMGS_DIR\\\"] in initial_dirs and is_db_empty:\\n default_path = os.path.join(os.getcwd(), cfg.local[\\\"DEFAULT_IMGS_DIR\\\"])\\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\\n self.le = LabelEncoder()\\n #Nothing relate to mapping name to dir here, we don't care about\\n #This data because of the user doesn't exist in the database\\n self.__savePreProcessedData()\",\n \"def initialize_database():\\n # TODO: Refactor the funtime library\\n this.db = Store(this.host).create_lib(this.store_name).get_store()\",\n \"def setup(self):\\n return self.setupDatabases()\",\n \"def _manual_setup(self):\\n # If self.cache is None, then all caching should be skipped\\n if self.name_to_index_dict is None:\\n self.name_to_index_dict = {name:i for i, name in enumerate(self.input_fields)}\\n self.task_label_index = self.name_to_index_dict[self.task_name]\\n if self.cache is not None:\\n self.setup_cache()\",\n \"def bootstrap(self, datafile):\\n import sqlite3\\n # Try fetching a value from the table, if we get an OperationalError\\n # we assume that the table doesn't exist, and create it.\\n try:\\n self.get(\\\"foo\\\")\\n return\\n except KeyError:\\n return\\n except sqlite3.OperationalError:\\n print \\\" >> Bootstrapping local store: %s\\\" % datafile\\n c = self.conn.cursor()\\n c.execute(\\\"CREATE TABLE metastore (k varchar(255), v \\\"\\n \\\"text, primary key(k));\\\")\\n self.conn.commit()\",\n \"def work(self):\\n self.config_file = self.args.config\\n self.init_config()\\n self.init_db()\\n\\n self.kickoff()\",\n \"def init_data_base_activity(path):\\n\\n conn = sqlite3.connect(path)\\n c = conn.cursor()\\n\\n c.execute(\\\"DROP TABLE IF EXISTS Activity\\\")\\n c.execute('''CREATE TABLE Activity\\n (\\n inseeNb TEXT, comLib TEXT, equipementId TEXT,\\n equNbEquIdentique TEXT, actCode TEXT,actLib TEXT,\\n equActivitePraticable TEXT, equActivitePratique TEXT,\\n equActiviteSalleSpe TEXT, actNivLib TEXT\\n )'''\\n )\\n\\n conn.commit()\\n conn.close()\",\n \"def on_worker_init(self):\\n self.import_default_modules()\\n\\n self.close_database()\\n self.close_cache()\",\n \"def setUp(self):\\n client = utils.create_test_datastore_client()\\n self.resource = import_attempt.ImportAttemptByID(client)\\n list_resource = import_attempt_list.ImportAttemptList(client)\\n run_list_resource = system_run_list.SystemRunList(client)\\n attempts = [{\\n _ATTEMPT.provenance_url: 'google.com'\\n }, {\\n _ATTEMPT.provenance_url: 'facebook.com'\\n }, {\\n _ATTEMPT.provenance_url: 'bing.com'\\n }]\\n self.attempts = utils.ingest_import_attempts(run_list_resource,\\n list_resource, attempts)\",\n \"def prepare(self):\\n if self.opts['verbose']:\\n print(\\\"Preparing dataset (one-time operation)...\\\")\\n # Create paths files and load them back in\\n self._build_ID_sets()\\n self._create_ID_files()\\n self._load_ID_files()\\n if self.opts['verbose']:\\n print(\\\"... done with preparing the dataset.\\\")\",\n \"def setup(self):\\n self.config = pau.IConfig\\n self.session = pau.ISession\\n pau.resolve(self)\\n\\n self.session.assets = Assets()\\n self.config.db = self.db_name\\n\\n self.db = pau.IDb\\n pau.resolve(self)\\n\\n # Instance\\n i = Setup()\\n pau.resolve(i)\\n return i\",\n \"def init_database(self):\\n init_database(self.engine)\",\n \"def importData():\\n #importChallengeDataToDB()\\n importTrendingDataToDB()\",\n \"def __init__(self, persistent=True):\\n super().__init__()\\n self.name_cache = {}\\n self.run_cache = {}\\n self.row_cache = {}\\n self.persistent = persistent\\n\\n if self.persistent:\\n self.load_cache()\",\n \"def database_setup():\\n Base.metadata.create_all(bind=engine)\\n db = LocalSession()\\n try:\\n populate_from_json(db, Vector, str(VECTORS))\\n populate_from_json(db, Gender, str(GENDERS))\\n populate_from_json(db, Tag, str(TAGS))\\n finally:\\n db.close()\",\n \"def _precache_reference_files(self, input_file):\\n from .. import datamodels\\n gc.collect()\\n if self._is_association_file(input_file):\\n return\\n try:\\n with datamodels.open(input_file) as model:\\n pass\\n except (ValueError, TypeError, IOError):\\n self.log.info(\\n 'First argument {0} does not appear to be a '\\n 'model'.format(input_file))\\n else:\\n super(Pipeline, self)._precache_reference_files(input_file)\\n for name in self.step_defs.keys():\\n step = getattr(self, name)\\n step._precache_reference_files(input_file)\\n gc.collect()\",\n \"def prepare(self):\\n raise NotImplementedError('ContextSourceInterface.setup')\",\n \"def init(self, **kwargs):\\n self._d = {}\\n self._th = None\\n self._run = True\\n self.load()\",\n \"def setup(db_name = 'net.db', **extra_params):\\n global db_run # Imports the DB from the simulator\\n \\n# # If the file already exists delete it\\n if DEBUG: print \\\"[ pyNN ] : Opening DB\\\", os.path.abspath(db_name)\\n if os.path.exists(db_name):\\n if DEBUG: print \\\"[ pyNN ] : DB already initialized... cleaning up... removing file %s\\\" % db_name\\n os.remove(db_name)\\n db_run = db(db_name) # Creates the DB \\n db_run.init_db() # Initializes the DB\\n return(db_run)\",\n \"def _preprocess(self) -> None:\\n self.cache = Cache(self._db, self._collection)\",\n \"def __init__(self):\\n\\n self.this_dir = os.path.dirname(os.path.abspath(__file__))\\n self.db_path = self._discover_in_dir(self.this_dir)\",\n \"def init_db(self):\\n self.db_config = databaseutils.process_db_config(self.config['db'])\\n\\n from sqlalchemy import create_engine\\n from sqlalchemy.orm import sessionmaker, scoped_session\\n self.engine = create_engine(self.db_config.constr, pool_recycle=3600)\\n self.session = scoped_session(sessionmaker(bind=self.engine))\\n\\n # Make sure tables are created\\n DB_Base.metadata.create_all(self.engine)\\n\\n if self.sqlite_file is not None:\\n dbname = 'sqlite:///%s' % self.sqlite_file\\n self.sqlite_engine = create_engine(dbname, echo=False)\\n self.sqlite_session = scoped_session(sessionmaker(bind=self.sqlite_engine))\\n DB_Base.metadata.create_all(self.sqlite_engine)\\n logger.info('Using SQLite %s' % self.sqlite_engine)\",\n \"def setUp(self):\\n self.conn = self.dbi.connection()\\n self.file_lumi_insert = FileLumiInsert(self.logger, self.dbi, self.dbowner)\\n self.file_id = FileID(self.logger, self.dbi, self.dbowner)\",\n \"def init():\\n global __dbChanged\\n __dbChanged = False\\n loadItemsFromFile()\\n global __isInitialized\\n if __isInitialized == True:\\n return\\n\\n Report.trace(\\\"itemdatabase\\\", \\\"Initializing the item database.\\\")\\n returnCode = FilterManager.executeFiltersForEvent(\\\"preInitializeItemDatabase\\\")\\n if returnCode == FilterManager.FINISHED:\\n Report.trace(\\\"itemdatabase\\\", \\\"Item database initialized.\\\")\\n __isInitialized = True\\n return\\n\\n for item in Items.items:\\n addItem(item)\\n\\n FilterManager.executeFiltersForEvent(\\\"postInitializeItemDatabase\\\")\\n __isInitialized = True\\n Report.trace(\\\"itemdatabase\\\", \\\"Item database initialized.\\\")\",\n \"def load_models(self, episode):\\r\\n self.actor.load_state_dict(self.target_actor.state_dict())\\r\\n self.critic.load_state_dict(self.target_critic.state_dict())\\r\\n hard_update(self.target_actor, self.actor)\\r\\n hard_update(self.target_critic, self.critic)\",\n \"async def bootstrap(self, app, db):\\n await self.factory.prepare(db)\",\n \"def setUp(self):\\n\\n PyFunceble.load_config(\\n generate_directory_structure=False, custom={\\\"db_type\\\": \\\"json\\\"}\\n )\\n\\n self.file_to_test = \\\"this_is_a_ghost\\\"\\n self.storage_file = (\\n PyFunceble.CONFIG_DIRECTORY + PyFunceble.OUTPUTS.default_files.inactive_db\\n )\\n\\n self.time_past = str(int((datetime.utcnow() - timedelta(days=365)).timestamp()))\\n self.time_future = str(\\n int((datetime.utcnow() + timedelta(days=365)).timestamp())\\n )\\n\\n self.inactive_db = InactiveDB(self.file_to_test, parent_process=True)\\n\\n PyFunceble.helpers.File(self.storage_file).delete()\",\n \"def __init__(self):\\n self.filepath = os.path.dirname(__file__)\\n self.filepath = os.path.join(self.filepath, \\\"Datenbank\\\")\\n self.filepath_render_database = os.path.join(self.filepath, self.render_database)\\n self.filepath_object_database = os.path.join(self.filepath, self.object_database)\\n self.filepath_output_database = os.path.join(self.filepath, self.output_database)\\n self.create_database()\",\n \"def load_trainer(self):\\n super().load_trainer()\\n\\n logging.info(\\\"[Server #%d] Loading a pre-trained model.\\\", os.getpid())\\n self.trainer.load_model()\",\n \"def setUp(self):\\n # Drop directory if it exists\\n if os.path.isdir(SERVER_DIR):\\n shutil.rmtree(SERVER_DIR)\\n os.makedirs(SERVER_DIR)\\n self.processor = MimirProcessor()\\n self.datastore = MimirDatastore(DATASTORE_DIR)\\n self.filestore = FileSystemFilestore(FILESTORE_DIR)\\n self.available_lenses = set(mimir.getAvailableLensTypes())\",\n \"def main():\\n # Create the flow\\n with Flow('pickle flow') as flow:\\n db_table = create_table()\\n weather_data = get_weather(LAT_NYC, LON_NYC, 2018)\\n parsed_data = parse_weather(weather_data)\\n populated_table = store_weather(parsed_data)\\n populated_table.set_upstream(db_table)\\n\\n # Run the flow\\n flow.run()\",\n \"def load_static():\\n\\n for i, row in enumerate(open(\\\"seed_data/homepage_feature.static\\\")):\\n row = row.rstrip()\\n title, body, img_path_xs, img_path_sm, img_path_md, img_path_lg, is_active = row.split(\\\"|\\\")\\n homepage_feature = HomepageFeatureModel(title=title,\\n body=body,\\n img_path_xs=img_path_xs,\\n img_path_sm=img_path_sm,\\n img_path_md=img_path_md,\\n img_path_lg=img_path_lg,\\n is_active=is_active)\\n db.session.add(homepage_feature)\\n\\n for i, row in enumerate(open(\\\"seed_data/help_article.static\\\")):\\n row = row.rstrip()\\n title, description, body = row.split(\\\"|\\\")\\n help_article = HelpArticleModel(title=title, \\n description=description, \\n body=body)\\n db.session.add(help_article)\\n\\n db.session.commit()\",\n \"def __init__(self, workflow, **kwds):\\n self.kwds = kwds\\n self.url = self.get('url', 'cmsweb.cern.ch')\\n WorkflowManager.__init__(self, workflow, self.url)\\n self.workload = getWorkload(self.url, workflow)\\n self.cacheID = self.winfo.get('StepOneConfigCacheID', '')\\n self.config = getConfig(self.url, self.cacheID)\\n self.pileup_dataset = self._pileup_dataset()\\n self.priority = self._priority()\\n self.era = self.get('era', 'Summer12')\\n self.lfn = self.get('lfn', '/store/mc')\\n self.special_name = self.get('specialName', '')\\n self.max_rss = self.get('maxRSS', 2300000)\\n self.max_vsize = self.get('maxVSize', 4100000000)\\n self.input_dataset = ''\\n self.pileup_scenario = ''\\n self.global_tag = self.get('globalTag', '')\\n self.campaign = self.get('campaign', '')\\n self.max_merge_events = self.get('maxMergeEvents', 50000)\\n self.activity = self.get('activity', 'reprocessing')\\n self.restrict = self.get('restrict', 'None')\\n self.site_use = self.get('site', None)\\n self.site_cust = self.get('site_cust', None)\\n self.xrootd = self.get('xrootd', 0)\\n self.ext_tag = self.get('ext', '')\\n self.team = self.get('team', '')\\n\\n # perform various initialization\\n self._init()\\n\\n # custom settings\\n # Construct processed dataset version\\n if self.pileup_scenario:\\n self.pileup_scenario = self.pileup_scenario+'_' \\n\\n specialprocstring = kwds.get('specialName', '')\\n if specialprocstring:\\n self.special_name = specialprocstring + '_'\\n\\n # ProcessingString\\n inprocstring = kwds.get('procstring', '')\\n if inprocstring:\\n self.procstring = inprocstring\\n else:\\n self.procstring = self.special_name + self.pileup_scenario +\\\\\\n self.global_tag + self.ext_tag\\n\\n # ProcessingVersion\\n inprocversion = kwds.get('procversion', '')\\n if inprocversion:\\n self.procversion = inprocversion\\n else:\\n self.procversion = self.dataset_version(self.era, self.procstring)\",\n \"def initialize(self, context):\\n\\n properties = context.system_properties\\n self.map_location = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n self.device = torch.device(\\n self.map_location + \\\":\\\" + str(properties.get(\\\"gpu_id\\\"))\\n if torch.cuda.is_available()\\n else self.map_location\\n )\\n self.manifest = context.manifest\\n\\n model_dir = properties.get(\\\"model_dir\\\")\\n self.batch_size = properties.get(\\\"batch_size\\\")\\n serialized_file = self.manifest[\\\"model\\\"][\\\"serializedFile\\\"]\\n model_pt_path = os.path.join(model_dir, serialized_file)\\n\\n if not os.path.isfile(model_pt_path):\\n raise RuntimeError(\\\"Missing the model.pt file\\\")\\n\\n logger.debug(\\\"Loading torchscript model\\\")\\n self.model = self._load_torchscript_model(model_pt_path)\\n\\n self.model.to(self.device)\\n self.model.eval()\\n\\n logger.debug(\\\"Model file %s loaded successfully\\\", model_pt_path)\\n\\n self.initialized = True\",\n \"def initialise_bdd(self):\\n print(fr.FR[1])\\n self.base.create_database(\\\"sql/p5.sql\\\")\\n print(fr.FR[2])\\n self.category_table.save_category()\\n print(fr.FR[3])\",\n \"def setUp(self):\\n self.db_fd, closet.app.config['DATABASE'] = tempfile.mkstemp()\\n closet.app.config['TESTING'] = True\\n self.app = closet.app.test_client()\\n closet.init_db()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6175916","0.6035001","0.5991969","0.5970857","0.58654773","0.58605886","0.5847241","0.5826606","0.5805958","0.57829595","0.5778072","0.575451","0.56998646","0.56855494","0.56470186","0.56340146","0.5630023","0.56250453","0.5624165","0.5621802","0.5620545","0.56033486","0.55841726","0.5569187","0.5568181","0.5544322","0.5532155","0.55276227","0.55227935","0.550592","0.5501023","0.5495304","0.54923826","0.5484581","0.5476364","0.5464528","0.5445132","0.5444847","0.5444847","0.54418695","0.54370636","0.5436625","0.54348296","0.54339755","0.5433472","0.54277277","0.5422092","0.54197806","0.5417412","0.5411178","0.54059285","0.54019254","0.5395547","0.53936625","0.5388855","0.5387381","0.53802246","0.5375867","0.5375409","0.5375409","0.5375409","0.5375409","0.5375409","0.53695434","0.53675514","0.53648806","0.5364327","0.53558004","0.53527975","0.535171","0.53513885","0.5349924","0.53488547","0.5345963","0.5344522","0.5341688","0.5335764","0.5335659","0.533484","0.53321123","0.5330602","0.53158915","0.5315007","0.53106475","0.53065","0.53063226","0.53060824","0.5305812","0.5304857","0.5303942","0.53003865","0.5291318","0.5290473","0.5284757","0.5281851","0.5279755","0.5279748","0.5275723","0.52728003","0.52723414"],"string":"[\n \"0.6175916\",\n \"0.6035001\",\n \"0.5991969\",\n \"0.5970857\",\n \"0.58654773\",\n \"0.58605886\",\n \"0.5847241\",\n \"0.5826606\",\n \"0.5805958\",\n \"0.57829595\",\n \"0.5778072\",\n \"0.575451\",\n \"0.56998646\",\n \"0.56855494\",\n \"0.56470186\",\n \"0.56340146\",\n \"0.5630023\",\n \"0.56250453\",\n \"0.5624165\",\n \"0.5621802\",\n \"0.5620545\",\n \"0.56033486\",\n \"0.55841726\",\n \"0.5569187\",\n \"0.5568181\",\n \"0.5544322\",\n \"0.5532155\",\n \"0.55276227\",\n \"0.55227935\",\n \"0.550592\",\n \"0.5501023\",\n \"0.5495304\",\n \"0.54923826\",\n \"0.5484581\",\n \"0.5476364\",\n \"0.5464528\",\n \"0.5445132\",\n \"0.5444847\",\n \"0.5444847\",\n \"0.54418695\",\n \"0.54370636\",\n \"0.5436625\",\n \"0.54348296\",\n \"0.54339755\",\n \"0.5433472\",\n \"0.54277277\",\n \"0.5422092\",\n \"0.54197806\",\n \"0.5417412\",\n \"0.5411178\",\n \"0.54059285\",\n \"0.54019254\",\n \"0.5395547\",\n \"0.53936625\",\n \"0.5388855\",\n \"0.5387381\",\n \"0.53802246\",\n \"0.5375867\",\n \"0.5375409\",\n \"0.5375409\",\n \"0.5375409\",\n \"0.5375409\",\n \"0.5375409\",\n \"0.53695434\",\n \"0.53675514\",\n \"0.53648806\",\n \"0.5364327\",\n \"0.53558004\",\n \"0.53527975\",\n \"0.535171\",\n \"0.53513885\",\n \"0.5349924\",\n \"0.53488547\",\n \"0.5345963\",\n \"0.5344522\",\n \"0.5341688\",\n \"0.5335764\",\n \"0.5335659\",\n \"0.533484\",\n \"0.53321123\",\n \"0.5330602\",\n \"0.53158915\",\n \"0.5315007\",\n \"0.53106475\",\n \"0.53065\",\n \"0.53063226\",\n \"0.53060824\",\n \"0.5305812\",\n \"0.5304857\",\n \"0.5303942\",\n \"0.53003865\",\n \"0.5291318\",\n \"0.5290473\",\n \"0.5284757\",\n \"0.5281851\",\n \"0.5279755\",\n \"0.5279748\",\n \"0.5275723\",\n \"0.52728003\",\n \"0.52723414\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5878006"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":17086,"cells":{"query":{"kind":"string","value":"LciaEngine.__getitem__ retrieves a canonical context by more intensively searching for matches from a given context. Adds foreign context's full name as synonym if one is affirmatively found. If one is not found, returns the NullContext. None is returned as None, to represent 'unspecified' (i.e. accept all) as opposed to 'no context' which isa context (accept only matching). (as tested)"},"document":{"kind":"string","value":"def __getitem__(self, item):\n if item is None:\n return None\n try:\n return self._cm.__getitem__(item)\n except KeyError:\n if isinstance(item, Context):\n return self._cm.find_matching_context(item)\n elif isinstance(item, tuple) and len(item) > 1:\n return self.__getitem__(item[1:])\n return NullContext"},"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 __dis_context__(self, context, word):\n senses = self.vs.get_senses(word, self.ignore_case)\n if self.verbose:\n print(\"Senses of a target word:\")\n print(senses)\n\n if len(senses) == 0: # means we don't know any sense for this word\n return None\n\n # collect context vectors\n vctx = [self.vc[c] for c in context]\n\n if len(vctx) == 0: # means we have no context\n return None\n # TODO: better return most frequent sense or make random choice\n\n # filter context vectors, if aplicable\n if self.filter_ctx >= 0:\n vctx = self.__filter__(vctx, senses, self.filter_ctx)\n\n if self.ctx_method == 'prob':\n avg_context = np.mean(vctx, axis=0)\n scores = [self.__logprob__(avg_context, self.vs[sense]) for sense, prob in senses]\n\n elif self.ctx_method == 'sim':\n avg_context = np.mean(vctx, axis=0)\n scores = [self.__cosine_sim__(avg_context, self.vs[sense]) for sense, prob in senses]\n if self.verbose:\n print(\"Sense probabilities:\")\n print(scores)\n\n else:\n raise ValueError(\"Unknown context handling method '%s'\" % self.ctx_method)\n\n # return sense (word#id), scores for senses\n return senses[np.argmax(scores)][0], scores","def _plug_from_context(self):\n children = self.smartplug.sys_info[\"children\"]\n return next(c for c in children if c[\"id\"] == self.smartplug.context)","def get_context(self):\n symbol_chain = self.split_completion_object(self.get_word_before())\n current_rs_object = self.module\n\n for symbol in symbol_chain:\n try:\n current_rs_object = current_rs_object.get_object(symbol)\n logging.info(f\"New context found: {current_rs_object.name}\")\n except:\n logging.error(f\"{type(current_rs_object)} has no method get_object yet.\")\n return current_rs_object\n\n return current_rs_object","def _resolve_context(r, tablename, context):\n\n record_id = r.id\n if not record_id:\n return None\n\n if not context:\n query = None\n\n elif type(context) is tuple:\n context, field = context\n query = (FS(context) == r.record[field])\n\n elif context == \"location\":\n # Show records linked to this Location & all it's Child Locations\n s = \"(location)$path\"\n # This version doesn't serialize_url\n #m = (\"%(id)s/*,*/%(id)s/*\" % dict(id=id)).split(\",\")\n #filter = (FS(s).like(m)) | (FS(s) == id)\n m = (\"%(id)s,%(id)s/*,*/%(id)s/*,*/%(id)s\" % dict(id=record_id)).split(\",\")\n m = [f.replace(\"*\", \"%\") for f in m]\n query = (FS(s).like(m))\n # @ToDo:\n #elif context == \"organisation\":\n # # Show records linked to this Organisation and all it's Branches\n # s = \"(%s)\" % context\n # query = (FS(s) == id)\n else:\n # Normal: show just records linked directly to this master resource\n s = \"(%s)\" % context\n query = (FS(s) == record_id)\n\n # Define target resource\n resource = current.s3db.resource(tablename, filter=query)\n r.customise_resource(tablename)\n return resource, query","def _repair_context(self, context):\n\n if isinstance(context, Graph):\n return self._repair_context(context.identifier)\n elif isinstance(context, URIRef):\n return context\n else:\n return NULL_CONTEXT","def _find_context(\n node: ast.AST,\n contexts: Tuple[Type[ast.AST], ...],\n) -> Optional[ast.AST]:\n parent = get_parent(node)\n if parent is None:\n return None\n elif isinstance(parent, contexts):\n return parent\n return _find_context(parent, contexts)","def set_context(self):\n results = self.rml.query(\"\"\"\n SELECT ?o {\n {\n ?s rr:class ?o\n } UNION {\n ?s rr:predicate ?o\n }\n }\"\"\")\n namespaces = [Uri(row[0]).value[0]\n for row in results\n if isinstance(row[0], rdflib.URIRef)]\n self.context = {ns[0]: ns[1] for ns in namespaces if ns[0]}","def __getitem__(self, name):\r\n if name not in self.current_context:\r\n raise KeyError(\"Trying to use an undefined label!\")\r\n return self.current_context[name]","def test_context2vec_context_similarity(self):\n contexts = {1:{0, 1, 2, 3}, 2:{2, 3, 4, 5}, 3:{10}}\n cc = ContextCorpus(contexts)\n model = Word2Vec(cc, size=3, iter=1000, min_count=1, alpha=0.1, sg=0)\n results = filter(lambda x: x[0].startswith('C'), model.most_similar('C1',\n topn=100))\n self.assertTrue(results[0][0] == 'C2')","def get_from_context(cls, context):\n obj = context.active_object\n\n if obj and obj.type not in {\"LAMP\", \"CAMERA\"}:\n mat = obj.active_material\n\n if mat:\n # ID pointer\n node_tree = mat.appleseed.osl_node_tree\n\n if node_tree:\n return node_tree, mat, mat\n\n elif obj and obj.type == \"LAMP\":\n node_tree = obj.data.appleseed.osl_node_tree\n\n if node_tree:\n return node_tree, None, None\n\n return None, None, None","def resolve(self, context, safe=True, quiet=False):\r\n try:\r\n current = context\r\n for bit in self.bits:\r\n try: # dictionary lookup\r\n current = current[bit]\r\n except (TypeError, AttributeError, KeyError):\r\n try: # attribute lookup\r\n current = getattr(current, bit)\r\n except (TypeError, AttributeError):\r\n try: # list-index lookup\r\n current = current[int(bit)]\r\n except (IndexError, # list index out of range\r\n ValueError, # invalid literal for int()\r\n KeyError, # dict without `int(bit)` key\r\n TypeError, # unsubscriptable object\r\n ):\r\n raise ValueError('Failed lookup for key [%s] in %r'\r\n ', when resolving the accessor %s'\r\n % (bit, current, self))\r\n if callable(current):\r\n if safe and getattr(current, 'alters_data', False):\r\n raise ValueError('refusing to call %s() because `.alters_data = True`'\r\n % repr(current))\r\n current = current()\r\n # important that we break in None case, or a relationship\r\n # spanning across a null-key will raise an exception in the\r\n # next iteration, instead of defaulting.\r\n if current is None:\r\n break\r\n return current\r\n except:\r\n if not quiet:\r\n raise","def __call__(self, context=None):\n if context is None:\n context = self.context\n return self.entity.resolve(context)","def get(self, key):\n keystr = str(key)\n res = None\n\n try:\n res = self.ctx[keystr]\n except KeyError:\n for k, v in self.ctx.items():\n if \"name\" in v and v[\"name\"].lower() == keystr.lower():\n res = v\n break\n\n return res","def xontrib_context(name):\n spec = find_xontrib(name)\n if spec is None:\n return None\n m = importlib.import_module(spec.name)\n pubnames = getattr(m, \"__all__\", None)\n if pubnames is not None:\n ctx = {k: getattr(m, k) for k in pubnames}\n else:\n ctx = {k: getattr(m, k) for k in dir(m) if not k.startswith(\"_\")}\n return ctx","def common_contexts(self, words, fail_on_unknown=False):\n words = [self._key(w) for w in words]\n contexts = [set(self._word_to_contexts[w]) for w in words]\n empty = [words[i] for i in range(len(words)) if not contexts[i]]\n common = reduce(set.intersection, contexts)\n if empty and fail_on_unknown:\n raise ValueError(\"The following word(s) were not found:\", \" \".join(words))\n elif not common:\n # nothing in common -- just return an empty freqdist.\n return FreqDist()\n else:\n fd = FreqDist(\n c for w in words for c in self._word_to_contexts[w] if c in common\n )\n return fd","def currentCtx(*args, **kwargs)->AnyStr:\n pass","def ctx():\n return None","def open_context(self, description, shared=True):\n\n cu_name = description[\"cu_name\"]\n context = self.contexts.get(cu_name)\n if context:\n return context[\"idx\"]\n if _xrt_version >= (2, 6, 0):\n cu_index = xrt.xclIPName2Index(self.handle, cu_name)\n description[\"cu_index\"] = cu_index\n else:\n cu_index = description[\"cu_index\"]\n\n uuid = bytes.fromhex(description[\"xclbin_uuid\"])\n uuid_ctypes = XrtUUID((ctypes.c_char * 16).from_buffer_copy(uuid))\n err = xrt.xclOpenContext(self.handle, uuid_ctypes, cu_index, shared)\n\n if err:\n raise RuntimeError(\n \"Could not open CU context - {}, {}\".format(err, cu_index)\n )\n # Setup the execution context for the compute unit\n self.contexts[cu_name] = {\n \"cu\": cu_name,\n \"idx\": cu_index,\n \"uuid_ctypes\": uuid_ctypes,\n \"shared\": shared,\n }\n\n return cu_index","def __getitem__(self, key):\n try:\n att = getattr(self, key)\n return att\n except AttributeError:\n # mimic pylons context\n return None","def context(self) -> CONTEXT:","def get_context(event):\n for link in event.links.links:\n if link.get(\"type\") == \"CONTEXT\":\n context = link.get(\"target\")\n break\n else:\n context = None\n return context","def lookup():","def getQueryAnchor(self, context, metatype=None):\n for o in list(context.aq_chain):\n if IExtropyTracking.providedBy(o):\n if metatype is None:\n return o\n elif hasattr(o,'meta_type') and metatype == o.meta_type:\n return o\n return getToolByName(self, 'portal_url').getPortalObject()","def __getitem__(self, item):\r\n current = self\r\n while current is not None:\r\n if item in current.locals:\r\n return current.locals[item]\r\n current = current.parent","def __contexts(\n self, triple: \"_TripleType\"\n ) -> Generator[\"_ContextType\", None, None]:\n # type error: Argument 2 to \"get\" of \"Mapping\" has incompatible type \"str\"; expected \"Optional[Graph]\"\n return (\n self.__context_obj_map.get(ctx_str, ctx_str) # type: ignore[arg-type]\n for ctx_str in self.__get_context_for_triple(triple, skipQuoted=True)\n if ctx_str is not None\n )","def resolveContext(self, context):\n if context is None:\n return context\n elif isinstance(context, tuple):\n return context\n elif isinstance(context, tuple):\n return tuple(context.split('/'))\n else:\n return context.getPhysicalPath()","def get_word_context(word):\r\n\tfor content, profile in word_context_profile:\r\n\t\tif word == content:\r\n\t\t\treturn profile \r\n\treturn 0","def get_doc_context(self, docname, body, metatags):\n\n # TYPO3: remove 'documentation' from end of 'shorttitle'\n shorttitle = self.globalcontext.get('shorttitle', '')\n if shorttitle and shorttitle.endswith(' documentation'):\n shorttitle = shorttitle[0:-14].rstrip()\n self.globalcontext['shorttitle'] = shorttitle\n \n\n # find out relations\n # TYPO3: always have order 'previous', 'up', 'next'\n prev = up = next = None\n parents = []\n rellinks = self.globalcontext['rellinks'][:]\n related = self.relations.get(docname)\n titles = self.env.titles\n if related and related[1]:\n try:\n prev = {\n 'link': self.get_relative_uri(docname, related[1]),\n 'title': self.render_partial(titles[related[1]])['title']\n }\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n if related and related[0]:\n try:\n up = {\n 'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']\n }\n rellinks.append((related[0], up['title'], 'U', _('up')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n if related and related[2]:\n try:\n next = {\n 'link': self.get_relative_uri(docname, related[2]),\n 'title': self.render_partial(titles[related[2]])['title']\n }\n rellinks.append((related[2], next['title'], 'N', _('next')))\n except KeyError:\n next = None\n while related and related[0]:\n try:\n parents.append(\n {'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']})\n except KeyError:\n pass\n related = self.relations.get(related[0])\n if parents:\n parents.pop() # remove link to the master file; we have a generic\n # \"back to index\" link already\n parents.reverse()\n\n # title rendered as HTML\n title = self.env.longtitles.get(docname)\n title = title and self.render_partial(title)['title'] or ''\n # the name for the copied source\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\n\n # metadata for the document\n meta = self.env.metadata.get(docname)\n\n # local TOC and global TOC tree\n self_toc = self.env.get_toc_for(docname, self)\n toc = self.render_partial(self_toc)['fragment']\n\n return dict(\n parents = parents,\n prev = prev,\n next = next,\n title = title,\n meta = meta,\n body = body,\n metatags = metatags,\n rellinks = rellinks,\n sourcename = sourcename,\n toc = toc,\n # only display a TOC if there's more than one item to show\n display_toc = (self.env.toc_num_entries[docname] > 1),\n )","def foreign_get(object, item):\n if object is None or object is Null:\n return None\n try:\n if isinstance(object, (list, tuple)):\n item = int(item)\n return foreign_translate(object[item])\n except (KeyError, IndexError):\n return None","def context(self, tokens, index, history):\n return tokens[index - 1] if index else None","def _context():\n global _trident_context\n if _trident_context is None:\n _trident_context = _Context()\n return _trident_context","def get_contextual(old_windows, is_fatal=True):\n\n c = [w for w in Gtk.Window.list_toplevels() if w not in\n old_windows and w.get_mapped()]\n if not c:\n if is_fatal:\n gps_fatal_error('No contextual menu created')\n return None\n return c[0]","def getContext(editor):\n hou_context = editor.pwd().childTypeCategory().name()\n if hou_context == 'Sop':\n return 'SOP'\n elif hou_context == 'Dop':\n return 'DOP'\n elif hou_context == 'Object':\n return 'OBJ'\n elif hou_context == 'Driver':\n return 'ROP'\n elif hou_context == 'Chop':\n return 'CHOP'\n elif hou_context == 'Vop':\n return 'VOP'\n elif hou_context == 'Shop':\n return 'SHOP'\n elif hou_context == 'Cop2':\n return 'COP'","def provide_context(self) -> Optional[Dict[Text, Any]]:","def __getitem__(self, item):\n # check if it's implicitly a furanose\n furanose = item in [\"ERY\", \"THRE\", \"RUL\", \"XUL\", \"XLU\", \"ACE\"]\n\n # remove lactole identifier from name and store flag for furanoses\n if item[-1] == \"p\" and not item.endswith(\"Hep\"):\n item = item[:-1]\n if item[-1] == \"f\":\n item = item[:-1]\n furanose = True\n\n # look the structure up and raise an error if it's not contained\n if furanose and item in self.furanose_fac:\n return self.furanose_fac[item]\n if not furanose and item in self.pyranose_fac:\n return self.pyranose_fac[item]\n if item in self.open_fac:\n return self.open_fac[item]\n raise NotImplementedError(\"Query-monosaccharide is neither in pyranoses nor in furanoses.\")","def locateObjLocation(data, questionDict, questionIdict):\n where = questionDict['where']\n for t in range(data.shape[0] - 1):\n if data[t, 0] == where:\n for u in range(t + 1, data.shape[0]):\n word = questionIdict[data[u, 0] - 1]\n lexname = lookupLexname(word)\n if (lexname is not None and \\\n lexname.startswith('noun')) or \\\n (lexname is None):\n return data[u, 0]\n print 'not found'\n return data[-1, 0]","def _resolve_type_from_context(self, cr, uid, context=None):\n if context is None:\n context = {}\n return context.get('default_type')","def get_document_context(context):\n document_types = {\n 'transcript': 'transcript',\n 'opening_statement_chair': 'chair opening statement',\n 'opening_statement_rm': 'ranking member opening statement',\n }\n\n eventdocuments_qs = EventDocument.objects.filter(\n event_id=context['hearing']\n )\n\n for key, value in document_types.items():\n try:\n doc = eventdocuments_qs.get(note=value)\n context[key] = EventDocumentLink.objects.exclude(\n text='archived'\n ).filter(\n document_id=doc\n )[0].url\n except (ObjectDoesNotExist):\n context[key] = None\n\n try:\n context[key + '_archived'] = EventDocumentLink.objects.get(\n document_id=doc,\n text='archived'\n ).url\n except (ObjectDoesNotExist, UnboundLocalError):\n pass\n\n return context","def contexts( # type: ignore[override]\n self, triple: Optional[\"_TripleType\"] = None\n ) -> Generator[\"_ContextIdentifierType\", None, None]:\n\n if triple:\n nts = self.node_to_sparql\n s, p, o = triple\n params = (\n nts(s if s else Variable(\"s\")),\n nts(p if p else Variable(\"p\")),\n nts(o if o else Variable(\"o\")),\n )\n q = \"SELECT ?name WHERE { GRAPH ?name { %s %s %s }}\" % params\n else:\n q = \"SELECT ?name WHERE { GRAPH ?name {} }\"\n\n result = self._query(q)\n # type error: Item \"bool\" of \"Union[Tuple[Node, Node, Node], bool, ResultRow]\" has no attribute \"name\"\n # error: Generator has incompatible item type \"Union[Any, Identifier]\"; expected \"IdentifiedNode\"\n return (row.name for row in result) # type: ignore[union-attr,misc]","def get_context(host='localhost', port=2002, find_uno=find_ooo.find_uno):\n\n uno = find_uno()\n localctx = uno.getComponentContext()\n create_instance = localctx.getServiceManager().createInstanceWithContext\n\n resolver_class = \"com.sun.star.bridge.UnoUrlResolver\"\n resolver = create_instance(resolver_class, localctx)\n\n # http://udk.openoffice.org/common/man/spec/uno-url.html\n context_url = (\"uno:socket,host={host},port={port};\"\n \"urp;StarOffice.ComponentContext\".format)\n\n return resolver.resolve(context_url(host=host, port=port))","def __getitem__(self, alt_loc):\n assert isinstance(alt_loc, str)\n\n if self.altloc is None:\n if self.alt_loc == alt_loc:\n return self\n raise KeyError, alt_loc\n\n else:\n return self.altloc[alt_loc]","def _compute_context_for_item(item):\n source_text = [None, None, None]\n reference_text = [None, None, None]\n \n left_context = RankingTask.objects.filter(hit=item.hit, pk=item.id-1)\n right_context = RankingTask.objects.filter(hit=item.hit, pk=item.id+1)\n \n _item_doc_id = getattr(item.attributes, 'doc-id', None)\n \n # Item text and, if available, reference text are always set.\n source_text[1] = item.source[0]\n if item.reference:\n reference_text[1] = item.reference[0]\n \n # Only display context if left/right doc-ids match current item's doc-id.\n if left_context:\n _left = left_context[0]\n _left_doc_id = getattr(_left.attributes, 'doc-id', None)\n \n if _left_doc_id == _item_doc_id:\n source_text[0] = _left.source[0]\n if _left.reference:\n reference_text[0] = _left.reference[0]\n \n if right_context:\n _right = right_context[0]\n _right_doc_id = getattr(_right.attributes, 'doc-id', None)\n \n if _right_doc_id == _item_doc_id:\n source_text[2] = _right.source[0]\n if _right.reference:\n reference_text[2] = _right.reference[0]\n \n return (source_text, reference_text)","def compute_applied_name_contexts(citelist: list) -> None:\n for i, cite in enumerate(citelist):\n if (cite.context == \"specimen\") or (cite.context == \"location\") or (cite.context == \"sequence\"):\n cite.applied_cites = {cite}\n elif cite.context == \"citation\":\n for j in range(i): # only look at entries up to the current one\n tmp = citelist[j]\n if (tmp.cite_key == cite.application) and match_num_ref(tmp.name_key, cite.cite_n):\n if (tmp.context == \"specimen\") or (tmp.context == \"location\") or (tmp.context == \"sequence\"):\n cite.applied_cites |= {tmp}\n if len(cite.applied_cites) == 0:\n cite.applied_cites = None\n\n # for testing purposes only\n # if cite.applied_cites is None:\n # print(cite.cite_key, cite.name_key, cite.context, \"No application\")\n # else:\n # for c in cite.applied_cites:\n # print(cite.cite_key, cite.name_key, cite.context, c.cite_key, c.name_key, c.context)\n # input()","def _resolve(self, csub, c, direction):\n\t# By default, no way to resolve\n\treturn None","def lookup(index,keyword):\n\tif keyword in index:\n\t\treturn index[keyword]\n\treturn None","def get_prefix_with_context(model, context):\n\n model_keys = list(model.keys())\n\n # Some light cleanup.\n context = context.replace(\"?\", \"\").replace(\"!\", \"\").replace(\".\", \"\")\n context_keywords = list(set(context.split()))\n\n # we remove stop words from the context.\n # We use reversed() to remove items from the list without affecting the sequence.\n for word in reversed(context_keywords):\n\n if len(word) <= 3 or word in STOP_WORDS:\n context_keywords.remove(word)\n\n # If our context has no keywords left we return a random prefix.\n if len(context_keywords) == 0:\n return get_prefix(model_keys)\n\n # We are going to sample one prefix for each available keyword and return only one.\n random.shuffle(model_keys)\n sampled_prefixes = list()\n\n for word in context_keywords:\n\n for prefix in model_keys:\n\n if word in prefix or word.lower() in prefix or word.title() in prefix:\n\n if \"?\" not in prefix or \"!\" not in prefix or \".\" not in prefix:\n sampled_prefixes.append(prefix)\n break\n\n # If we don't get any samples we fallback to the random prefix method.\n if len(sampled_prefixes) == 0:\n return get_prefix(model_keys)\n else:\n return random.choice(sampled_prefixes)","def lookup(name, frame, locals):\n if name in locals:\n return 'local', locals[name]\n if name in frame.f_globals:\n return 'global', frame.f_globals[name]\n if '__builtins__' in frame.f_globals:\n builtins = frame.f_globals['__builtins__']\n if isinstance(builtins, type({})):\n if name in builtins:\n return 'builtin', builtins[name]\n else:\n if hasattr(builtins, name):\n return 'builtin', getattr(builtins, name)\n return None, __UNDEF__","def get_context(self):\r\n ctx = {}\r\n for clause in self.where_clauses or []:\r\n clause.update_context(ctx)\r\n return ctx","def lookup(*args):\n lemma, results = etym(*args)\n languages = nest()\n if not results:\n query, _, dictionary = args\n lemma, results = etym(query, None, dictionary)\n for result in results:\n languages[lemma][unicode(result['pos'])] = result['languages']\n return languages","def _get_concordance(self, vocabulary_uri: str = None) -> Optional[_Concordance]:\n\n # get the correct source (if any) given vocabulary_name:\n vocabulary = None\n if vocabulary_uri is None:\n vocabulary = self._sources[0]\n else:\n for source in self._sources:\n if source.uri == vocabulary_uri:\n vocabulary = source\n if vocabulary is None:\n print(\"The selected vocabulary does not exist!\")\n return None\n\n # make the best vector (on which the ranking of self._vocabularies is based):\n best_vector = _Analysis.make_best_vector(vocabulary.levenshtein_vector, self._sensitivity)\n\n # make concordance:\n source_scheme = self._scheme\n target_scheme = _ConceptScheme(uri=vocabulary.uri)\n concordance = _Concordance(from_scheme=source_scheme, to_scheme=target_scheme, mappings=set())\n\n # make concept mappings:\n for score in best_vector.get_vector():\n source_concept = score.comparandum\n target_concept = score.comparans.get_concept()\n source_member_set = {source_concept}\n target_member_set = {target_concept}\n source_bundle = _ConceptBundle(member_set=source_member_set)\n target_bundle = _ConceptBundle(member_set=target_member_set)\n\n mapping = _ConceptMapping(from_=source_bundle,\n to=target_bundle,\n from_scheme=source_scheme,\n to_scheme=target_scheme)\n\n concordance.mappings.add(mapping)\n\n return concordance","def getcategory_context(self,category):\r\n return self[category]","def get_xfrm(name):\r\n for x in xfrms:\r\n if x.name == name:\r\n return x\r\n return None","def context(self, context):\n if context is not None and not re.search(r'^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=)?$', context): # noqa: E501\n raise ValueError(r\"Invalid value for `context`, must be a follow pattern or equal to `/^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=)?$/`\") # noqa: E501\n\n self._context = context","def get_doc_context(self, docname, body, metatags):\n\n # find out relations\n prev = next = None\n parents = []\n rellinks = self.globalcontext['rellinks'][:]\n related = self.relations.get(docname)\n # Populate titles with the list of longtitles from the env instead of titles\n # titles = self.env.titles\n titles = self.env.longtitles\n if related and related[2]:\n try:\n next = {\n 'link': self.get_relative_uri(docname, related[2]),\n 'title': self.render_partial(titles[related[2]])['title']\n }\n rellinks.append((related[2], next['title'], 'N', _('next')))\n except KeyError:\n next = None\n if related and related[1]:\n try:\n prev = {\n 'link': self.get_relative_uri(docname, related[1]),\n 'title': self.render_partial(titles[related[1]])['title']\n }\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\n except KeyError:\n # the relation is (somehow) not in the TOC tree, handle\n # that gracefully\n prev = None\n while related and related[0]:\n try:\n parents.append(\n {'link': self.get_relative_uri(docname, related[0]),\n 'title': self.render_partial(titles[related[0]])['title']})\n except KeyError:\n pass\n related = self.relations.get(related[0])\n if parents:\n parents.pop() # remove link to the master file; we have a generic\n # \"back to index\" link already\n parents.reverse()\n\n # title rendered as HTML\n title = self.env.longtitles.get(docname)\n title = title and self.render_partial(title)['title'] or ''\n # the name for the copied source\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\n\n # metadata for the document\n meta = self.env.metadata.get(docname)\n\n # local TOC and global TOC tree\n self_toc = self.env.get_toc_for(docname, self)\n toc = self.render_partial(self_toc)['fragment']\n\n return dict(\n parents = parents,\n prev = prev,\n next = next,\n title = title,\n meta = meta,\n body = body,\n metatags = metatags,\n rellinks = rellinks,\n sourcename = sourcename,\n toc = toc,\n # only display a TOC if there's more than one item to show\n display_toc = (self.env.toc_num_entries[docname] > 1),\n )","def get_context(self, max_frames=None, missing_entities=None):\n missing_entities = missing_entities or []\n\n relevant_frames = [frame[0] for frame in self.frame_stack if\n time.time() - frame[1] < self.timeout]\n if not max_frames or max_frames > len(relevant_frames):\n max_frames = len(relevant_frames)\n\n missing_entities = list(missing_entities)\n context = []\n last = ''\n depth = 0\n entity = {}\n for i in range(max_frames):\n frame_entities = [entity.copy() for entity in\n relevant_frames[i].entities]\n for entity in frame_entities:\n entity['confidence'] = entity.get('confidence', 1.0) \\\n / (2.0 + depth)\n context += frame_entities\n\n # Update depth\n if entity['origin'] != last or entity['origin'] == '':\n depth += 1\n last = entity['origin']\n\n result = []\n if missing_entities:\n for entity in context:\n if entity.get('data') in missing_entities:\n result.append(entity)\n # NOTE: this implies that we will only ever get one\n # of an entity kind from context, unless specified\n # multiple times in missing_entities. Cannot get\n # an arbitrary number of an entity kind.\n missing_entities.remove(entity.get('data'))\n else:\n result = context\n\n # Only use the latest keyword\n return _strip_result(result)","def getContext(namespace):","def _findAltOpts(self, lookupword):\n if self.allwords == []:\n # on first call of _findAltOpts()\n # create a list of all the words contained in the database\n with sqlite3.connect(self.dbpath) as conn:\n cursor = conn.cursor()\n cursor.execute('SELECT word FROM words')\n allwords = cursor.fetchall()\n self.allwords = tools.listOfTuplesToList(allwords)\n\n # to collect words that have the longest common\n # substrings with the lookupword\n altopts = []\n # lengths[i] is the length of the longest common\n # substring of altopts[i] and the lookupword\n lengths = []\n\n for word in self.allwords:\n match = SequenceMatcher(None,\n lookupword,\n word\n ).find_longest_match(0, len(lookupword),\n 0, len(word))\n\n if len(altopts) < self.altsmax and match.size >= 3:\n altopts.append(word)\n lengths.append(match.size)\n elif lengths != [] and match.size > lengths[-1]:\n # current word is a better match than the last item of altopts\n # insert the word into altopts and delete the altopts last item\n for i in range(len(lengths)):\n if lengths[i] < match.size:\n index = i\n altopts.insert(index, word)\n lengths.insert(index, match.size)\n del altopts[-1]\n del lengths[-1]\n return altopts","def lookup_concept(wikidataId):\n\n if cfg.USE_CACHE:\n if (wikidataId in LOOKUP_DICT):\n return LOOKUP_DICT[wikidataId]\n \n response_json = wa.request_entity_fishing_concept_lookup(wikidataId)\n \n if not response_json:\n return nan\n\n if 'statements' not in response_json.keys():\n return nan\n\n for statement in response_json['statements']:\n if statement['propertyId'] == 'P1566':\n logger.debug('GeoNamesID found for %s: %s', wikidataId, statement['value'])\n if cfg.USE_CACHE:\n LOOKUP_DICT[wikidataId] = statement['value']\n return statement['value']\n\n \n return nan","def get_ctxt(self, id):\n id = id_force_tuple(id)\n ctxt = {}\n for v in self.vars:\n ctxt[v.name] = v.T\n\n prf = self.prf\n try:\n for n in id:\n for item in prf.items[:n+1]:\n if item.rule == \"variable\":\n nm, T = item.args\n ctxt[nm] = T\n prf = prf.items[n].subproof\n return ctxt\n except (AttributeError, IndexError):\n raise TacticException()","def __getitem__(self, ref):\n for concept in self.concepts:\n if concept.match_ref(ref):\n return concept\n raise KeyError()","def locate(cls):\r\n if not cls._active:\r\n raise cls.ContextError('No parse context active.')\r\n return next(reversed(cls._active))","def detect_robot_context(code: str, cursor_pos: int):\n code = code[:cursor_pos]\n line = code.rsplit(\"\\n\")[-1]\n context_parts = code.rsplit(\"***\", 2)\n if len(context_parts) != 3:\n return \"__root__\"\n else:\n context_name = context_parts[1].strip().lower()\n if context_name == \"settings\":\n return \"__settings__\"\n elif line.lstrip() == line:\n return \"__root__\"\n elif context_name in [\"tasks\", \"test cases\"]:\n return \"__tasks__\"\n elif context_name == \"keywords\":\n return \"__keywords__\"\n else:\n return \"__root__\"","def scope_context(self):\n if self._course_id:\n return 'COURSE'\n elif self._partner_id:\n return 'PARTNER'\n elif self._group_id:\n return 'GROUP'\n else:\n return None","def get_default_context_cpl():\n ctx = {'py_make_float_array': py_make_float_array,\n 'py_pow': py_pow, 'py_mul': py_mul, 'py_opp': py_opp,\n 'numpy': numpy}\n try:\n from skl2onnx.algebra.complex_functions import onnx_squareform_pdist # delayed\n from skl2onnx.algebra.complex_functions import onnx_cdist # delayed\n ctx['onnx_squareform_pdist'] = onnx_squareform_pdist\n ctx['onnx_cdist'] = onnx_cdist\n except ImportError: # pragma: no cover\n # Too old version for skl2onnx.\n pass\n\n from skl2onnx.algebra import onnx_ops # delayed\n from skl2onnx.algebra.onnx_operator import OnnxOperator # delayed\n d = onnx_ops.__dict__\n for k, v in d.items():\n try:\n if k.startswith(\"Onnx\") and issubclass(v, OnnxOperator):\n ctx[k] = v\n except TypeError as e:\n if inspect.isfunction(v):\n continue\n raise RuntimeError( # pragma: no cover\n f\"Issue with {k}={v} (type={type(v)})\") from e\n return ctx","def _get_answer(context, context_words, answer_start, answer_end):\n context = context.decode('utf-8')\n context_words = [word.decode('utf-8') for word in context_words]\n pos = 0\n answer_start_char = None\n answer_end_char = None\n for i, word in enumerate(context_words):\n pos = context.index(word, pos)\n if answer_start == i:\n answer_start_char = pos\n pos += len(word)\n if answer_end == i:\n answer_end_char = pos\n break\n assert answer_start_char is not None, (\n '`answer_start` is not found in context. '\n 'context=`%s`, context_words=`%r`, '\n 'answer_start=%d, answer_end=%d') % (context, context_words, answer_start,\n answer_end)\n assert answer_end_char is not None, (\n '`answer_end` is not found in context. '\n 'context=`%s`, context_words=`%r`, '\n 'answer_start=%d, answer_end=%d') % (context, context_words, answer_start,\n answer_end)\n answer = context[answer_start_char:answer_end_char].encode('utf-8')\n return answer","def test_context_corpus_iter(self):\n contexts = {1:{0, 1, 2, 3}, 2:{3, 4, 5}, 3:{10}}\n cc = ContextCorpus(contexts)\n line = list(next(cc.__iter__()))\n context = int(line[0].replace('C', ''))\n examples = contexts[context]\n good = all((int(i.replace('I', '')) in examples for i in line[1:]))\n self.assertTrue(good)","def __getitem__(self, item):\n return foreign_get(self.vars, item)","def get_catalog_lookup_session(self):\n raise Unimplemented()","def context(self) -> _C_out:\n return self._context","def resolve_anyref(\n self, refdoc: str, node: pending_xref, contnode: Element,\n ) -> Element | None:\n stddomain = self.env.get_domain('std')\n target = node['reftarget']\n results: list[tuple[str, Element]] = []\n # first, try resolving as :doc:\n doc_ref = stddomain.resolve_xref(self.env, refdoc, self.app.builder,\n 'doc', target, node, contnode)\n if doc_ref:\n results.append(('doc', doc_ref))\n # next, do the standard domain (makes this a priority)\n results.extend(stddomain.resolve_any_xref(self.env, refdoc, self.app.builder,\n target, node, contnode))\n for domain in self.env.domains.values():\n if domain.name == 'std':\n continue # we did this one already\n try:\n results.extend(domain.resolve_any_xref(self.env, refdoc, self.app.builder,\n target, node, contnode))\n except NotImplementedError:\n # the domain doesn't yet support the new interface\n # we have to manually collect possible references (SLOW)\n for role in domain.roles:\n res = domain.resolve_xref(self.env, refdoc, self.app.builder,\n role, target, node, contnode)\n if res and len(res) > 0 and isinstance(res[0], nodes.Element):\n results.append((f'{domain.name}:{role}', res))\n # now, see how many matches we got...\n if not results:\n return None\n if len(results) > 1:\n def stringify(name: str, node: Element) -> str:\n reftitle = node.get('reftitle', node.astext())\n return f':{name}:`{reftitle}`'\n candidates = ' or '.join(stringify(name, role) for name, role in results)\n logger.warning(__(\"more than one target found for 'any' cross-\"\n 'reference %r: could be %s'), target, candidates,\n location=node)\n res_role, newnode = results[0]\n # Override \"any\" class with the actual role type to get the styling\n # approximately correct.\n res_domain = res_role.split(':')[0]\n if (len(newnode) > 0 and\n isinstance(newnode[0], nodes.Element) and\n newnode[0].get('classes')):\n newnode[0]['classes'].append(res_domain)\n newnode[0]['classes'].append(res_role.replace(':', '-'))\n return newnode","def find(self, op):\n # return the environment itself so that invoker can update information\n # in specific environment\n if op in self:\n return self\n if self._outer is None:\n raise LookupError('unbound '+op)\n return self._outer.find(op)","def sdcToClassifier_keyword(self, sdc):\n for srname, engine in self.engineMap.iteritems():\n if(srname in sdc[\"spatialRelation\"].text):\n return engine\n return None","def context(self) -> Optional[str]:\n displayed_line = self.editor_line\n displayed_column = self.editor_column\n # we want to avoid displaying a blank line for context. If we're on a blank line\n # find the nearest line above us that isn't blank.\n while displayed_line >= 1 and not len(self._lines[displayed_line - 1].strip()):\n displayed_line -= 1\n displayed_column = len(self._lines[displayed_line - 1])\n\n # only show context if we managed to find a non-empty line\n if len(self._lines[displayed_line - 1].strip()):\n formatted_source_line = expand_tabs(self._lines[displayed_line - 1]).rstrip(\n _NEWLINE_CHARS\n )\n # fmt: off\n return (\n f\"{formatted_source_line}\\n\"\n + f\"{' ' * (displayed_column - 1)}^\"\n )\n # fmt: on\n else:\n return None","def getSourceForId(context, identifier):\n nearest = getattr(context, identifier, None)\n if IExternalSource.providedBy(nearest):\n return nearest\n return None","def __getitem__(self, key):\n for db in self.db:\n if db.name == key:\n return db\n raise IndexError","def add_place_predicate_context(task: SynthesisTask, grammar: CFG):\n\n if 'processed' not in task.context:\n task.context['processed'] = set()\n\n processed_strs = task.context['processed']\n new_strings = [s for s in task.pos_str_context + task.neg_str_context if s.s not in processed_strs]\n if len(new_strings) == 0:\n return\n\n processed_strs.update([s.s for s in new_strings])\n\n if task.no_context:\n\n regions_in_grammar = grammar.get_terminal_sym('REGION').values\n relevant_regions = []\n for region in regions_in_grammar:\n if any([check_regions(s.s, [region]) for s in new_strings]):\n relevant_regions.append(region)\n\n task.context['inRegion'] = relevant_regions\n\n countries_in_grammar = grammar.get_terminal_sym('COUNTRY').values\n relevant_countries = []\n for country in countries_in_grammar:\n if any([check_countries(s.s, [country]) for s in new_strings]):\n relevant_countries.append(country)\n\n task.context['inCountry'] = relevant_countries\n\n task.context['inState'] = grammar.get_terminal_sym('STATE').values\n else:\n\n def find_entity(ty: str) -> List[str]:\n relevant_entity = []\n for s_ctx in new_strings:\n for span_ctx in s_ctx.str_span_to_predicate_context.values():\n if ty in span_ctx and span_ctx.get(ty) not in relevant_entity:\n relevant_entity.extend(span_ctx.get(ty))\n return list(set(relevant_entity))\n\n task.context['inRegion'] = find_entity('region')\n task.context['inCountry'] = find_entity('country')\n task.context['inState'] = find_entity('state')","def _lookup(self, key):\n\n if key in self.position and key in self.info:\n # If the key exists in both position and info, treat it as a list to intersect.\n return self._skill_list(key)\n if key in self.position:\n return self.position[key]\n if key in self.info:\n return self.info[key]\n\n raise KeyError(f\"Invalid Key: {key}\")","def _get(context, namespace_name, resource_type_name,\n namespace_id, resource_type_id, session):\n\n # visibility check assumed done in calling routine via namespace_get\n try:\n query = session.query(models.MetadefNamespaceResourceType).filter_by(\n namespace_id=namespace_id, resource_type_id=resource_type_id)\n db_rec = query.one()\n except sa_orm.exc.NoResultFound:\n LOG.debug(\"The metadata definition resource-type association of\"\n \" resource_type=%(resource_type_name)s to\"\n \" namespace_name=%(namespace_name)s was not found.\",\n {'resource_type_name': resource_type_name,\n 'namespace_name': namespace_name})\n raise exc.MetadefResourceTypeAssociationNotFound(\n resource_type_name=resource_type_name,\n namespace_name=namespace_name)\n\n return db_rec","def _resolve_section_id_from_context(self, cr, uid, context=None):\n if context is None:\n context = {}\n if type(context.get('default_section_id')) in (int, long):\n return context.get('default_section_id')\n if isinstance(context.get('default_section_id'), basestring):\n section_name = context['default_section_id']\n section_ids = self.pool.get('crm.case.section').name_search(cr, uid, name=section_name, context=context)\n if len(section_ids) == 1:\n return int(section_ids[0][0])\n return None","def lookup(conn, language_code, graphic, phonetic, restrictions):\n c = conn.cursor()\n entry_ids = tuple(c.execute('SELECT entry_id FROM lemmas WHERE language = ? AND graphic = ? and phonetic = ?', (language_code, graphic, hiragana_to_katakana(phonetic))))\n return tuple(Lexeme(conn, language_code, entry_id, restrictions) for (entry_id,) in entry_ids)","def assemblyContext(self):\n return fusion.Occurrence()","def _is_contextual(self, graph: Optional[Union[\"Graph\", \"str\"]]) -> bool:\n if (not self.context_aware) or (graph is None):\n return False\n if isinstance(graph, str):\n return graph != \"__UNION__\"\n else:\n return graph.identifier != DATASET_DEFAULT_GRAPH_ID","def context_get():\n global __context\n if __context is None:\n __context = Context()\n return __context","def find(context, alias):\n if not hasattr(context, \"config\"):\n return None\n\n expansion = context.config.get(ALIAS_SECTION, alias)\n return expansion.split(' ') if expansion else None","def _test_word(query_word, query_context):\n assert(not query_word.is_at_var)\n engine = query_context._engine\n # TODO: validate on activate context too\n alphas, betas, regexs, annotations = validate_and_split_constraints(query_word, engine=engine)\n callable_annotations = [word for word in annotations if hasattr(word, \"__call__\")]\n data_set = {word : d for word,d in enumerate(query_context.pairs())}\n pairs = enumerate(query_context.pairs())\n query_context.clear()\n\n\n potentials = [(i, d[0], passing) for i,d in pairs for passing in retrieve_potentials(query_word, d)]\n # Apply Tests\n # TODO: test type instance if not ATOM\n passing = [run_subbinds(n, regexs, d, i) for i,d,n in potentials\n if test_alphas(n, alphas, d, engine=engine)\n and test_betas(n, betas, d, engine=engine)\n and test_annotations(n, callable_annotations, d, engine)]\n\n to_add = [add_var_to_context(i, query_word, d, n) for i,d,n in passing if n is not None]\n\n query_context.append(*to_add, fail_dict=data_set)\n return annotations","def make_context(self, engine, args):\n args = self.normalize_args(args)\n _, ctx = self._make_argkey_and_context(engine, args)\n return ctx","def locate(self, interface, depth=1, _default=object()):\n key = qual(interface)\n currentContext = self\n while True:\n if depth < 0:\n full = []\n while True:\n try:\n full.append(self.locate(interface, len(full)+1))\n except KeyError:\n break\n #print \"full\", full, depth\n if full:\n return full[depth]\n return None\n\n # Hook for FactoryContext and other implementations of complex locating\n locateHook = currentContext.locateHook\n if locateHook is not None:\n result = locateHook(interface)\n if result is not None:\n return result\n\n _remembrances = currentContext._remembrances\n if _remembrances is not None:\n rememberedValue = _remembrances.get(key, _default)\n if rememberedValue is not _default:\n depth -= 1\n if not depth:\n return rememberedValue\n\n contextParent = currentContext.parent\n if contextParent is None:\n raise KeyError, \"Interface %s was not remembered.\" % key\n\n currentContext = contextParent","def set_adapt_context(self, context, word, origin):\n self.bus.emit(Message('add_context',\n {'context': context, 'word': word,\n 'origin': origin}))","def lookup(self):\n return self._lookup","def lookup(self, key):","def section(self, context):\n registry = queryUtility(IRegistry)\n if registry is None:\n return None\n if registry.get('plone.subjects_of_navigation_root', False):\n portal = getToolByName(context, 'portal_url').getPortalObject()\n return getNavigationRootObject(context, portal)\n return None","def get(key, domain=None, language=None, context=None):\n\n return intuition.get(key, domain, language, context)","def extract_context(words, mask_index, window):\n total_length = len(words)\n half_window = int(window / 2)\n assert 0 <= mask_index < total_length\n return words[max(0, mask_index - half_window):min(total_length, mask_index + half_window + 1)]","def _key_from_context(self, ctx, tag_name):\n tag_context = self.get_tag_context(ctx, tag_name)\n if tag_context:\n if tag_context == \"global\":\n return \"config:tags:global\"\n elif tag_context == \"chan\":\n return \"chan:{}:tags\".format(ctx.message.channel.id)\n elif tag_context == \"guild\":\n return \"guild:{}:tags\".format(ctx.message.guild.id)\n else:\n return None","def edge_lookup(self, keylookup_obj, id_strct, debug=False):\n # pylint: disable=E1102, R0201, W0613\n yield NotImplemented(\"This method must be overridden by the base class.\")","def category(self):\n\n for category, match_list in rule_list:\n for match in match_list:\n if match.match(self):\n return category\n\n return None","def __getitem__(self, name):\n return self.current_scope[name]","def get_context_data(instance):\n # type: (Dict[str, Any]) -> Tuple[Optional[OctetString], str]\n context_engine_id = None\n context_name = ''\n\n if 'user' in instance:\n if 'context_engine_id' in instance:\n context_engine_id = OctetString(instance['context_engine_id'])\n\n if 'context_name' in instance:\n context_name = instance['context_name']\n\n return context_engine_id, context_name","def definition_context(self):\n return self.__context","def codrspace_contexts(request):\n contexts = {}\n contexts.update({\n 'TAGLINE': \"Why you no write tutorial?\"\n })\n\n return contexts"],"string":"[\n \"def __dis_context__(self, context, word):\\n senses = self.vs.get_senses(word, self.ignore_case)\\n if self.verbose:\\n print(\\\"Senses of a target word:\\\")\\n print(senses)\\n\\n if len(senses) == 0: # means we don't know any sense for this word\\n return None\\n\\n # collect context vectors\\n vctx = [self.vc[c] for c in context]\\n\\n if len(vctx) == 0: # means we have no context\\n return None\\n # TODO: better return most frequent sense or make random choice\\n\\n # filter context vectors, if aplicable\\n if self.filter_ctx >= 0:\\n vctx = self.__filter__(vctx, senses, self.filter_ctx)\\n\\n if self.ctx_method == 'prob':\\n avg_context = np.mean(vctx, axis=0)\\n scores = [self.__logprob__(avg_context, self.vs[sense]) for sense, prob in senses]\\n\\n elif self.ctx_method == 'sim':\\n avg_context = np.mean(vctx, axis=0)\\n scores = [self.__cosine_sim__(avg_context, self.vs[sense]) for sense, prob in senses]\\n if self.verbose:\\n print(\\\"Sense probabilities:\\\")\\n print(scores)\\n\\n else:\\n raise ValueError(\\\"Unknown context handling method '%s'\\\" % self.ctx_method)\\n\\n # return sense (word#id), scores for senses\\n return senses[np.argmax(scores)][0], scores\",\n \"def _plug_from_context(self):\\n children = self.smartplug.sys_info[\\\"children\\\"]\\n return next(c for c in children if c[\\\"id\\\"] == self.smartplug.context)\",\n \"def get_context(self):\\n symbol_chain = self.split_completion_object(self.get_word_before())\\n current_rs_object = self.module\\n\\n for symbol in symbol_chain:\\n try:\\n current_rs_object = current_rs_object.get_object(symbol)\\n logging.info(f\\\"New context found: {current_rs_object.name}\\\")\\n except:\\n logging.error(f\\\"{type(current_rs_object)} has no method get_object yet.\\\")\\n return current_rs_object\\n\\n return current_rs_object\",\n \"def _resolve_context(r, tablename, context):\\n\\n record_id = r.id\\n if not record_id:\\n return None\\n\\n if not context:\\n query = None\\n\\n elif type(context) is tuple:\\n context, field = context\\n query = (FS(context) == r.record[field])\\n\\n elif context == \\\"location\\\":\\n # Show records linked to this Location & all it's Child Locations\\n s = \\\"(location)$path\\\"\\n # This version doesn't serialize_url\\n #m = (\\\"%(id)s/*,*/%(id)s/*\\\" % dict(id=id)).split(\\\",\\\")\\n #filter = (FS(s).like(m)) | (FS(s) == id)\\n m = (\\\"%(id)s,%(id)s/*,*/%(id)s/*,*/%(id)s\\\" % dict(id=record_id)).split(\\\",\\\")\\n m = [f.replace(\\\"*\\\", \\\"%\\\") for f in m]\\n query = (FS(s).like(m))\\n # @ToDo:\\n #elif context == \\\"organisation\\\":\\n # # Show records linked to this Organisation and all it's Branches\\n # s = \\\"(%s)\\\" % context\\n # query = (FS(s) == id)\\n else:\\n # Normal: show just records linked directly to this master resource\\n s = \\\"(%s)\\\" % context\\n query = (FS(s) == record_id)\\n\\n # Define target resource\\n resource = current.s3db.resource(tablename, filter=query)\\n r.customise_resource(tablename)\\n return resource, query\",\n \"def _repair_context(self, context):\\n\\n if isinstance(context, Graph):\\n return self._repair_context(context.identifier)\\n elif isinstance(context, URIRef):\\n return context\\n else:\\n return NULL_CONTEXT\",\n \"def _find_context(\\n node: ast.AST,\\n contexts: Tuple[Type[ast.AST], ...],\\n) -> Optional[ast.AST]:\\n parent = get_parent(node)\\n if parent is None:\\n return None\\n elif isinstance(parent, contexts):\\n return parent\\n return _find_context(parent, contexts)\",\n \"def set_context(self):\\n results = self.rml.query(\\\"\\\"\\\"\\n SELECT ?o {\\n {\\n ?s rr:class ?o\\n } UNION {\\n ?s rr:predicate ?o\\n }\\n }\\\"\\\"\\\")\\n namespaces = [Uri(row[0]).value[0]\\n for row in results\\n if isinstance(row[0], rdflib.URIRef)]\\n self.context = {ns[0]: ns[1] for ns in namespaces if ns[0]}\",\n \"def __getitem__(self, name):\\r\\n if name not in self.current_context:\\r\\n raise KeyError(\\\"Trying to use an undefined label!\\\")\\r\\n return self.current_context[name]\",\n \"def test_context2vec_context_similarity(self):\\n contexts = {1:{0, 1, 2, 3}, 2:{2, 3, 4, 5}, 3:{10}}\\n cc = ContextCorpus(contexts)\\n model = Word2Vec(cc, size=3, iter=1000, min_count=1, alpha=0.1, sg=0)\\n results = filter(lambda x: x[0].startswith('C'), model.most_similar('C1',\\n topn=100))\\n self.assertTrue(results[0][0] == 'C2')\",\n \"def get_from_context(cls, context):\\n obj = context.active_object\\n\\n if obj and obj.type not in {\\\"LAMP\\\", \\\"CAMERA\\\"}:\\n mat = obj.active_material\\n\\n if mat:\\n # ID pointer\\n node_tree = mat.appleseed.osl_node_tree\\n\\n if node_tree:\\n return node_tree, mat, mat\\n\\n elif obj and obj.type == \\\"LAMP\\\":\\n node_tree = obj.data.appleseed.osl_node_tree\\n\\n if node_tree:\\n return node_tree, None, None\\n\\n return None, None, None\",\n \"def resolve(self, context, safe=True, quiet=False):\\r\\n try:\\r\\n current = context\\r\\n for bit in self.bits:\\r\\n try: # dictionary lookup\\r\\n current = current[bit]\\r\\n except (TypeError, AttributeError, KeyError):\\r\\n try: # attribute lookup\\r\\n current = getattr(current, bit)\\r\\n except (TypeError, AttributeError):\\r\\n try: # list-index lookup\\r\\n current = current[int(bit)]\\r\\n except (IndexError, # list index out of range\\r\\n ValueError, # invalid literal for int()\\r\\n KeyError, # dict without `int(bit)` key\\r\\n TypeError, # unsubscriptable object\\r\\n ):\\r\\n raise ValueError('Failed lookup for key [%s] in %r'\\r\\n ', when resolving the accessor %s'\\r\\n % (bit, current, self))\\r\\n if callable(current):\\r\\n if safe and getattr(current, 'alters_data', False):\\r\\n raise ValueError('refusing to call %s() because `.alters_data = True`'\\r\\n % repr(current))\\r\\n current = current()\\r\\n # important that we break in None case, or a relationship\\r\\n # spanning across a null-key will raise an exception in the\\r\\n # next iteration, instead of defaulting.\\r\\n if current is None:\\r\\n break\\r\\n return current\\r\\n except:\\r\\n if not quiet:\\r\\n raise\",\n \"def __call__(self, context=None):\\n if context is None:\\n context = self.context\\n return self.entity.resolve(context)\",\n \"def get(self, key):\\n keystr = str(key)\\n res = None\\n\\n try:\\n res = self.ctx[keystr]\\n except KeyError:\\n for k, v in self.ctx.items():\\n if \\\"name\\\" in v and v[\\\"name\\\"].lower() == keystr.lower():\\n res = v\\n break\\n\\n return res\",\n \"def xontrib_context(name):\\n spec = find_xontrib(name)\\n if spec is None:\\n return None\\n m = importlib.import_module(spec.name)\\n pubnames = getattr(m, \\\"__all__\\\", None)\\n if pubnames is not None:\\n ctx = {k: getattr(m, k) for k in pubnames}\\n else:\\n ctx = {k: getattr(m, k) for k in dir(m) if not k.startswith(\\\"_\\\")}\\n return ctx\",\n \"def common_contexts(self, words, fail_on_unknown=False):\\n words = [self._key(w) for w in words]\\n contexts = [set(self._word_to_contexts[w]) for w in words]\\n empty = [words[i] for i in range(len(words)) if not contexts[i]]\\n common = reduce(set.intersection, contexts)\\n if empty and fail_on_unknown:\\n raise ValueError(\\\"The following word(s) were not found:\\\", \\\" \\\".join(words))\\n elif not common:\\n # nothing in common -- just return an empty freqdist.\\n return FreqDist()\\n else:\\n fd = FreqDist(\\n c for w in words for c in self._word_to_contexts[w] if c in common\\n )\\n return fd\",\n \"def currentCtx(*args, **kwargs)->AnyStr:\\n pass\",\n \"def ctx():\\n return None\",\n \"def open_context(self, description, shared=True):\\n\\n cu_name = description[\\\"cu_name\\\"]\\n context = self.contexts.get(cu_name)\\n if context:\\n return context[\\\"idx\\\"]\\n if _xrt_version >= (2, 6, 0):\\n cu_index = xrt.xclIPName2Index(self.handle, cu_name)\\n description[\\\"cu_index\\\"] = cu_index\\n else:\\n cu_index = description[\\\"cu_index\\\"]\\n\\n uuid = bytes.fromhex(description[\\\"xclbin_uuid\\\"])\\n uuid_ctypes = XrtUUID((ctypes.c_char * 16).from_buffer_copy(uuid))\\n err = xrt.xclOpenContext(self.handle, uuid_ctypes, cu_index, shared)\\n\\n if err:\\n raise RuntimeError(\\n \\\"Could not open CU context - {}, {}\\\".format(err, cu_index)\\n )\\n # Setup the execution context for the compute unit\\n self.contexts[cu_name] = {\\n \\\"cu\\\": cu_name,\\n \\\"idx\\\": cu_index,\\n \\\"uuid_ctypes\\\": uuid_ctypes,\\n \\\"shared\\\": shared,\\n }\\n\\n return cu_index\",\n \"def __getitem__(self, key):\\n try:\\n att = getattr(self, key)\\n return att\\n except AttributeError:\\n # mimic pylons context\\n return None\",\n \"def context(self) -> CONTEXT:\",\n \"def get_context(event):\\n for link in event.links.links:\\n if link.get(\\\"type\\\") == \\\"CONTEXT\\\":\\n context = link.get(\\\"target\\\")\\n break\\n else:\\n context = None\\n return context\",\n \"def lookup():\",\n \"def getQueryAnchor(self, context, metatype=None):\\n for o in list(context.aq_chain):\\n if IExtropyTracking.providedBy(o):\\n if metatype is None:\\n return o\\n elif hasattr(o,'meta_type') and metatype == o.meta_type:\\n return o\\n return getToolByName(self, 'portal_url').getPortalObject()\",\n \"def __getitem__(self, item):\\r\\n current = self\\r\\n while current is not None:\\r\\n if item in current.locals:\\r\\n return current.locals[item]\\r\\n current = current.parent\",\n \"def __contexts(\\n self, triple: \\\"_TripleType\\\"\\n ) -> Generator[\\\"_ContextType\\\", None, None]:\\n # type error: Argument 2 to \\\"get\\\" of \\\"Mapping\\\" has incompatible type \\\"str\\\"; expected \\\"Optional[Graph]\\\"\\n return (\\n self.__context_obj_map.get(ctx_str, ctx_str) # type: ignore[arg-type]\\n for ctx_str in self.__get_context_for_triple(triple, skipQuoted=True)\\n if ctx_str is not None\\n )\",\n \"def resolveContext(self, context):\\n if context is None:\\n return context\\n elif isinstance(context, tuple):\\n return context\\n elif isinstance(context, tuple):\\n return tuple(context.split('/'))\\n else:\\n return context.getPhysicalPath()\",\n \"def get_word_context(word):\\r\\n\\tfor content, profile in word_context_profile:\\r\\n\\t\\tif word == content:\\r\\n\\t\\t\\treturn profile \\r\\n\\treturn 0\",\n \"def get_doc_context(self, docname, body, metatags):\\n\\n # TYPO3: remove 'documentation' from end of 'shorttitle'\\n shorttitle = self.globalcontext.get('shorttitle', '')\\n if shorttitle and shorttitle.endswith(' documentation'):\\n shorttitle = shorttitle[0:-14].rstrip()\\n self.globalcontext['shorttitle'] = shorttitle\\n \\n\\n # find out relations\\n # TYPO3: always have order 'previous', 'up', 'next'\\n prev = up = next = None\\n parents = []\\n rellinks = self.globalcontext['rellinks'][:]\\n related = self.relations.get(docname)\\n titles = self.env.titles\\n if related and related[1]:\\n try:\\n prev = {\\n 'link': self.get_relative_uri(docname, related[1]),\\n 'title': self.render_partial(titles[related[1]])['title']\\n }\\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n if related and related[0]:\\n try:\\n up = {\\n 'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']\\n }\\n rellinks.append((related[0], up['title'], 'U', _('up')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n if related and related[2]:\\n try:\\n next = {\\n 'link': self.get_relative_uri(docname, related[2]),\\n 'title': self.render_partial(titles[related[2]])['title']\\n }\\n rellinks.append((related[2], next['title'], 'N', _('next')))\\n except KeyError:\\n next = None\\n while related and related[0]:\\n try:\\n parents.append(\\n {'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']})\\n except KeyError:\\n pass\\n related = self.relations.get(related[0])\\n if parents:\\n parents.pop() # remove link to the master file; we have a generic\\n # \\\"back to index\\\" link already\\n parents.reverse()\\n\\n # title rendered as HTML\\n title = self.env.longtitles.get(docname)\\n title = title and self.render_partial(title)['title'] or ''\\n # the name for the copied source\\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\\n\\n # metadata for the document\\n meta = self.env.metadata.get(docname)\\n\\n # local TOC and global TOC tree\\n self_toc = self.env.get_toc_for(docname, self)\\n toc = self.render_partial(self_toc)['fragment']\\n\\n return dict(\\n parents = parents,\\n prev = prev,\\n next = next,\\n title = title,\\n meta = meta,\\n body = body,\\n metatags = metatags,\\n rellinks = rellinks,\\n sourcename = sourcename,\\n toc = toc,\\n # only display a TOC if there's more than one item to show\\n display_toc = (self.env.toc_num_entries[docname] > 1),\\n )\",\n \"def foreign_get(object, item):\\n if object is None or object is Null:\\n return None\\n try:\\n if isinstance(object, (list, tuple)):\\n item = int(item)\\n return foreign_translate(object[item])\\n except (KeyError, IndexError):\\n return None\",\n \"def context(self, tokens, index, history):\\n return tokens[index - 1] if index else None\",\n \"def _context():\\n global _trident_context\\n if _trident_context is None:\\n _trident_context = _Context()\\n return _trident_context\",\n \"def get_contextual(old_windows, is_fatal=True):\\n\\n c = [w for w in Gtk.Window.list_toplevels() if w not in\\n old_windows and w.get_mapped()]\\n if not c:\\n if is_fatal:\\n gps_fatal_error('No contextual menu created')\\n return None\\n return c[0]\",\n \"def getContext(editor):\\n hou_context = editor.pwd().childTypeCategory().name()\\n if hou_context == 'Sop':\\n return 'SOP'\\n elif hou_context == 'Dop':\\n return 'DOP'\\n elif hou_context == 'Object':\\n return 'OBJ'\\n elif hou_context == 'Driver':\\n return 'ROP'\\n elif hou_context == 'Chop':\\n return 'CHOP'\\n elif hou_context == 'Vop':\\n return 'VOP'\\n elif hou_context == 'Shop':\\n return 'SHOP'\\n elif hou_context == 'Cop2':\\n return 'COP'\",\n \"def provide_context(self) -> Optional[Dict[Text, Any]]:\",\n \"def __getitem__(self, item):\\n # check if it's implicitly a furanose\\n furanose = item in [\\\"ERY\\\", \\\"THRE\\\", \\\"RUL\\\", \\\"XUL\\\", \\\"XLU\\\", \\\"ACE\\\"]\\n\\n # remove lactole identifier from name and store flag for furanoses\\n if item[-1] == \\\"p\\\" and not item.endswith(\\\"Hep\\\"):\\n item = item[:-1]\\n if item[-1] == \\\"f\\\":\\n item = item[:-1]\\n furanose = True\\n\\n # look the structure up and raise an error if it's not contained\\n if furanose and item in self.furanose_fac:\\n return self.furanose_fac[item]\\n if not furanose and item in self.pyranose_fac:\\n return self.pyranose_fac[item]\\n if item in self.open_fac:\\n return self.open_fac[item]\\n raise NotImplementedError(\\\"Query-monosaccharide is neither in pyranoses nor in furanoses.\\\")\",\n \"def locateObjLocation(data, questionDict, questionIdict):\\n where = questionDict['where']\\n for t in range(data.shape[0] - 1):\\n if data[t, 0] == where:\\n for u in range(t + 1, data.shape[0]):\\n word = questionIdict[data[u, 0] - 1]\\n lexname = lookupLexname(word)\\n if (lexname is not None and \\\\\\n lexname.startswith('noun')) or \\\\\\n (lexname is None):\\n return data[u, 0]\\n print 'not found'\\n return data[-1, 0]\",\n \"def _resolve_type_from_context(self, cr, uid, context=None):\\n if context is None:\\n context = {}\\n return context.get('default_type')\",\n \"def get_document_context(context):\\n document_types = {\\n 'transcript': 'transcript',\\n 'opening_statement_chair': 'chair opening statement',\\n 'opening_statement_rm': 'ranking member opening statement',\\n }\\n\\n eventdocuments_qs = EventDocument.objects.filter(\\n event_id=context['hearing']\\n )\\n\\n for key, value in document_types.items():\\n try:\\n doc = eventdocuments_qs.get(note=value)\\n context[key] = EventDocumentLink.objects.exclude(\\n text='archived'\\n ).filter(\\n document_id=doc\\n )[0].url\\n except (ObjectDoesNotExist):\\n context[key] = None\\n\\n try:\\n context[key + '_archived'] = EventDocumentLink.objects.get(\\n document_id=doc,\\n text='archived'\\n ).url\\n except (ObjectDoesNotExist, UnboundLocalError):\\n pass\\n\\n return context\",\n \"def contexts( # type: ignore[override]\\n self, triple: Optional[\\\"_TripleType\\\"] = None\\n ) -> Generator[\\\"_ContextIdentifierType\\\", None, None]:\\n\\n if triple:\\n nts = self.node_to_sparql\\n s, p, o = triple\\n params = (\\n nts(s if s else Variable(\\\"s\\\")),\\n nts(p if p else Variable(\\\"p\\\")),\\n nts(o if o else Variable(\\\"o\\\")),\\n )\\n q = \\\"SELECT ?name WHERE { GRAPH ?name { %s %s %s }}\\\" % params\\n else:\\n q = \\\"SELECT ?name WHERE { GRAPH ?name {} }\\\"\\n\\n result = self._query(q)\\n # type error: Item \\\"bool\\\" of \\\"Union[Tuple[Node, Node, Node], bool, ResultRow]\\\" has no attribute \\\"name\\\"\\n # error: Generator has incompatible item type \\\"Union[Any, Identifier]\\\"; expected \\\"IdentifiedNode\\\"\\n return (row.name for row in result) # type: ignore[union-attr,misc]\",\n \"def get_context(host='localhost', port=2002, find_uno=find_ooo.find_uno):\\n\\n uno = find_uno()\\n localctx = uno.getComponentContext()\\n create_instance = localctx.getServiceManager().createInstanceWithContext\\n\\n resolver_class = \\\"com.sun.star.bridge.UnoUrlResolver\\\"\\n resolver = create_instance(resolver_class, localctx)\\n\\n # http://udk.openoffice.org/common/man/spec/uno-url.html\\n context_url = (\\\"uno:socket,host={host},port={port};\\\"\\n \\\"urp;StarOffice.ComponentContext\\\".format)\\n\\n return resolver.resolve(context_url(host=host, port=port))\",\n \"def __getitem__(self, alt_loc):\\n assert isinstance(alt_loc, str)\\n\\n if self.altloc is None:\\n if self.alt_loc == alt_loc:\\n return self\\n raise KeyError, alt_loc\\n\\n else:\\n return self.altloc[alt_loc]\",\n \"def _compute_context_for_item(item):\\n source_text = [None, None, None]\\n reference_text = [None, None, None]\\n \\n left_context = RankingTask.objects.filter(hit=item.hit, pk=item.id-1)\\n right_context = RankingTask.objects.filter(hit=item.hit, pk=item.id+1)\\n \\n _item_doc_id = getattr(item.attributes, 'doc-id', None)\\n \\n # Item text and, if available, reference text are always set.\\n source_text[1] = item.source[0]\\n if item.reference:\\n reference_text[1] = item.reference[0]\\n \\n # Only display context if left/right doc-ids match current item's doc-id.\\n if left_context:\\n _left = left_context[0]\\n _left_doc_id = getattr(_left.attributes, 'doc-id', None)\\n \\n if _left_doc_id == _item_doc_id:\\n source_text[0] = _left.source[0]\\n if _left.reference:\\n reference_text[0] = _left.reference[0]\\n \\n if right_context:\\n _right = right_context[0]\\n _right_doc_id = getattr(_right.attributes, 'doc-id', None)\\n \\n if _right_doc_id == _item_doc_id:\\n source_text[2] = _right.source[0]\\n if _right.reference:\\n reference_text[2] = _right.reference[0]\\n \\n return (source_text, reference_text)\",\n \"def compute_applied_name_contexts(citelist: list) -> None:\\n for i, cite in enumerate(citelist):\\n if (cite.context == \\\"specimen\\\") or (cite.context == \\\"location\\\") or (cite.context == \\\"sequence\\\"):\\n cite.applied_cites = {cite}\\n elif cite.context == \\\"citation\\\":\\n for j in range(i): # only look at entries up to the current one\\n tmp = citelist[j]\\n if (tmp.cite_key == cite.application) and match_num_ref(tmp.name_key, cite.cite_n):\\n if (tmp.context == \\\"specimen\\\") or (tmp.context == \\\"location\\\") or (tmp.context == \\\"sequence\\\"):\\n cite.applied_cites |= {tmp}\\n if len(cite.applied_cites) == 0:\\n cite.applied_cites = None\\n\\n # for testing purposes only\\n # if cite.applied_cites is None:\\n # print(cite.cite_key, cite.name_key, cite.context, \\\"No application\\\")\\n # else:\\n # for c in cite.applied_cites:\\n # print(cite.cite_key, cite.name_key, cite.context, c.cite_key, c.name_key, c.context)\\n # input()\",\n \"def _resolve(self, csub, c, direction):\\n\\t# By default, no way to resolve\\n\\treturn None\",\n \"def lookup(index,keyword):\\n\\tif keyword in index:\\n\\t\\treturn index[keyword]\\n\\treturn None\",\n \"def get_prefix_with_context(model, context):\\n\\n model_keys = list(model.keys())\\n\\n # Some light cleanup.\\n context = context.replace(\\\"?\\\", \\\"\\\").replace(\\\"!\\\", \\\"\\\").replace(\\\".\\\", \\\"\\\")\\n context_keywords = list(set(context.split()))\\n\\n # we remove stop words from the context.\\n # We use reversed() to remove items from the list without affecting the sequence.\\n for word in reversed(context_keywords):\\n\\n if len(word) <= 3 or word in STOP_WORDS:\\n context_keywords.remove(word)\\n\\n # If our context has no keywords left we return a random prefix.\\n if len(context_keywords) == 0:\\n return get_prefix(model_keys)\\n\\n # We are going to sample one prefix for each available keyword and return only one.\\n random.shuffle(model_keys)\\n sampled_prefixes = list()\\n\\n for word in context_keywords:\\n\\n for prefix in model_keys:\\n\\n if word in prefix or word.lower() in prefix or word.title() in prefix:\\n\\n if \\\"?\\\" not in prefix or \\\"!\\\" not in prefix or \\\".\\\" not in prefix:\\n sampled_prefixes.append(prefix)\\n break\\n\\n # If we don't get any samples we fallback to the random prefix method.\\n if len(sampled_prefixes) == 0:\\n return get_prefix(model_keys)\\n else:\\n return random.choice(sampled_prefixes)\",\n \"def lookup(name, frame, locals):\\n if name in locals:\\n return 'local', locals[name]\\n if name in frame.f_globals:\\n return 'global', frame.f_globals[name]\\n if '__builtins__' in frame.f_globals:\\n builtins = frame.f_globals['__builtins__']\\n if isinstance(builtins, type({})):\\n if name in builtins:\\n return 'builtin', builtins[name]\\n else:\\n if hasattr(builtins, name):\\n return 'builtin', getattr(builtins, name)\\n return None, __UNDEF__\",\n \"def get_context(self):\\r\\n ctx = {}\\r\\n for clause in self.where_clauses or []:\\r\\n clause.update_context(ctx)\\r\\n return ctx\",\n \"def lookup(*args):\\n lemma, results = etym(*args)\\n languages = nest()\\n if not results:\\n query, _, dictionary = args\\n lemma, results = etym(query, None, dictionary)\\n for result in results:\\n languages[lemma][unicode(result['pos'])] = result['languages']\\n return languages\",\n \"def _get_concordance(self, vocabulary_uri: str = None) -> Optional[_Concordance]:\\n\\n # get the correct source (if any) given vocabulary_name:\\n vocabulary = None\\n if vocabulary_uri is None:\\n vocabulary = self._sources[0]\\n else:\\n for source in self._sources:\\n if source.uri == vocabulary_uri:\\n vocabulary = source\\n if vocabulary is None:\\n print(\\\"The selected vocabulary does not exist!\\\")\\n return None\\n\\n # make the best vector (on which the ranking of self._vocabularies is based):\\n best_vector = _Analysis.make_best_vector(vocabulary.levenshtein_vector, self._sensitivity)\\n\\n # make concordance:\\n source_scheme = self._scheme\\n target_scheme = _ConceptScheme(uri=vocabulary.uri)\\n concordance = _Concordance(from_scheme=source_scheme, to_scheme=target_scheme, mappings=set())\\n\\n # make concept mappings:\\n for score in best_vector.get_vector():\\n source_concept = score.comparandum\\n target_concept = score.comparans.get_concept()\\n source_member_set = {source_concept}\\n target_member_set = {target_concept}\\n source_bundle = _ConceptBundle(member_set=source_member_set)\\n target_bundle = _ConceptBundle(member_set=target_member_set)\\n\\n mapping = _ConceptMapping(from_=source_bundle,\\n to=target_bundle,\\n from_scheme=source_scheme,\\n to_scheme=target_scheme)\\n\\n concordance.mappings.add(mapping)\\n\\n return concordance\",\n \"def getcategory_context(self,category):\\r\\n return self[category]\",\n \"def get_xfrm(name):\\r\\n for x in xfrms:\\r\\n if x.name == name:\\r\\n return x\\r\\n return None\",\n \"def context(self, context):\\n if context is not None and not re.search(r'^(?:[A-Za-z0-9+\\\\/]{4})*(?:[A-Za-z0-9+\\\\/]{2}==|[A-Za-z0-9+\\\\/]{3}=)?$', context): # noqa: E501\\n raise ValueError(r\\\"Invalid value for `context`, must be a follow pattern or equal to `/^(?:[A-Za-z0-9+\\\\/]{4})*(?:[A-Za-z0-9+\\\\/]{2}==|[A-Za-z0-9+\\\\/]{3}=)?$/`\\\") # noqa: E501\\n\\n self._context = context\",\n \"def get_doc_context(self, docname, body, metatags):\\n\\n # find out relations\\n prev = next = None\\n parents = []\\n rellinks = self.globalcontext['rellinks'][:]\\n related = self.relations.get(docname)\\n # Populate titles with the list of longtitles from the env instead of titles\\n # titles = self.env.titles\\n titles = self.env.longtitles\\n if related and related[2]:\\n try:\\n next = {\\n 'link': self.get_relative_uri(docname, related[2]),\\n 'title': self.render_partial(titles[related[2]])['title']\\n }\\n rellinks.append((related[2], next['title'], 'N', _('next')))\\n except KeyError:\\n next = None\\n if related and related[1]:\\n try:\\n prev = {\\n 'link': self.get_relative_uri(docname, related[1]),\\n 'title': self.render_partial(titles[related[1]])['title']\\n }\\n rellinks.append((related[1], prev['title'], 'P', _('previous')))\\n except KeyError:\\n # the relation is (somehow) not in the TOC tree, handle\\n # that gracefully\\n prev = None\\n while related and related[0]:\\n try:\\n parents.append(\\n {'link': self.get_relative_uri(docname, related[0]),\\n 'title': self.render_partial(titles[related[0]])['title']})\\n except KeyError:\\n pass\\n related = self.relations.get(related[0])\\n if parents:\\n parents.pop() # remove link to the master file; we have a generic\\n # \\\"back to index\\\" link already\\n parents.reverse()\\n\\n # title rendered as HTML\\n title = self.env.longtitles.get(docname)\\n title = title and self.render_partial(title)['title'] or ''\\n # the name for the copied source\\n sourcename = self.config.html_copy_source and docname + '.txt' or ''\\n\\n # metadata for the document\\n meta = self.env.metadata.get(docname)\\n\\n # local TOC and global TOC tree\\n self_toc = self.env.get_toc_for(docname, self)\\n toc = self.render_partial(self_toc)['fragment']\\n\\n return dict(\\n parents = parents,\\n prev = prev,\\n next = next,\\n title = title,\\n meta = meta,\\n body = body,\\n metatags = metatags,\\n rellinks = rellinks,\\n sourcename = sourcename,\\n toc = toc,\\n # only display a TOC if there's more than one item to show\\n display_toc = (self.env.toc_num_entries[docname] > 1),\\n )\",\n \"def get_context(self, max_frames=None, missing_entities=None):\\n missing_entities = missing_entities or []\\n\\n relevant_frames = [frame[0] for frame in self.frame_stack if\\n time.time() - frame[1] < self.timeout]\\n if not max_frames or max_frames > len(relevant_frames):\\n max_frames = len(relevant_frames)\\n\\n missing_entities = list(missing_entities)\\n context = []\\n last = ''\\n depth = 0\\n entity = {}\\n for i in range(max_frames):\\n frame_entities = [entity.copy() for entity in\\n relevant_frames[i].entities]\\n for entity in frame_entities:\\n entity['confidence'] = entity.get('confidence', 1.0) \\\\\\n / (2.0 + depth)\\n context += frame_entities\\n\\n # Update depth\\n if entity['origin'] != last or entity['origin'] == '':\\n depth += 1\\n last = entity['origin']\\n\\n result = []\\n if missing_entities:\\n for entity in context:\\n if entity.get('data') in missing_entities:\\n result.append(entity)\\n # NOTE: this implies that we will only ever get one\\n # of an entity kind from context, unless specified\\n # multiple times in missing_entities. Cannot get\\n # an arbitrary number of an entity kind.\\n missing_entities.remove(entity.get('data'))\\n else:\\n result = context\\n\\n # Only use the latest keyword\\n return _strip_result(result)\",\n \"def getContext(namespace):\",\n \"def _findAltOpts(self, lookupword):\\n if self.allwords == []:\\n # on first call of _findAltOpts()\\n # create a list of all the words contained in the database\\n with sqlite3.connect(self.dbpath) as conn:\\n cursor = conn.cursor()\\n cursor.execute('SELECT word FROM words')\\n allwords = cursor.fetchall()\\n self.allwords = tools.listOfTuplesToList(allwords)\\n\\n # to collect words that have the longest common\\n # substrings with the lookupword\\n altopts = []\\n # lengths[i] is the length of the longest common\\n # substring of altopts[i] and the lookupword\\n lengths = []\\n\\n for word in self.allwords:\\n match = SequenceMatcher(None,\\n lookupword,\\n word\\n ).find_longest_match(0, len(lookupword),\\n 0, len(word))\\n\\n if len(altopts) < self.altsmax and match.size >= 3:\\n altopts.append(word)\\n lengths.append(match.size)\\n elif lengths != [] and match.size > lengths[-1]:\\n # current word is a better match than the last item of altopts\\n # insert the word into altopts and delete the altopts last item\\n for i in range(len(lengths)):\\n if lengths[i] < match.size:\\n index = i\\n altopts.insert(index, word)\\n lengths.insert(index, match.size)\\n del altopts[-1]\\n del lengths[-1]\\n return altopts\",\n \"def lookup_concept(wikidataId):\\n\\n if cfg.USE_CACHE:\\n if (wikidataId in LOOKUP_DICT):\\n return LOOKUP_DICT[wikidataId]\\n \\n response_json = wa.request_entity_fishing_concept_lookup(wikidataId)\\n \\n if not response_json:\\n return nan\\n\\n if 'statements' not in response_json.keys():\\n return nan\\n\\n for statement in response_json['statements']:\\n if statement['propertyId'] == 'P1566':\\n logger.debug('GeoNamesID found for %s: %s', wikidataId, statement['value'])\\n if cfg.USE_CACHE:\\n LOOKUP_DICT[wikidataId] = statement['value']\\n return statement['value']\\n\\n \\n return nan\",\n \"def get_ctxt(self, id):\\n id = id_force_tuple(id)\\n ctxt = {}\\n for v in self.vars:\\n ctxt[v.name] = v.T\\n\\n prf = self.prf\\n try:\\n for n in id:\\n for item in prf.items[:n+1]:\\n if item.rule == \\\"variable\\\":\\n nm, T = item.args\\n ctxt[nm] = T\\n prf = prf.items[n].subproof\\n return ctxt\\n except (AttributeError, IndexError):\\n raise TacticException()\",\n \"def __getitem__(self, ref):\\n for concept in self.concepts:\\n if concept.match_ref(ref):\\n return concept\\n raise KeyError()\",\n \"def locate(cls):\\r\\n if not cls._active:\\r\\n raise cls.ContextError('No parse context active.')\\r\\n return next(reversed(cls._active))\",\n \"def detect_robot_context(code: str, cursor_pos: int):\\n code = code[:cursor_pos]\\n line = code.rsplit(\\\"\\\\n\\\")[-1]\\n context_parts = code.rsplit(\\\"***\\\", 2)\\n if len(context_parts) != 3:\\n return \\\"__root__\\\"\\n else:\\n context_name = context_parts[1].strip().lower()\\n if context_name == \\\"settings\\\":\\n return \\\"__settings__\\\"\\n elif line.lstrip() == line:\\n return \\\"__root__\\\"\\n elif context_name in [\\\"tasks\\\", \\\"test cases\\\"]:\\n return \\\"__tasks__\\\"\\n elif context_name == \\\"keywords\\\":\\n return \\\"__keywords__\\\"\\n else:\\n return \\\"__root__\\\"\",\n \"def scope_context(self):\\n if self._course_id:\\n return 'COURSE'\\n elif self._partner_id:\\n return 'PARTNER'\\n elif self._group_id:\\n return 'GROUP'\\n else:\\n return None\",\n \"def get_default_context_cpl():\\n ctx = {'py_make_float_array': py_make_float_array,\\n 'py_pow': py_pow, 'py_mul': py_mul, 'py_opp': py_opp,\\n 'numpy': numpy}\\n try:\\n from skl2onnx.algebra.complex_functions import onnx_squareform_pdist # delayed\\n from skl2onnx.algebra.complex_functions import onnx_cdist # delayed\\n ctx['onnx_squareform_pdist'] = onnx_squareform_pdist\\n ctx['onnx_cdist'] = onnx_cdist\\n except ImportError: # pragma: no cover\\n # Too old version for skl2onnx.\\n pass\\n\\n from skl2onnx.algebra import onnx_ops # delayed\\n from skl2onnx.algebra.onnx_operator import OnnxOperator # delayed\\n d = onnx_ops.__dict__\\n for k, v in d.items():\\n try:\\n if k.startswith(\\\"Onnx\\\") and issubclass(v, OnnxOperator):\\n ctx[k] = v\\n except TypeError as e:\\n if inspect.isfunction(v):\\n continue\\n raise RuntimeError( # pragma: no cover\\n f\\\"Issue with {k}={v} (type={type(v)})\\\") from e\\n return ctx\",\n \"def _get_answer(context, context_words, answer_start, answer_end):\\n context = context.decode('utf-8')\\n context_words = [word.decode('utf-8') for word in context_words]\\n pos = 0\\n answer_start_char = None\\n answer_end_char = None\\n for i, word in enumerate(context_words):\\n pos = context.index(word, pos)\\n if answer_start == i:\\n answer_start_char = pos\\n pos += len(word)\\n if answer_end == i:\\n answer_end_char = pos\\n break\\n assert answer_start_char is not None, (\\n '`answer_start` is not found in context. '\\n 'context=`%s`, context_words=`%r`, '\\n 'answer_start=%d, answer_end=%d') % (context, context_words, answer_start,\\n answer_end)\\n assert answer_end_char is not None, (\\n '`answer_end` is not found in context. '\\n 'context=`%s`, context_words=`%r`, '\\n 'answer_start=%d, answer_end=%d') % (context, context_words, answer_start,\\n answer_end)\\n answer = context[answer_start_char:answer_end_char].encode('utf-8')\\n return answer\",\n \"def test_context_corpus_iter(self):\\n contexts = {1:{0, 1, 2, 3}, 2:{3, 4, 5}, 3:{10}}\\n cc = ContextCorpus(contexts)\\n line = list(next(cc.__iter__()))\\n context = int(line[0].replace('C', ''))\\n examples = contexts[context]\\n good = all((int(i.replace('I', '')) in examples for i in line[1:]))\\n self.assertTrue(good)\",\n \"def __getitem__(self, item):\\n return foreign_get(self.vars, item)\",\n \"def get_catalog_lookup_session(self):\\n raise Unimplemented()\",\n \"def context(self) -> _C_out:\\n return self._context\",\n \"def resolve_anyref(\\n self, refdoc: str, node: pending_xref, contnode: Element,\\n ) -> Element | None:\\n stddomain = self.env.get_domain('std')\\n target = node['reftarget']\\n results: list[tuple[str, Element]] = []\\n # first, try resolving as :doc:\\n doc_ref = stddomain.resolve_xref(self.env, refdoc, self.app.builder,\\n 'doc', target, node, contnode)\\n if doc_ref:\\n results.append(('doc', doc_ref))\\n # next, do the standard domain (makes this a priority)\\n results.extend(stddomain.resolve_any_xref(self.env, refdoc, self.app.builder,\\n target, node, contnode))\\n for domain in self.env.domains.values():\\n if domain.name == 'std':\\n continue # we did this one already\\n try:\\n results.extend(domain.resolve_any_xref(self.env, refdoc, self.app.builder,\\n target, node, contnode))\\n except NotImplementedError:\\n # the domain doesn't yet support the new interface\\n # we have to manually collect possible references (SLOW)\\n for role in domain.roles:\\n res = domain.resolve_xref(self.env, refdoc, self.app.builder,\\n role, target, node, contnode)\\n if res and len(res) > 0 and isinstance(res[0], nodes.Element):\\n results.append((f'{domain.name}:{role}', res))\\n # now, see how many matches we got...\\n if not results:\\n return None\\n if len(results) > 1:\\n def stringify(name: str, node: Element) -> str:\\n reftitle = node.get('reftitle', node.astext())\\n return f':{name}:`{reftitle}`'\\n candidates = ' or '.join(stringify(name, role) for name, role in results)\\n logger.warning(__(\\\"more than one target found for 'any' cross-\\\"\\n 'reference %r: could be %s'), target, candidates,\\n location=node)\\n res_role, newnode = results[0]\\n # Override \\\"any\\\" class with the actual role type to get the styling\\n # approximately correct.\\n res_domain = res_role.split(':')[0]\\n if (len(newnode) > 0 and\\n isinstance(newnode[0], nodes.Element) and\\n newnode[0].get('classes')):\\n newnode[0]['classes'].append(res_domain)\\n newnode[0]['classes'].append(res_role.replace(':', '-'))\\n return newnode\",\n \"def find(self, op):\\n # return the environment itself so that invoker can update information\\n # in specific environment\\n if op in self:\\n return self\\n if self._outer is None:\\n raise LookupError('unbound '+op)\\n return self._outer.find(op)\",\n \"def sdcToClassifier_keyword(self, sdc):\\n for srname, engine in self.engineMap.iteritems():\\n if(srname in sdc[\\\"spatialRelation\\\"].text):\\n return engine\\n return None\",\n \"def context(self) -> Optional[str]:\\n displayed_line = self.editor_line\\n displayed_column = self.editor_column\\n # we want to avoid displaying a blank line for context. If we're on a blank line\\n # find the nearest line above us that isn't blank.\\n while displayed_line >= 1 and not len(self._lines[displayed_line - 1].strip()):\\n displayed_line -= 1\\n displayed_column = len(self._lines[displayed_line - 1])\\n\\n # only show context if we managed to find a non-empty line\\n if len(self._lines[displayed_line - 1].strip()):\\n formatted_source_line = expand_tabs(self._lines[displayed_line - 1]).rstrip(\\n _NEWLINE_CHARS\\n )\\n # fmt: off\\n return (\\n f\\\"{formatted_source_line}\\\\n\\\"\\n + f\\\"{' ' * (displayed_column - 1)}^\\\"\\n )\\n # fmt: on\\n else:\\n return None\",\n \"def getSourceForId(context, identifier):\\n nearest = getattr(context, identifier, None)\\n if IExternalSource.providedBy(nearest):\\n return nearest\\n return None\",\n \"def __getitem__(self, key):\\n for db in self.db:\\n if db.name == key:\\n return db\\n raise IndexError\",\n \"def add_place_predicate_context(task: SynthesisTask, grammar: CFG):\\n\\n if 'processed' not in task.context:\\n task.context['processed'] = set()\\n\\n processed_strs = task.context['processed']\\n new_strings = [s for s in task.pos_str_context + task.neg_str_context if s.s not in processed_strs]\\n if len(new_strings) == 0:\\n return\\n\\n processed_strs.update([s.s for s in new_strings])\\n\\n if task.no_context:\\n\\n regions_in_grammar = grammar.get_terminal_sym('REGION').values\\n relevant_regions = []\\n for region in regions_in_grammar:\\n if any([check_regions(s.s, [region]) for s in new_strings]):\\n relevant_regions.append(region)\\n\\n task.context['inRegion'] = relevant_regions\\n\\n countries_in_grammar = grammar.get_terminal_sym('COUNTRY').values\\n relevant_countries = []\\n for country in countries_in_grammar:\\n if any([check_countries(s.s, [country]) for s in new_strings]):\\n relevant_countries.append(country)\\n\\n task.context['inCountry'] = relevant_countries\\n\\n task.context['inState'] = grammar.get_terminal_sym('STATE').values\\n else:\\n\\n def find_entity(ty: str) -> List[str]:\\n relevant_entity = []\\n for s_ctx in new_strings:\\n for span_ctx in s_ctx.str_span_to_predicate_context.values():\\n if ty in span_ctx and span_ctx.get(ty) not in relevant_entity:\\n relevant_entity.extend(span_ctx.get(ty))\\n return list(set(relevant_entity))\\n\\n task.context['inRegion'] = find_entity('region')\\n task.context['inCountry'] = find_entity('country')\\n task.context['inState'] = find_entity('state')\",\n \"def _lookup(self, key):\\n\\n if key in self.position and key in self.info:\\n # If the key exists in both position and info, treat it as a list to intersect.\\n return self._skill_list(key)\\n if key in self.position:\\n return self.position[key]\\n if key in self.info:\\n return self.info[key]\\n\\n raise KeyError(f\\\"Invalid Key: {key}\\\")\",\n \"def _get(context, namespace_name, resource_type_name,\\n namespace_id, resource_type_id, session):\\n\\n # visibility check assumed done in calling routine via namespace_get\\n try:\\n query = session.query(models.MetadefNamespaceResourceType).filter_by(\\n namespace_id=namespace_id, resource_type_id=resource_type_id)\\n db_rec = query.one()\\n except sa_orm.exc.NoResultFound:\\n LOG.debug(\\\"The metadata definition resource-type association of\\\"\\n \\\" resource_type=%(resource_type_name)s to\\\"\\n \\\" namespace_name=%(namespace_name)s was not found.\\\",\\n {'resource_type_name': resource_type_name,\\n 'namespace_name': namespace_name})\\n raise exc.MetadefResourceTypeAssociationNotFound(\\n resource_type_name=resource_type_name,\\n namespace_name=namespace_name)\\n\\n return db_rec\",\n \"def _resolve_section_id_from_context(self, cr, uid, context=None):\\n if context is None:\\n context = {}\\n if type(context.get('default_section_id')) in (int, long):\\n return context.get('default_section_id')\\n if isinstance(context.get('default_section_id'), basestring):\\n section_name = context['default_section_id']\\n section_ids = self.pool.get('crm.case.section').name_search(cr, uid, name=section_name, context=context)\\n if len(section_ids) == 1:\\n return int(section_ids[0][0])\\n return None\",\n \"def lookup(conn, language_code, graphic, phonetic, restrictions):\\n c = conn.cursor()\\n entry_ids = tuple(c.execute('SELECT entry_id FROM lemmas WHERE language = ? AND graphic = ? and phonetic = ?', (language_code, graphic, hiragana_to_katakana(phonetic))))\\n return tuple(Lexeme(conn, language_code, entry_id, restrictions) for (entry_id,) in entry_ids)\",\n \"def assemblyContext(self):\\n return fusion.Occurrence()\",\n \"def _is_contextual(self, graph: Optional[Union[\\\"Graph\\\", \\\"str\\\"]]) -> bool:\\n if (not self.context_aware) or (graph is None):\\n return False\\n if isinstance(graph, str):\\n return graph != \\\"__UNION__\\\"\\n else:\\n return graph.identifier != DATASET_DEFAULT_GRAPH_ID\",\n \"def context_get():\\n global __context\\n if __context is None:\\n __context = Context()\\n return __context\",\n \"def find(context, alias):\\n if not hasattr(context, \\\"config\\\"):\\n return None\\n\\n expansion = context.config.get(ALIAS_SECTION, alias)\\n return expansion.split(' ') if expansion else None\",\n \"def _test_word(query_word, query_context):\\n assert(not query_word.is_at_var)\\n engine = query_context._engine\\n # TODO: validate on activate context too\\n alphas, betas, regexs, annotations = validate_and_split_constraints(query_word, engine=engine)\\n callable_annotations = [word for word in annotations if hasattr(word, \\\"__call__\\\")]\\n data_set = {word : d for word,d in enumerate(query_context.pairs())}\\n pairs = enumerate(query_context.pairs())\\n query_context.clear()\\n\\n\\n potentials = [(i, d[0], passing) for i,d in pairs for passing in retrieve_potentials(query_word, d)]\\n # Apply Tests\\n # TODO: test type instance if not ATOM\\n passing = [run_subbinds(n, regexs, d, i) for i,d,n in potentials\\n if test_alphas(n, alphas, d, engine=engine)\\n and test_betas(n, betas, d, engine=engine)\\n and test_annotations(n, callable_annotations, d, engine)]\\n\\n to_add = [add_var_to_context(i, query_word, d, n) for i,d,n in passing if n is not None]\\n\\n query_context.append(*to_add, fail_dict=data_set)\\n return annotations\",\n \"def make_context(self, engine, args):\\n args = self.normalize_args(args)\\n _, ctx = self._make_argkey_and_context(engine, args)\\n return ctx\",\n \"def locate(self, interface, depth=1, _default=object()):\\n key = qual(interface)\\n currentContext = self\\n while True:\\n if depth < 0:\\n full = []\\n while True:\\n try:\\n full.append(self.locate(interface, len(full)+1))\\n except KeyError:\\n break\\n #print \\\"full\\\", full, depth\\n if full:\\n return full[depth]\\n return None\\n\\n # Hook for FactoryContext and other implementations of complex locating\\n locateHook = currentContext.locateHook\\n if locateHook is not None:\\n result = locateHook(interface)\\n if result is not None:\\n return result\\n\\n _remembrances = currentContext._remembrances\\n if _remembrances is not None:\\n rememberedValue = _remembrances.get(key, _default)\\n if rememberedValue is not _default:\\n depth -= 1\\n if not depth:\\n return rememberedValue\\n\\n contextParent = currentContext.parent\\n if contextParent is None:\\n raise KeyError, \\\"Interface %s was not remembered.\\\" % key\\n\\n currentContext = contextParent\",\n \"def set_adapt_context(self, context, word, origin):\\n self.bus.emit(Message('add_context',\\n {'context': context, 'word': word,\\n 'origin': origin}))\",\n \"def lookup(self):\\n return self._lookup\",\n \"def lookup(self, key):\",\n \"def section(self, context):\\n registry = queryUtility(IRegistry)\\n if registry is None:\\n return None\\n if registry.get('plone.subjects_of_navigation_root', False):\\n portal = getToolByName(context, 'portal_url').getPortalObject()\\n return getNavigationRootObject(context, portal)\\n return None\",\n \"def get(key, domain=None, language=None, context=None):\\n\\n return intuition.get(key, domain, language, context)\",\n \"def extract_context(words, mask_index, window):\\n total_length = len(words)\\n half_window = int(window / 2)\\n assert 0 <= mask_index < total_length\\n return words[max(0, mask_index - half_window):min(total_length, mask_index + half_window + 1)]\",\n \"def _key_from_context(self, ctx, tag_name):\\n tag_context = self.get_tag_context(ctx, tag_name)\\n if tag_context:\\n if tag_context == \\\"global\\\":\\n return \\\"config:tags:global\\\"\\n elif tag_context == \\\"chan\\\":\\n return \\\"chan:{}:tags\\\".format(ctx.message.channel.id)\\n elif tag_context == \\\"guild\\\":\\n return \\\"guild:{}:tags\\\".format(ctx.message.guild.id)\\n else:\\n return None\",\n \"def edge_lookup(self, keylookup_obj, id_strct, debug=False):\\n # pylint: disable=E1102, R0201, W0613\\n yield NotImplemented(\\\"This method must be overridden by the base class.\\\")\",\n \"def category(self):\\n\\n for category, match_list in rule_list:\\n for match in match_list:\\n if match.match(self):\\n return category\\n\\n return None\",\n \"def __getitem__(self, name):\\n return self.current_scope[name]\",\n \"def get_context_data(instance):\\n # type: (Dict[str, Any]) -> Tuple[Optional[OctetString], str]\\n context_engine_id = None\\n context_name = ''\\n\\n if 'user' in instance:\\n if 'context_engine_id' in instance:\\n context_engine_id = OctetString(instance['context_engine_id'])\\n\\n if 'context_name' in instance:\\n context_name = instance['context_name']\\n\\n return context_engine_id, context_name\",\n \"def definition_context(self):\\n return self.__context\",\n \"def codrspace_contexts(request):\\n contexts = {}\\n contexts.update({\\n 'TAGLINE': \\\"Why you no write tutorial?\\\"\\n })\\n\\n return contexts\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57803524","0.52267176","0.5220787","0.52120763","0.5174642","0.5164446","0.5149356","0.5041184","0.49859065","0.49716657","0.49243554","0.49187955","0.49112827","0.4855967","0.48273122","0.4817933","0.47763702","0.47615644","0.4757728","0.47567716","0.4750502","0.4734812","0.47305727","0.47237477","0.47216007","0.46912032","0.46878093","0.46591023","0.46567845","0.46564373","0.46414384","0.46377906","0.46163726","0.46059737","0.45765138","0.454904","0.4542763","0.45352584","0.45331225","0.4519761","0.45144984","0.45126185","0.45052594","0.4501442","0.44844985","0.4469409","0.44690952","0.44503558","0.44361967","0.44341797","0.44296274","0.44238853","0.43961674","0.43925476","0.43913704","0.4390319","0.438624","0.43861994","0.43838307","0.43825492","0.43774045","0.43730152","0.43704832","0.43582648","0.43528387","0.43387592","0.43347874","0.4334355","0.43218324","0.43210742","0.43197513","0.43140507","0.43033594","0.43033212","0.42979848","0.4293633","0.42920628","0.42920172","0.42807585","0.4276486","0.42745543","0.42721498","0.42707637","0.42623657","0.42574352","0.42546955","0.42505866","0.4249614","0.4247906","0.42315364","0.42311466","0.4230629","0.42187268","0.4216605","0.4215622","0.42129132","0.42110285","0.4209747","0.41974282","0.4189234"],"string":"[\n \"0.57803524\",\n \"0.52267176\",\n \"0.5220787\",\n \"0.52120763\",\n \"0.5174642\",\n \"0.5164446\",\n \"0.5149356\",\n \"0.5041184\",\n \"0.49859065\",\n \"0.49716657\",\n \"0.49243554\",\n \"0.49187955\",\n \"0.49112827\",\n \"0.4855967\",\n \"0.48273122\",\n \"0.4817933\",\n \"0.47763702\",\n \"0.47615644\",\n \"0.4757728\",\n \"0.47567716\",\n \"0.4750502\",\n \"0.4734812\",\n \"0.47305727\",\n \"0.47237477\",\n \"0.47216007\",\n \"0.46912032\",\n \"0.46878093\",\n \"0.46591023\",\n \"0.46567845\",\n \"0.46564373\",\n \"0.46414384\",\n \"0.46377906\",\n \"0.46163726\",\n \"0.46059737\",\n \"0.45765138\",\n \"0.454904\",\n \"0.4542763\",\n \"0.45352584\",\n \"0.45331225\",\n \"0.4519761\",\n \"0.45144984\",\n \"0.45126185\",\n \"0.45052594\",\n \"0.4501442\",\n \"0.44844985\",\n \"0.4469409\",\n \"0.44690952\",\n \"0.44503558\",\n \"0.44361967\",\n \"0.44341797\",\n \"0.44296274\",\n \"0.44238853\",\n \"0.43961674\",\n \"0.43925476\",\n \"0.43913704\",\n \"0.4390319\",\n \"0.438624\",\n \"0.43861994\",\n \"0.43838307\",\n \"0.43825492\",\n \"0.43774045\",\n \"0.43730152\",\n \"0.43704832\",\n \"0.43582648\",\n \"0.43528387\",\n \"0.43387592\",\n \"0.43347874\",\n \"0.4334355\",\n \"0.43218324\",\n \"0.43210742\",\n \"0.43197513\",\n \"0.43140507\",\n \"0.43033594\",\n \"0.43033212\",\n \"0.42979848\",\n \"0.4293633\",\n \"0.42920628\",\n \"0.42920172\",\n \"0.42807585\",\n \"0.4276486\",\n \"0.42745543\",\n \"0.42721498\",\n \"0.42707637\",\n \"0.42623657\",\n \"0.42574352\",\n \"0.42546955\",\n \"0.42505866\",\n \"0.4249614\",\n \"0.4247906\",\n \"0.42315364\",\n \"0.42311466\",\n \"0.4230629\",\n \"0.42187268\",\n \"0.4216605\",\n \"0.4215622\",\n \"0.42129132\",\n \"0.42110285\",\n \"0.4209747\",\n \"0.41974282\",\n \"0.4189234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6447261"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17087,"cells":{"query":{"kind":"string","value":"This function was created because we don't want TermManagers getting confused about things like misassigned CAS numbers, because they don't have the capacity to store multiple CFs. So we will save the full synonym list for the LciaEngine."},"document":{"kind":"string","value":"def _flow_terms(flow):\n return flow.synonyms"},"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 fill_stempool(self):\n tokens = [apply_word_tokenize(x) for x in self.df['name']]\n\n flatten1 = itertools.chain.from_iterable\n flat = list(flatten1(tokens))\n\n stems = [self.stemmer.stem(x) for x in flat]\n\n return set(stems)","def nsrSynonyms():\r\n # Input file\r\n synonymsFile = pd.read_csv(args.indir+\"/\"+args.infile2, header=2,\r\n sep=\"\\t\", encoding=\"utf8\")\r\n\r\n # Parse taxonomic names into their elementary components\r\n synonyms = synonymsFile.loc[synonymsFile['language'] == 'Scientific']\r\n synonymDict = {}\r\n for synonym, taxon in zip(synonyms['synonym'], synonyms['taxon']):\r\n synonym = taxonParser(synonym)\r\n taxon = taxonParser(taxon)\r\n if not taxon or synonym is False or taxon is False:\r\n pass\r\n else:\r\n synonymDict[synonym] = taxon\r\n\r\n # Write dictionary to file\r\n with io.open(par_path+\"/results/nsr_synonyms.csv\", \"w\", encoding=\"utf-8\") as outfile:\r\n outfile.write(\"synonym_name,identification_reference,taxon_name,taxon_author\\n\")\r\n for key, value in synonymDict.items():\r\n outfile.write('\"%s\",\"%s\",\"%s\",\"%s\"' % (' '.join(str(key).split()[:2]), ' '.join(str(key).split()[2:]),\r\n ' '.join(str(value).split()[:2]), ' '.join(str(value).split()[2:])))\r\n outfile.write(\"\\n\")\r\n return [*synonymDict], synonymDict","def get_searched_single_word_synonym(self, content, stop_words):\n content = re.sub(r\"[^\\w\\s]\", \"\", content)\n content = re.sub(r\"[0-9]+\", \"\", content)\n new_sent = [\n Word(word).singularize()\n for word in content.lower().split()\n if Word(word).singularize() not in stop_words\n ]\n new_sent = [\n Word(word).singularize()\n for word in new_sent\n if Word(word).singularize() in set(self.searched_words)\n ]\n\n syn = []\n for w in new_sent:\n for s in wordnet.synsets(w):\n for lemma in s.lemmas():\n if len(syn) == SYNONYM_LIMIT:\n break\n syn.append(lemma.name())\n syn = list(dict.fromkeys(syn)) #\n syn = \" \".join(syn)\n return syn","def getLSASpace():\n sids,documents = getSongTextInfo()\n texts = [[word for word in document.lower().split()] for document in documents]\n dictionary = corpora.Dictionary(texts)\n corpus = [dictionary.doc2bow(text) for text in texts]\n tfidf = models.TfidfModel(corpus)\n corpus_tfidf = tfidf[corpus]\n lsi = models.LsiModel(corpus_tfidf, id2word=dictionary, num_topics=30)\n corpus_lsi = lsi[corpus_tfidf]\n songMap = {}\n index = 0\n for doc in corpus_lsi:\n sid = sids[index]\n rMap = {}\n for item in doc:\n wid = item[0]\n count = item[1]\n rMap[wid] = count\n songMap[sid] = rMap\n index += 1\n return songMap","def synonyms(self) -> List[str]:\n return self._synonyms","def synonyms(self) -> List[str]:\n return pulumi.get(self, \"synonyms\")","def synonymic_list_generator(content):\n\tpass","def getSynonyms(self, wordSet):\n synonyms = {}\n for w in wordSet:\n # find synonyms\n synsets = wn.synsets(w, pos=wn.NOUN)\n if len(synsets) > 0: \n # there are noun senses for this word, get synonyms\n synonyms[w] = set([synset.name for synset in synsets])\n \n return synonyms","def on_serialize(self):\n for sw in self.sig_words:\n sw[1] = set(map(lambda s: s.name(), sw[1]))\n self.most_common_synsets = list(map(lambda s: s.name(), self.most_common_synsets))","def antonym(self, sense=0):\n s = self._synset(self.text, sense=sense)\n\n if not s:\n return []\n\n lemmas = s.lemmas()\n\n result = list()\n\n for lemma in lemmas:\n if lemma.antonyms():\n result.append(lemma.antonyms()[0].name())\n\n return result if result else []","def meronym(self, sense=0):\n s = self._synset(self.text, sense=sense)\n\n if not s:\n return []\n\n return s.member_meronyms()","def get_synonyms(word):\n synsets = [];\n syns = wn.synsets(word)\n for ss in syns:\n lemmas = []\n for l in ss.lemmas():\n lemma = { \"name\": l.name(), \"related_forms\": [] }\n for x in l.derivationally_related_forms():\n lemma['related_forms'].append(x.name())\n lemmas.append(lemma)\n synsets.append({\n \"lemmas\": lemmas,\n \"d\": ss.definition(),\n \"pos\": ss.pos(),\n \"id\": ss.name()\n })\n return synsets","def makeStems(self):\r\n clean_s = self.cleanString(self.text)\r\n LoW = clean_s.split() \r\n for x in LoW: \r\n if create_stem(x) not in self.stems: \r\n self.stems[create_stem(x)] = 1\r\n else: \r\n self.stems[create_stem(x)] += 1\r\n return self.stems","def _add_to_existing_flowable(self, fb, new_terms):\n biog = ('124-38-9' in fb)\n for term in new_terms:\n self._fm.add_synonym(fb, term)\n if biog and bool(biogenic.search(term)):\n self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym","def get_words(self):\r\n\r\n #using database\r\n\r\n if self.using_database:\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT word\"\r\n +\" FROM word_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n value_tuple)\r\n fetched = db_cursor.fetchall()\r\n if fetched:\r\n return {word[0] for word in fetched}\r\n\r\n return set()\r\n\r\n #using shelf\r\n\r\n return self.word_dict.keys()","def __macronize(self):\n self.macronizations = [Scansion(\"\")]\n for i, word in enumerate(self.words):\n new_macrons = []\n for exist in self.macronizations:\n for macrons in word.macronize():\n new_macrons.append(exist + macrons)\n self.macronizations = new_macrons","def get_legal_synonyms(input_filepath):\n syn_filepath = TestSystem.get_synonym_solution_filepath(input_filepath)\n if not os.path.isfile(syn_filepath):\n return None\n with io.open(syn_filepath, 'r') as f:\n result = dict()\n for l in f:\n if not l.startswith('#'):\n [name, val] = l.rstrip().split(\"===\")\n if name not in result:\n result[name] = [val]\n else:\n result[name].append(val)\n\n return result","def testOneWord(self):\n\n\t\t\t\tspinner.Synonym.objects.add('directory', 'catalog', 10)\n\t\t\t\tspinner.Synonym.objects.add('list', 'directory', 20)\n\t\t\t\tspinner.Synonym.objects.add('directory', 'guide', 10)\n\n\t\t\t\tsynonyms = spinner.Synonym.objects.get_synonyms(['directory'])\n\t\t\t\tassert len(synonyms) < 3, synonyms","def getLDASpace():\n sids,documents = getSongTextInfo()\n texts = [[word for word in document.lower().split()] for document in documents]\n dictionary = corpora.Dictionary(texts)\n corpus = [dictionary.doc2bow(text) for text in texts]\n tfidf = models.TfidfModel(corpus)\n corpus_tfidf = tfidf[corpus]\n lda = models.LdaModel(corpus_tfidf, id2word=dictionary, num_topics=30)\n corpus_lda = lda[corpus_tfidf]\n songMap = {}\n index = 0\n for doc in corpus_lda:\n sid = sids[index]\n rMap = {}\n for item in doc:\n wid = item[0]\n count = item[1]\n rMap[wid] = count\n songMap[sid] = rMap\n index += 1\n return songMap","def get_synonyms(word,w2v,pos,max=20):\n synonyms = []\n count = 0\n synsets = wordnet.synsets(word,pos=pos)\n for synset in synsets:\n candidate_names = []\n for lemma in synset.lemma_names():\n candidate_names.append(lemma)\n for hypo in synset.hyponyms():\n candidate_names.append(hypo)\n for hyper in synset.hypernyms():\n candidate_names.append(hyper)\n\n for lemma in candidate_names:\n if count >= max:\n break\n # print pos,word,lemma\n try:\n similarity = w2v.n_similarity([word.lower()],[lemma.lower() ])\n if similarity > .34 and lemma not in synonyms:\n synonyms.append(lemma)\n\n count += 1\n except:\n continue\n\n return synonyms","def _get_term_dictionaries(self):\n\t\tforward_dict = {}\n\t\treverse_dict = defaultdict(list)\n\t\tfor term in self.terms():\n\t\t\tif (term.name is not None) and (\"obsolete\" not in term.name): \n\t\t\t\twords = [term.name]\n\t\t\t\twords.extend([x.description for x in list(term.synonyms)])\t# Add all the synonyms\n\t\t\t\twords = [re.sub(r\" ?\\([^)]+\\)\", \"\", x) for x in words]\t\t# Replace parenthetical text.\n\t\t\t\tforward_dict[term.id] = words\n\t\t\t\tfor word in words:\n\t\t\t\t\treverse_dict[word].append(term.id)\n\t\treturn(forward_dict, reverse_dict)","def synonyms(self, synonyms: List[str]):\n\n self._synonyms = synonyms","def fit(self, clean=False):\n if self._no_canonical_entity_map:\n return\n\n if not self._use_text_rel:\n self._fit_exact_match()\n return\n\n if clean:\n delete_index(\n self._app_namespace, self._es_index_name, self._es_host, self._es_client\n )\n entity_map = self._resource_loader.get_entity_map(self.type)\n\n # list of canonical entities and their synonyms\n entities = entity_map.get(\"entities\", [])\n\n # create synonym index and import synonyms\n logger.info(\"Importing synonym data to synonym index '%s'\", self._es_index_name)\n EntityResolver.ingest_synonym(\n app_namespace=self._app_namespace,\n index_name=self._es_index_name,\n data=entities,\n es_host=self._es_host,\n es_client=self._es_client,\n use_double_metaphone=self._use_double_metaphone,\n )\n\n # It's supported to specify the KB object type and field name that the NLP entity type\n # corresponds to in the mapping.json file. In this case the synonym whitelist is also\n # imported to KB object index and the synonym info will be used when using Question Answerer\n # for text relevance matches.\n kb_index = entity_map.get(\"kb_index_name\")\n kb_field = entity_map.get(\"kb_field_name\")\n\n # if KB index and field name is specified then also import synonyms into KB object index.\n if kb_index and kb_field:\n # validate the KB index and field are valid.\n # TODO: this validation can probably be in some other places like resource loader.\n if not does_index_exist(\n self._app_namespace, kb_index, self._es_host, self._es_client\n ):\n raise ValueError(\n \"Cannot import synonym data to knowledge base. The knowledge base \"\n \"index name '{}' is not valid.\".format(kb_index)\n )\n if kb_field not in get_field_names(\n self._app_namespace, kb_index, self._es_host, self._es_client\n ):\n raise ValueError(\n \"Cannot import synonym data to knowledge base. The knowledge base \"\n \"field name '{}' is not valid.\".format(kb_field)\n )\n if entities and not entities[0].get(\"id\"):\n raise ValueError(\n \"Knowledge base index and field cannot be specified for entities \"\n \"without ID.\"\n )\n logger.info(\"Importing synonym data to knowledge base index '%s'\", kb_index)\n EntityResolver.ingest_synonym(\n app_namespace=self._app_namespace,\n index_name=kb_index,\n index_type=\"kb\",\n field_name=kb_field,\n data=entities,\n es_host=self._es_host,\n es_client=self._es_client,\n use_double_metaphone=self._use_double_metaphone,\n )","def get_words_from_sysets(synset):\n synlist = []\n for s in synset:\n syns = s.lemmas()[0].name()\n synlist.append(syns)\n return synlist","def synonyms_pipeline(config: SettingConfig) -> None:\n raw_synonym_pairs = generate_synonym_pairs(config)\n for pos in config.pos.keys():\n processed_synonym_pairs = postprocess_pairs(raw_synonym_pairs[pos], config)\n write_pairs(processed_synonym_pairs, config.constraints_root_path, pos, \"synonyms\")","def constitute_word_dict(self):\r\n\r\n #IS THIS NECESSARY WITH DATABASE??\r\n\r\n if self.using_shelf:\r\n for k_temp in self.get_words():\r\n self.delete_word(k_temp)\r\n\r\n for i_temp in [a_temp for a_temp in self.indexes()\r\n if Index(a_temp) > Index(str(0))]:\r\n\r\n self.add_search_words(Index(i_temp),\r\n self.get_text_from_note(i_temp))\r\n display.noteprint((alerts.ATTENTION,\r\n alerts.WORD_DICT_CONSTITUTED))","def get_synonyms(word):\n syns_sets = wordnet.synsets(word)\n if syns_sets:\n # if there's synonyms, take the first set\n desired = syns_sets[0].lemma_names()\n desired = [the_name.replace(\"_\", \" \") for the_name in desired]\n return desired\n\n else:\n return False","def get_synonyms(word):\n try:\n query = {'word': word}\n cursor = database['Words'].find(query)\n synonym_set = set()\n if cursor is None:\n return None\n for document in cursor:\n if len(document['synsets']) > 0:\n for key, synset in document['synsets'].items():\n synonyms = synset['synonyms'].split(\",\")\n for synonym in synonyms:\n synonym_set.add(synonym.strip())\n if len(synonym_set) == 0:\n return None\n return synonym_set\n except Exception as e:\n print(e)\n return None","def weed_out_synonyms(word, potential_synonyms):\n real_synonyms = set()\n for synonym in potential_synonyms:\n max_distance = abs(len(word) - len(synonym))\n abbr_len = min(len(word), len(synonym))\n forgiveness = round(1/7 * abbr_len)\n if lev.distance(word, synonym) <= max_distance + forgiveness:\n # Then it's a synonym!\n real_synonyms.add(synonym)\n return real_synonyms","def on_deserialize(self):\n for sw in self.sig_words:\n sw[1] = set(map(lambda s: wn.synset(s), sw[1]))\n self.most_common_synsets = list(map(lambda s: wn.synset(s), self.most_common_synsets))","def c_synonym_cd(self) -> str:\n return \"N\"","def load_known_corpora():\n\n print (\"Loading Corpora\")\n\n # For debugging purposes, comment out the definition of all but say the first\n # corpus, to speed the ingest time.\n shenoute_a22 = Corpus()\n shenoute_a22.annis_corpus_name = \"shenoute.a22\"\n shenoute_a22.title = \"Acephalous Work 22\"\n shenoute_a22.slug = \"acephalous_work_22\"\n shenoute_a22.urn_code = \"shenoute.a22\"\n shenoute_a22.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-a22\"\n\n patrum = Corpus()\n patrum.annis_corpus_name = \"apophthegmata.patrum\"\n patrum.title = \"Apophthegmata Patrum\"\n patrum.slug = \"ap\"\n patrum.urn_code = \"ap\"\n patrum.github = \"https://github.com/CopticScriptorium/corpora/tree/master/AP\"\n\n saof = Corpus()\n saof.annis_corpus_name = \"shenoute.abraham.our.father\"\n saof.title = \"Abraham Our Father\"\n saof.slug = \"abraham_our_father\"\n saof.urn_code = \"shenoute.abraham\"\n saof.github = \"https://github.com/CopticScriptorium/corpora/tree/master/abraham\"\n\n besa_ap = Corpus()\n besa_ap.annis_corpus_name = \"besa.letters\"\n besa_ap.title = \"Letter to Aphthonia\"\n besa_ap.slug = \"to_aphthonia\"\n besa_ap.urn_code = \"besa.aphthonia\"\n besa_ap.github = \"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\"\n\n fox = Corpus()\n fox.annis_corpus_name = \"shenoute.fox\"\n fox.title = \"Not Because a Fox Barks\"\n fox.slug = \"not_because_a_fox_barks\"\n fox.urn_code = \"shenoute.fox\"\n fox.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-fox\"\n\n mark = Corpus()\n mark.annis_corpus_name = \"sahidica.mark\"\n mark.title = \"Gospel of Mark\"\n mark.slug = \"gospel_of_mark\"\n mark.urn_code = \"nt.mark\"\n mark.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n corinth = Corpus()\n corinth.annis_corpus_name = \"sahidica.1corinthians\"\n corinth.title = \"1 Corinthians\"\n corinth.slug = \"1st_corinthians\"\n corinth.urn_code = \"nt.1cor\"\n corinth.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n snt = Corpus()\n snt.annis_corpus_name = \"sahidica.nt\"\n snt.title = \"New Testament\"\n snt.slug = \"new-testament\"\n snt.urn_code = \"nt\"\n snt.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n eager = Corpus()\n eager.annis_corpus_name = \"shenoute.eagerness\"\n eager.title = \"I See Your Eagerness\"\n eager.slug = \"eagernesss\"\n eager.urn_code = \"shenoute.eagerness\"\n eager.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-eagerness\"\n\n besa_nuns = Corpus()\n besa_nuns.annis_corpus_name = \"besa.letters\"\n besa_nuns.title = \"Letter to Thieving Nuns\"\n besa_nuns.slug = \"to_thieving_nuns\"\n besa_nuns.urn_code = \"besa.thieving\"\n besa_nuns.github = \"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\"\n\n doc_pap = Corpus()\n doc_pap.annis_corpus_name = \"doc.papyri\"\n doc_pap.title = \"Documentary Papyri\"\n doc_pap.slug = \"papyri\"\n doc_pap.urn_code = \"copticDoc:papyri_info\"\n doc_pap.github = \"https://github.com/CopticScriptorium/corpora/tree/master/doc-papyri\"\n\n known_corpora = [shenoute_a22, patrum, saof, besa_ap, fox, mark, corinth, snt, eager, besa_nuns, doc_pap]\n# known_corpora = [shenoute_a22]\n \n for one in known_corpora:\n try:\n Corpus.objects.get(slug__exact=one.slug)\n except Corpus.DoesNotExist:\n one.save()","def name_synonym_lookup(self, fbids):\n if not fbids:\n warnings.warn(\"Empty fbid list provided to name_synonym_lookup\")\n return False\n # stypes: symbol nickname synonym fullname\n query = \"SELECT f.uniquename as fbid, s.name as ascii_name, \" \\\n \"stype.name AS stype, \" \\\n \"fs.is_current, s.synonym_sgml as unicode_name \" \\\n \"FROM feature f \" \\\n \"JOIN feature_synonym fs on (f.feature_id=fs.feature_id) \" \\\n \"JOIN synonym s on (fs.synonym_id=s.synonym_id) \" \\\n \"JOIN cvterm stype on (s.type_id=stype.cvterm_id) \" \\\n \"WHERE f.uniquename IN ('%s')\"\n dc = self.query_fb(query % \"','\".join(fbids))\n results = {}\n old_key = ''\n out = {}\n for d in dc:\n key = d['fbid']\n if not (key == old_key):\n if out:\n results[old_key] = Feature(**out)\n out = {}\n out['fbid'] = key\n out['iri'] = map_iri('fb') + key\n out['synonyms'] = set()\n if d['stype'] == 'symbol' and d['is_current']:\n out['symbol'] = clean_sgml_tags(d['unicode_name'])\n else:\n out['synonyms'].add(clean_sgml_tags(d['ascii_name']))\n out['synonyms'].add(clean_sgml_tags(d['unicode_name']))\n old_key = key\n return results","def SetKeyWords(self, kw_lst):\n # Parse Keyword Settings List simply ignoring bad values and badly\n # formed lists\n self._code['keywords'] = list()\n kwlist = \"\"\n for keyw in kw_lst:\n if len(keyw) != 2:\n continue\n else:\n if not isinstance(keyw[0], int) or \\\n not isinstance(keyw[1], basestring):\n continue\n else:\n kwlist += keyw[1]\n super(EditraBaseStc, self).SetKeyWords(keyw[0], keyw[1])\n\n # Can't have ? in scintilla autocomp list unless specifying an image\n # TODO: this should be handled by the autocomp service\n if '?' in kwlist:\n kwlist.replace('?', '')\n\n kwlist = kwlist.split() # Split into a list of words\n kwlist = list(set(kwlist)) # Remove duplicates from the list\n kwlist.sort() # Sort into alphabetical order\n\n self._code['keywords'] = kwlist","def nsrGenera(taxonList, synonymList):\r\n species = list(filter(None, sorted(taxonList + synonymList)))\r\n generaList = [i.split()[0] for i in species]\r\n generaList = list(dict.fromkeys(generaList))\r\n return generaList","def get_wordlists():\n\n\tCS = {'ACM', 'IEEE', 'Computer Science', 'Artificial Intelligence',\n\t\t'Pattern Recognition', 'Computer Vision', 'Machine Learning',\n\t\t'Signal Processing', 'Electrical Engineering', 'Image Processing',\n\t\t'Data Mining', 'Neural Networks', 'Computer Graphics', 'Graphics',\n\t\t'Language Processing', 'Internet', 'Intelligent Systems',\n\t\t'Robotic','Data','Software', 'Machine Vision', 'Image Analysis',\n\t\t'Scientific Computing', 'SIAM', 'Malware','World Wide Web', \n\t\t'Computational Intelligence', 'Computational Linguistics',\n\t\t'Computational linguistics','Algorithm','Computer','ITiCSE',\n\t\t'ITICSE','Machine learning','Learning','learning',\n\t\t'Artificial intelligence','CIVR','Document Analysis'}\n\n\tbio = {'Biology', 'Microbiology', 'Molecular', 'Medical', 'Biological',\n\t\t'Cancer', 'Genome', 'Bioinformatics', 'Protein', 'Biocomputing',\n\t\t'Biomedical', 'biology', 'Medicine', 'Biosystems', 'Virology',\n\t\t'Brain', 'Psychology', 'Genetics', 'Bioengineering', 'Cell',\n\t\t'Cardiology', 'Metabolic', 'Biotechnology', 'Pathogens',\n\t\t'Pathology', 'Plant', 'PLANT', 'Virus', 'Drug','Medicinal',\n\t\t'Neuro','Psych',\n\t\t'Genomic','Diseases','Endocrinology', 'Epidemiology',\n\t\t'Proteom','Biochem', 'DNA', 'Pharma', 'Biomedic', 'biomedica',\n\t\t'Neurobiological'}\n\n\tmath = {'Mathemati','Markov','Probability','Algebra','Network',\n\t\t'Topology','Optimization', 'Geometr','Statistic','Algorithm',\n\t\t'Graph ','Graphs','Combinatori','Riemann Surfaces','Permutation Groups',\n\t\t'Functional Analysis', 'SIAM','Fixed Point','Wavelet','Statistics',\n\t\t'Linear Regression','Fractal','geometry','Multivariate','Chaos',\n\t\t'mathemati','Kernel'}\n\n\tlinguistics = {}\n\n\tcomputer_vision = {}\n\n\tchemistry = {}\n\n\tphysics = {}\n\n\t# Rename \"Computer Vision\" to \"Image Processing\"?\n\ttopic_names = ['Computer Science','Biology','Mathematics','Chemistry',\n\t\t'Physics','Computer Vision','Natural Language Processing']\n\ttopics = [CS, bio, math]#, linguistics, computer_vision, chemistry, physics]\n\n\treturn {topic_names[i]:topics[i] for i in range(len(topics))}","def testSynonym(self):\n\n\t\t\t\tone = spinner.Word.objects.get_single('mac', True)\n\t\t\t\ttwo = spinner.Word.objects.get_single('macintosh', True)\n\n\t\t\t\tsyn = spinner.Synonym.objects.get_single(one, two, True)\n\t\t\t\tassert isinstance(syn, spinner.Synonym), syn\n\t\t\t\t\n\t\t\t\tsyn.delete()\n\t\t\t\tone.delete()\n\t\t\t\ttwo.delete()","def synonyms(self):\n\n return [synonym[\"name\"] for synonym in self._get_synonym_json()]","def __insert_random_synonym(self, tokenized_sentence: list) -> str:\n sentence_length = len(tokenized_sentence)\n # Initialize the return string\n new_sentence = \"\"\n # Some variables to keep track of changes and attempted changes\n has_changed = False\n attempts = 0\n # Keep trying to make a change until either:\n # 1) You've made a change, OR\n # 2) You've tried to make a change for half the words in the sentence with no success\n while has_changed is not True and attempts <= sentence_length/2:\n # Grab a random word from the tokenized sentence\n index_to_get_word_from = random.randint(0, sentence_length-1)\n pair_to_get_word_from = tokenized_sentence[index_to_get_word_from]\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_get_word_from)\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \n if len(list_of_syns) < 1: \n # Failed synonym swap, so bump up the attempts tracker by one\n attempts += 1\n continue\n # Else, the word does have synonyms we can swap the word for\n else:\n # Randomly pick a word from the synonym list\n random_pick = random.randint(0, len(list_of_syns)-1)\n new_word = list_of_syns[random_pick]\n new_word_pair = (new_word, \"NA\") # \"NA\" is a dummy POS tag\n # Now randomly find a spot to put the new word\n index_to_place_new_word = random.randint(0, sentence_length-1)\n # Now update the tokenized sentence with the new word\n tokenized_sentence.insert(index_to_place_new_word, new_word_pair)\n sentence_length += 1\n # Pull the sentence back together\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\n # Now let's clean up our brand new sentence really quickly\n new_sentence = nltk_methods.clean_sentence(new_sentence)\n # BUT WAIT, what if this is a duplicate? We don't want that!\n if new_sentence in self.return_augmented_sentences():\n # Bump up the attempts and skip this sentence\n attempts += 1\n continue\n # Update the flags\n has_changed = True\n return new_sentence","def synonyms_keyword(self, p_keyword):\n pass","def get_synsets(words):\n synsets = {}\n for word in words:\n for syn in wn.synsets(word):\n synsets[syn.name] = tuple([lemma.name for lemma in syn.lemmas])\n return synsets","def setWordKnown(self):\n self.wordKnown = ''.join(['_ ' if w not in self.guessedRight else w for w in self.getWord()])","def store_names(self):\n # clear the text buffer, or create new buffer\n try:\n namestxt = bpy.data.texts[\"FullNames\"]\n namestxt.clear()\n except KeyError:\n namestxt = bpy.data.texts.new(\"FullNames\")\n \n # write the names to the text buffer\n for block, shortname in self.nif_import.dict_names.items():\n block_name = block.name.decode()\n if block_name and shortname != block_name:\n namestxt.write('%s;%s\\n' % (shortname, block_name))","def get_chebi_synonyms(chebi_ent):\n if hasattr(chebi_ent, 'Synonyms'):\n return [entry.data for entry in chebi_ent.Synonyms]\n else:\n return []","def learn_words(self):\n codebook = N.array(self.vowel_map.keys())\n for i in range(len(self.memory)):\n codes, dist = vq.vq(self.memory[i], codebook)\n self.stems[i] = N.array([self.vowel_map[tuple(codebook[x])] for x\n in codes])\n return self.stems","def index_terms(self):\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\n self.doc_store.dict.iteritems()]","def __synonym_replacement(self, tokenized_sentence: list) -> str:\n sentence_length = len(tokenized_sentence)\n # Initialize the return string\n new_sentence = \"\"\n # Some variables to keep track of changes and attempted changes\n has_changed = False\n attempts = 0\n # Keep trying to make a change until either:\n # 1) You've made a change, OR\n # 2) You've tried to make a change for half the words in the sentence with no success\n while has_changed is not True and attempts <= sentence_length/2:\n # Grab a random word from the tokenized sentence\n index_to_change = random.randint(0, sentence_length-1)\n pair_to_change = tokenized_sentence[index_to_change]\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_change)\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \n if len(list_of_syns) < 1: \n # Failed synonym swap, so bump up the attempts tracker by one\n attempts += 1\n continue\n # Else, the word does have synonyms we can swap the word for\n else:\n # Randomly pick a word from the synonym list\n random_pick = random.randint(0, len(list_of_syns)-1)\n new_word = list_of_syns[random_pick]\n new_word_pair = (new_word, \"NA\") # \"NA\" is a dummy POS tag\n # Now update the tokenized sentence with the new word\n tokenized_sentence[index_to_change] = new_word_pair\n # Pull the sentence back together\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\n # Now let's clean up our brand new sentence really quickly\n new_sentence = nltk_methods.clean_sentence(new_sentence)\n # BUT WAIT, what if this is a duplicate? We don't want that!\n if new_sentence in self.return_augmented_sentences():\n # Bump up the attempts and skip this sentence\n attempts += 1\n continue\n # Update the flags\n has_changed = True\n return new_sentence","def wordnet_synsets(self):\n new_var = \"n_synsets\"\n wn_lemmas = [l.encode('ascii') for l in wn.all_lemma_names()]\n has_item = self.compare_items(wn_lemmas)\n new_column = []\n if False in has_item:\n self._warning_msg('wordnet_synsets', wn_lemmas)\n for record, exists in zip(self._dict, has_item):\n if exists:\n n_synsets = len(wn.synsets(record))\n else:\n n_synsets = None\n new_column.append(n_synsets)\n self._append_column(new_column, new_var)","def set_subhead_searched_words(self):\n\n searched_words = []\n for i in range(self.subhead.shape[0]):\n if (\n self.subhead[\"searched_pair_word\"][i]\n in self.subhead[\"searched_unique_single_word_synonym\"][i]\n ):\n searched_words.append(\n self.subhead[\"searched_unique_single_word_synonym\"][i]\n )\n else:\n searched_words.append(\n self.subhead[\"searched_unique_single_word_synonym\"][i]\n + self.subhead[\"searched_pair_word\"][i]\n )\n self.subhead[\"searched_words\"] = searched_words","def main():\n namelst = open('cor_lamp.lst').readlines()\n namelst = ['awftbo'+i.strip() for i in namelst]\n for name in namelst:\n cor_keyword(name)\n func.set_airmass(name)","def build_sublemma_index(self):\n terms = []\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\n for line in f:\n term = line.strip('\\n')\n terms.append(term)\n terms = set(terms)\n for term in terms:\n term_list = term.split('_')\n subterms = get_sublists(term_list)\n self.sublemma_index[term] = [t for t in subterms if t in terms]","def reload_term_meta(self):\n result = self.execute_prepared_query(\"get_classes\")\n self.classes = set([row[0] for row in result])\n\n result = self.execute_prepared_query(\"get_properties\")\n self.properties = set([row[0] for row in result])\n\n result = self.execute_prepared_query(\"get_term_to_label\")\n self.term_to_label = {row[0]: row[1].toPython().strip() for row in result}\n\n result = self.execute_prepared_query(\"get_term_to_desc\")\n self.term_to_desc = {row[0]: row[1].toPython() for row in result}","def add_sr_synonyms(self,\n seq_region_file: str,\n seq_region_map: dict,\n external_db_map: dict,\n work_dir: str,\n unversion: bool = False,\n unversionable_sources_set: frozenset = frozenset([\"INSDC\", \"RefSeq\"])):\n os.makedirs(work_dir, exist_ok=True)\n\n # return if there's nothing to add\n if not seq_region_file: return\n\n # get seq_region ids, names, syns from db\n synonyms_trios_db = self.load_seq_region_synonyms_trios_from_core_db(self.pjc(work_dir, \"syns_from_core\"))\n\n # form set of synonyms already present in db\n synonyms_in_db = frozenset( [trio[2] for trio in synonyms_trios_db if trio[2] != \"NULL\"] )\n\n # subset of sources to use the allowed the unversion synonyms\n unversionable_sources = unversion and unversionable_sources_set or frozenset()\n\n # technical / optimization. get external_db_id for \"ensembl_internal_synonym\"\n ensembl_internal_synonym_ext_db_id = self.id_from_map_or_die(\"ensembl_internal_synonym\", external_db_map, \"external_db_map\")\n\n # get dict for additional mapping for sources to external_db names if there's one specified by \"external_db_map\" module param\n # not to be confused with the external_db_map function parameter above\n additional_sources_mapping = self.get_external_db_mapping()\n\n # load synonyms from the json file\n synonyms_from_json = [] # [ (seq_region_id, synonym, external_db_id)... ] list of trios for inserting into db \n with open(seq_region_file) as in_file:\n seq_regions = list(json.load(in_file))\n for seq_region in filter(lambda sr: sr.get(\"synonyms\", False), seq_regions):\n # iterate through all seq_regions having \"synonyms\" \n seq_region_name, seq_region_id, _ = \\\n self.name_and_id_from_seq_region_item(seq_region, seq_region_map, try_unversion = unversion)\n\n # fill synonyms_from_json list of trios\n for synonym_item in list(seq_region[\"synonyms\"]):\n synonym_name = synonym_item[\"name\"]\n source = synonym_item[\"source\"]\n unversioned_name = \"\"\n\n # check if there's any addtional mapping for the source, remap if so\n if additional_sources_mapping:\n source = additional_sources_mapping.get(source, source) # use the same name if no matches in additional_sources_mapping dict\n\n # try to get unversioned name if applicable \n if source in unversionable_sources:\n unversioned_name = re.sub(r\"\\.\\d+$\", \"\", synonym_name)\n\n # put trios if names are not already seen in db \n if synonym_name not in synonyms_in_db:\n external_db_id = self.id_from_map_or_die(source, external_db_map, \"external_db_map\")\n synonyms_from_json.append( (seq_region_id, self.quote_or_null(synonym_name), external_db_id) )\n\n # put additional unversioned synonyms if there's a sane one\n if unversioned_name \\\n and unversioned_name != synonym_name \\\n and unversioned_name not in synonyms_in_db:\n synonyms_from_json.append( (seq_region_id, self.quote_or_null(unversioned_name), ensembl_internal_synonym_ext_db_id) )\n\n # run insertion SQL\n self.insert_to_db(\n synonyms_from_json,\n \"seq_region_synonym\",\n [\"seq_region_id\", \"synonym\", \"external_db_id\"],\n self.pjc(work_dir, \"new_seq_region_synonyms\"),\n ignore = True\n )","def __settle_ttl(self):\n self.ttl = {}\n for v in self.g.nodes():\n indices = [self.universe.index((v, w))\n for w in self.g[v] if (v, w) in self.universe]\n self.ttl[v] = max(indices) if len(indices) else 0","def load_seq_region_synonyms_trios_from_core_db(self, work_dir: str) -> list:\n # was get_db_syns\n out_pfx = self.pjc(work_dir, f\"seq_region_synonyms\")\n sql = r'''select sr.seq_region_id as seq_region_id, sr.name, srs.synonym\n from seq_region sr left join seq_region_synonym srs\n on sr.seq_region_id = srs.seq_region_id\n order by sr.seq_region_id\n ;'''\n\n res = self.run_sql_req(sql, out_pfx)\n\n syn_trios = []\n out_file = out_pfx + \".stdout\"\n with open(out_file) as syns_file:\n skip_header = True\n for line in syns_file:\n if skip_header:\n skip_header = False\n continue\n (sr_id, name, syn) = line.strip().split(\"\\t\")\n syn_trios.append( (sr_id, name, syn) )\n return syn_trios","def copy_sr_name_to_syn(self, cs, x_db, log_pfx):\n asm_v = self.asm_name()\n sql = r'''insert into seq_region_synonym (seq_region_id, synonym, external_db_id)\n select\n sr.seq_region_id, sr.name, xdb.external_db_id\n from\n seq_region sr, external_db xdb, coord_system cs\n where xdb.db_name = \"%s\"\n and sr.coord_system_id = cs.coord_system_id\n and cs.name = \"%s\"\n and cs.version = \"%s\"\n and sr.name like \"%%._\"\n ;''' % (x_db, cs, asm_v)\n return self.run_sql_req(sql, log_pfx)","def populate_lexical():\n in_dir = os.path.join(buildconfig.FORM_INDEX_DIR, 'refined')\n frequency_cutoff = buildconfig.FREQUENCY_CUTOFF\n\n taxonomy = LanguageTaxonomy()\n lemma_counter = 0\n definition_counter = 0\n\n for letter in string.ascii_lowercase:\n stdout.write('Inserting data for %s...\\n' % letter)\n blocks = []\n in_file = os.path.join(in_dir, letter + '.json')\n with open(in_file, 'r') as filehandle:\n for line in filehandle:\n data = json.loads(line.strip())\n blocks.append(BlockData(*data))\n\n lemmas = []\n wordforms = []\n definitions = []\n for i, block in enumerate(blocks):\n lang_node = taxonomy.node(language=block.language)\n if lang_node is None:\n language_id = None\n else:\n language_id = lang_node.id\n\n if block.definition and block.f2000 < frequency_cutoff:\n definition_counter += 1\n definitions.append(Definition(id=definition_counter,\n text=block.definition[:100]))\n definition_id = definition_counter\n else:\n definition_id = None\n\n lemma_counter += 1\n lemmas.append(Lemma(id=lemma_counter,\n lemma=block.lemma,\n sort=block.sort,\n wordclass=block.wordclass,\n firstyear=block.start,\n lastyear=block.end,\n refentry=block.refentry,\n refid=block.refid,\n thesaurus_id=block.htlink,\n language_id=language_id,\n definition_id=definition_id,\n f2000=_rounder(block.f2000),\n f1950=_rounder(block.f1950),\n f1900=_rounder(block.f1900),\n f1850=_rounder(block.f1850),\n f1800=_rounder(block.f1800),\n f1750=_rounder(block.f1750),))\n\n for typelist in (block.standard_types,\n block.variant_types,\n block.alien_types):\n for typeunit in typelist:\n wordforms.append(Wordform(sort=typeunit[0],\n wordform=typeunit[1],\n wordclass=typeunit[2],\n lemma_id=lemma_counter,\n f2000=_rounder(typeunit[4]),\n f1900=_rounder(typeunit[5]),\n f1800=_rounder(typeunit[6]),))\n\n if i % 1000 == 0:\n Definition.objects.bulk_create(definitions)\n Lemma.objects.bulk_create(lemmas)\n Wordform.objects.bulk_create(wordforms)\n definitions = []\n lemmas = []\n wordforms = []\n\n Definition.objects.bulk_create(definitions)\n Lemma.objects.bulk_create(lemmas)\n Wordform.objects.bulk_create(wordforms)","def applyStemFilter(self):\n \n \"\"\"\n 027 Steps to do:\n 1 Create temporary table with all \"candidates\".\n 2 Select one line from temp_bow\n 3 Issue the stem\n 4 Select from bow result od stem\n 5a If exists do mergelines\n 5b Else nothing\n 6 Remove processed line from temp_bow \n \n \"\"\"\n\n if not hasattr(self,\"stemmer\"): # 027 This is to really initialize stemmer.\n self.initializeStemer() \n if not hasattr(self,\"stemmer\") or not self.stemmer : # 027 This is to check if initialization succeded.\n self.logger.error(\"Stemization failed, because stemmer is not initialized.\")\n else:\n # 027 1 Create temporary table:\n # 027 Only survives with a current cursor instance\n sql=\"create temporary table BOW_plural_candidates as select * from BOW where word like '%s';\"\n args=()\n self.DBcursor.execute(sql,args)\n register=[] # 027 Registers which lines were modified to prevent overwrite in second modification.\n for cx in range(self.getTableLinesCount(\"BOW_plural_candidates\",\"bow_id\")):\n # 027 2 Select one line from temp_bow\n sql=\"select * from BOW_plural_candidates limit 1;\"\n args=()\n self.DBcursor.execute(sql,args)\n line = self.DBcursor.fetchone()\n if line:\n # 027 3 Issue the stem\n stemmedWord=self.stemmer.stemWord(line[1])\n else:\n stemmedWord=\"\"\n self.logger.debug(\"Got wrong input for stemization: %s\"%(str(line))) \n line=[None,None]\n if not self.getTableLinesCount(\"BOW_plural_candidates\", \"bow_id\"):\n self.logger.debug(\"Bow plural candidates table is empty. Ending.\")\n break\n if stemmedWord in register:\n self.logger.debug(\"Doing commit because word %s was found in register.\"%(stemmedWord)) \n self.DBconnection.commit()\n if not stemmedWord == line[1]:\n # 027 4 Select from bow result od stem\n sql=\"select * from BOW where word like ?\"\n args=(stemmedWord,)\n self.DBcursor.execute(sql,args)\n singularCandidate = self.DBcursor.fetchall()\n # 027 5a If exists do mergelines\n # 027 Lines get merged only when there is exactly one line matching line.\n # 027 If the stemmed word doesn't match anything original word is preserved.\n # 027 More line - shall not happen. \n if len(singularCandidate)==1: \n self.mergeLines(singularCandidate[0][0], line[0])\n register.append(stemmedWord)\n self.logger.debug(\" Line %i with word %s was merged to line %i with word %s\"%(line[0],line[1],singularCandidate[0][0],singularCandidate[0][1])) \n # 027 6 Remove processed line from temp_bow \n sql=\"delete from BOW_plural_candidates where bow_id=?;\"\n args=(line[0],)\n self.DBcursor.execute(sql,args)\n self.DBconnection.commit()","def create_tokens_li():\n cnt=0\n for file in docs:\n file_name = open(\"./corpus/\"+ str(file) + \".txt\")\n print(cnt)\n cnt+=1\n words = file_name.read()\n tokens_doc = nltk.word_tokenize(words)\n tokens_doc = [w.lower() for w in tokens_doc]\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\n tokens_li.append(tokens_doc)\n\n\n #storing in json file\n with open('savers/tokens.json', 'w') as fp:\n json.dump(tokens_li, fp)","def attr_synonyms(self):\n if self._modifier_exists(DUPLICATED_KEY):\n synonyms = self[CONFIG_KEY][SAMPLE_MODS_KEY][DUPLICATED_KEY]\n _LOGGER.debug(\"Applying synonyms: {}\".format(synonyms))\n for sample in self.samples:\n for attr, new in list(synonyms.items()):\n if attr in sample:\n setattr(sample, new, getattr(sample, attr))","def test_synonym(self): \n pass","def scrapeSynonym(word,key='b08CVJHscZ6rRGfc7MzS',language='en_US', max=5):\n endpoint = \"http://thesaurus.altervista.org/thesaurus/v1\"\n url = endpoint + \"?word={}&language={}&key={}&output=json\".format(word,language,key)\n r = requests.request('GET', url, timeout=5.0)\n if r.status_code == 200:\n try:\n syns = r.json()['response'][0]['list']['synonyms'].split('|')\n except KeyError or TypeError:\n return None\n\n del syns[max:]\n for i in range(len(syns)):\n syns[i] = syns[i].split(' ')[0] \n\n return {'word' : word,'syns' : syns}","def test_syndome_LUT(self):\r\n syns = []\r\n errvecs = golay._make_3bit_errors()\r\n for errvec in errvecs:\r\n syn = tuple(numpy.mod(numpy.dot(errvec, golay.DEFAULT_H.T), 2))\r\n syns.append(syn)\r\n self.assertEqual(set(syns), set(golay.DEFAULT_SYNDROME_LUT.keys()))\r\n self.assertEqual(len(set(syns)), len(syns))\r\n self.assertEqual(len(syns), len(errvecs))\r\n self.assertEqual(len(errvecs), 2325)","def aliases():\n fetch(\"PropertyValueAliases.txt\")\n longforms = {}\n shortforms = {}\n re1 = re.compile(r\"^ *sc *; *(\\w+) *; *(\\w+)\")\n for line in fileinput.input(os.path.basename(\"PropertyValueAliases.txt\")):\n m = re1.match(line)\n if m:\n l = m.group(2).strip()\n s = m.group(1).strip()\n assert(s not in longforms)\n assert(l not in shortforms)\n longforms[s] = l\n shortforms[l] = s\n else:\n continue\n\n return (longforms, shortforms)","def add_entry(wn, synset, lemma, idx=0, n=-1, change_list=None):\n print(\"Adding %s to synset %s\" % (lemma, synset.id))\n n_entries = len(empty_if_none(wn.members_by_id(synset.id)))\n entry_global = [entry for entry in empty_if_none(wn.entry_by_lemma(lemma))\n if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech or\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE and synset.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE or\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE and synset.part_of_speech == PartOfSpeech.ADJECTIVE]\n\n if len(entry_global) == 1:\n entry_global = wn.entry_by_id(entry_global[0])\n n_senses = len(entry_global.senses)\n else:\n entry_global = None\n n_senses = 0\n\n if idx <= 0:\n idx = n_entries + 1\n elif idx > n_entries + 1:\n raise Exception(\"IDX value specified is higher than number of entries\")\n elif idx == n_entries + 1:\n pass\n else:\n for sense_id in sense_ids_for_synset(wn, synset):\n this_idx = int(sense_id[-2:])\n if this_idx >= idx:\n change_sense_idx(wn, sense_id, this_idx + 1)\n\n if n < 0:\n n = n_senses\n elif n > n_senses:\n raise Exception(\"n value exceeds number of senses for lemma\")\n elif n == n_senses:\n pass\n else:\n sense_n = 0\n for sense in entry_global.senses:\n if sense_n >= n:\n change_sense_n(wn, entry_global, sense.id, sense_n + 1)\n sense_n += 1\n\n wn_synset = wn\n entries = [entry for entry in empty_if_none(wn_synset.entry_by_lemma(\n lemma)) if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech]\n\n if entries:\n if len(entries) != 1:\n raise Exception(\"More than one entry for part of speech\")\n print(\"Found an entry!\")\n wn_entry = wn.entry_by_id(entries[0])\n entry = wn_synset.entry_by_id(entries[0])\n sense = Sense(\n id=\"oewn-%s-%s-%s-%02d\" %\n (escape_lemma(lemma),\n synset.part_of_speech.value,\n synset_key(\n synset.id),\n idx),\n synset=synset.id,\n n=n,\n sense_key=None)\n\n wn_entry.senses.append(sense)\n entry.senses.append(sense)\n sense.sense_key = get_sense_key(wn, entry, sense, synset.lex_name)\n if sense.synset not in wn.members:\n wn.members[sense.synset] = []\n wn.members[sense.synset].append(wn_entry.lemma.written_form)\n else:\n n = 0\n print(\"Creating new entry\")\n entry = LexicalEntry(\n \"oewn-%s-%s\" % (escape_lemma(lemma), synset.part_of_speech.value))\n entry.set_lemma(Lemma(lemma, synset.part_of_speech))\n sense = Sense(\n id=\"oewn-%s-%s-%s-%02d\" %\n (escape_lemma(lemma),\n synset.part_of_speech.value,\n synset_key(\n synset.id),\n idx),\n synset=synset.id,\n n=n,\n sense_key=None)\n entry.add_sense(sense)\n sense.sense_key = get_sense_key(wn, entry, sense, synset.lex_name)\n wn.add_entry(entry)\n if change_list:\n change_list.change_entry(wn, entry)\n return entry","def senses(self):\n sense_set = wordnet.synsets(self.text)\n\n result = list()\n for s in sense_set:\n result.append(s.lemma_names())\n\n return result","def store_wn_lookup():\n syns = list( wn.all_synsets() )\n #syn_str = map(lambda s: str(s).replace(\"Synset\",'').strip('()').strip(\"'\"), syns)\n syn_str = map(lambda s: str(s).replace(\"Synset\",'').strip('()').strip(\"'\").strip('\"'), syns)\n #offsets_list = [(\"n%08d\" % s.offset, s) for s in syns]\n olist = map(lambda a, b: (\"n%08d\" % a.offset, b), syns, syn_str)\n offset_dict = dict(olist)\n pickle.dump(offset_dict, open('/Users/xlx/Documents/proj/imgnet-flickr/db3/wn_offset_dict.pickle', 'wb'))","def get_synsets_rt(word: str) -> List:\n return rt.categories(word)","def init_auto_alias(self):\n for alias,cmd in self.auto_alias:\n self.alias_table[alias] = (0,cmd)","def Adjust_Keyword_List( self ):\r\n listing = list( self.system.Get_Term_List( ) ) #get the term list of the current profile\r\n\r\n d=ExpressionAdjust.ExpressionAdjuster( self.root, listing, 'Keywords' )\r\n if(d.return_state==0):\r\n return #Cancel hit\r\n self.system.Set_Term_List( d.profile_list )\r\n self.system.Apply_Profile_Term_List_2()","def setLemmas(self, lemmas):\n ankiwords = [Ankiword.fromLemma(lemma) for lemma in lemmas]\n\n # now find words from anki database and add it to list\n letterings = {ankiword.lettering for ankiword in ankiwords}\n for lettering in letterings:\n ankiwords.extend(self.ankiInterface.findAnkiwords(lettering))\n\n self.ankiwordListWidget.resetAnkiwordList(ankiwords)","def test_term_list_removes_duplicates():\n term = SplineTerm(0)\n term_list = term + term\n\n assert isinstance(term_list, TermList)\n assert len(term_list) == 1","def sents_2(list_of_tweets):\n stopwords = nltk.corpus.stopwords.words('english')\n contextTerms = []\n for sent in list_of_tweets:\n for word in sent.split():\n word_lemmatizer = WordNetLemmatizer()\n word = word_lemmatizer.lemmatize(word.lower())\n if wordnet.synsets(word) and word not in stopwords and len(word)>2:\n contextTerms.append(word)\n\n #print( contextTerms)\n return contextTerms","def synonyms_wiktionary(name, lang=\"fr\"):\n import wptools\n page = wptools.page(name, wiki='{0}.wiktionary.org'.format(\n lang), lang=lang, silent=True)\n page.get_parse()\n text = page.data['wikitext']\n syn = \"==== {{S|synonymes}} ====\"\n if syn not in text:\n return None\n text = text.split(syn)[1].split(\"====\")[0]\n reg = re.compile(\"[[]{2}(.*?)[]]{2}\")\n res = reg.findall(text)\n return res","def ingest_synonym(\n cls,\n app_namespace,\n index_name,\n index_type=INDEX_TYPE_SYNONYM,\n field_name=None,\n data=None,\n es_host=None,\n es_client=None,\n use_double_metaphone=False,\n ):\n data = data or []\n\n def _action_generator(docs):\n\n for doc in docs:\n action = {}\n\n # id\n if doc.get(\"id\"):\n action[\"_id\"] = doc[\"id\"]\n else:\n # generate hash from canonical name as ID\n action[\"_id\"] = hashlib.sha256(\n doc.get(\"cname\").encode(\"utf-8\")\n ).hexdigest()\n\n # synonym whitelist\n whitelist = doc[\"whitelist\"]\n syn_list = []\n syn_list.append({\"name\": doc[\"cname\"]})\n for syn in whitelist:\n syn_list.append({\"name\": syn})\n\n # If index type is INDEX_TYPE_KB we import the synonym into knowledge base object\n # index by updating the knowledge base object with additional synonym whitelist\n # field. Otherwise, by default we import to synonym index in ES.\n if index_type == INDEX_TYPE_KB and field_name:\n syn_field = field_name + \"$whitelist\"\n action[\"_op_type\"] = \"update\"\n action[\"doc\"] = {syn_field: syn_list}\n else:\n action.update(doc)\n action[\"whitelist\"] = syn_list\n\n yield action\n\n mapping = (\n PHONETIC_ES_SYNONYM_MAPPING\n if use_double_metaphone\n else DEFAULT_ES_SYNONYM_MAPPING\n )\n es_client = es_client or create_es_client(es_host)\n mapping = resolve_es_config_for_version(mapping, es_client)\n load_index(\n app_namespace,\n index_name,\n _action_generator(data),\n len(data),\n mapping,\n DOC_TYPE,\n es_host,\n es_client,\n )","def get_synset(self, word):\n #word = word.decode('utf-8')\n if word in self.SYNSET_CACHE:\n return self.SYNSET_CACHE[word]\n else:\n synset = set(wn.synsets(word))\n self.SYNSET_CACHE[word] = synset\n return synset","def make_words(self,lm):\n if \" \" in self.corpus[0] and \" \" in self.corpus[1]: \n print \"assuming BLICK\"\n self.corpus = [convert_to_disc(i) for i in self.corpus]\n else:\n self.disc = 1\n print \"assuming Disc\" \n if not os.path.isfile(self.f): ##check if it already exists\n print \"generating 10 million words\"\n outfile = open(self.f, \"w\")\n outfile.write(\"word,blick,ngram,Real,T,disc\\n\")\n for word in self.corpus:\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Real\", \"1\")\n while len(self.wordlist)<10000000: \n words = lm.generate(100)\n for word in words:\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\n write_row_of_bigmatch(word, self.disc, outfile, lm, \"Simulated\", \"0\")\n self.wordlist[word] = 0\n return","def change_entry(wn, synset, target_synset, lemma, change_list=None):\n print(\"Adding %s to synset %s\" % (lemma, synset.id))\n n_entries = len(empty_if_none(wn.members_by_id(target_synset.id)))\n entry_global = [entry for entry in empty_if_none(wn.entry_by_lemma(lemma))\n if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech or\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE and synset.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE or\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE and synset.part_of_speech == PartOfSpeech.ADJECTIVE]\n\n if len(entry_global) == 1:\n entry_global = wn.entry_by_id(entry_global[0])\n n_senses = len(entry_global.senses)\n else:\n entry_global = None\n n_senses = 0\n\n idx = n_entries + 1\n n = n_senses\n\n wn_synset = wn\n entries = [entry for entry in empty_if_none(wn_synset.entry_by_lemma(\n lemma)) if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech]\n\n for entry in entries:\n for sense in wn_synset.entry_by_id(entry).senses:\n if sense.synset == synset.id:\n print(\"Moving %s to %s\" % (sense.id, target_synset.id))\n sense.synset = target_synset.id\n wn.change_sense_id(\n sense,\n \"oewn-%s-%s-%s-%02d\" %\n (escape_lemma(lemma),\n target_synset.part_of_speech.value,\n synset_key(\n target_synset.id),\n idx),\n change_list)\n if change_list:\n change_list.change_entry(wn, entry)","def get_possible_synsets(self, word, pos=None):\n candidates = wordnet.synsets(word)\n return [self._synset_dict[SWNEntry.make_unique_key(synset.pos, synset.offset)] for synset in\n candidates]","def update_terms(verbose=False):\n for be in settings.SOCIALDICT_BACKENDS:\n try:\n backends = __import__('socialdict.backends', fromlist=[be])\n backend = getattr(backends, be)\n status = backend.update_database_terms()\n if verbose:\n print \"\\nStatus for '%s'\" % backend.SOURCE\n print_status(status)\n except ImportError, e:\n print e\n pass","def stemmerAplay(self ):\n stemmer = nltk.stem.RSLPStemmer()\n text = []\n for (news, clazz) in self.dataSet:\n comstemmer =[str(stemmer.stem(p)) for p in news.split() if p not in self.stopWords]\n text.append((comstemmer, clazz))\n return text","def _append_CLDR_terms(self, _fallback=dict()):\n if _fallback:\n fallback = _fallback\n else:\n fallback = self.Fallback\n for term, value in CLDR:\n if term and term not in fallback:\n fallback[term] = value\n \n return(fallback)","def set_words(data_path):\n w_df = pd.read_csv(data_path, names=['es','gn','syn1','syn2'], encoding='iso-8859-1') # file -i\n gn_df = w_df[['gn','syn1','syn2']].drop_duplicates()\n gn_lst = gn_df['gn'].tolist()+gn_df['syn1'].tolist()+gn_df['syn2'].tolist()\n cleanedList = [x for x in gn_lst if str(x) != 'nan' and len(x)>=3]\n gn_set = set(cleanedList)\n \n print(len(gn_set))\n \n f = open(data_path[:-4]+\".txt\", 'w')\n for w in gn_set:\n f.write('{}\\n'.format(w))\n f.close()\n \n return list(gn_set)","def analyze_words(self):\n\t\t\n\t\tword_analysis = {}\n\t\tfor word in self.word_list:\n\t\t\tif word not in word_analysis:\n\t\t\t\tacademic = (word in LEMMA_DICT)\n\t\t\t\tlength = len(word)\n\t\t\t\tfrequency = len(self.word_list[word])\n\t\t\t\tstem = word\t\n\t\t\t\tword_location_index = len(self.sentence_index)-1 #first set it as the last index\n\t\t\t\t\n\t\t\t\tfor index, sentence in self.sentence_index.items():\n\t\t\t\t\tif word in sentence.split():#need to be individual words, not parts of a word\n\t\t\t\t\t\tword_location_index = index \n\t\t\t\t\t\tbreak\n\t\t\t\t\tif self.word_list[word][0] in sentence.split():#accounts for words with upper cases\n\t\t\t\t\t\tword_location_index = index\n\t\t\t\t\t\n\t\t\t\t#selection critera\n\t\t\t\tif academic:\n\t\t\t\t\tselection_criteria = 'academic word'\n\t\t\t\telif frequency > 1: \n\t\t\t\t\tselection_criteria = 'high frequency'\n\t\t\t\telse:\n\t\t\t\t\tselection_criteria = 'word length'\n\n\t\t\t\tword_analysis[word] = (academic, length, frequency, stem, word_location_index, selection_criteria)\n\t\t\n\t\tself.word_analysis = word_analysis\n\t\t\n\t\treturn self.word_analysis","def list_syms():\n\tSymStringVec=[];\n\tSymStringVec.append(\"CSYM\");\n\tSymStringVec.append(\"DSYM\");\n\tSymStringVec.append(\"TET_SYM\");\n\tSymStringVec.append(\"OCT_SYM\");\n\tSymStringVec.append(\"ICOS_SYM\");\n\tSymStringVec.append(\"ISYM\");\n\treturn SymStringVec","def assume_alias(self):\n\n es = self.get_es()\n if es.head(self.es_alias):\n #remove all existing aliases - this is destructive and could be harmful, but for current\n #uses, it is legal - in a more delicate routing arrangement, a configuration file of\n # some sort should be in use.\n alias_indices = es[self.es_alias].get('_status')['indices'].keys()\n\n remove_actions = [{\"remove\": {\"index\": x, \"alias\": self.es_alias}} for x in\n alias_indices]\n remove_data = {\"actions\": remove_actions}\n es.post('_aliases', data=remove_data)\n #now reapply HEAD/master index\n es.post('_aliases', data={\"actions\": [{\"add\":\n {\"index\": self.es_index,\n \"alias\": self.es_alias}}]})","def _tokens_to_terms(self, tokens: Sequence[str]) -> List[int]:\n ret = []\n for t in tokens:\n term = self.stemmer(t)\n if term in self.term2id_dict:\n ret.append(self.term2id_dict[term])\n else:\n self.term2id_dict[term] = self.g_term_max_id\n self.id2term_dict[self.g_term_max_id] = term\n ret.append(self.g_term_max_id)\n self.g_term_max_id += 1\n return ret","def ingest_synonym(\n app_namespace,\n index_name,\n index_type=INDEX_TYPE_SYNONYM,\n field_name=None,\n data=None,\n es_host=None,\n es_client=None,\n use_double_metaphone=False,\n ):\n data = data or []\n\n def _action_generator(docs):\n\n for doc in docs:\n action = {}\n\n # id\n if doc.get(\"id\"):\n action[\"_id\"] = doc[\"id\"]\n else:\n # generate hash from canonical name as ID\n action[\"_id\"] = hashlib.sha256(\n doc.get(\"cname\").encode(\"utf-8\")\n ).hexdigest()\n\n # synonym whitelist\n whitelist = doc[\"whitelist\"]\n syn_list = []\n syn_list.append({\"name\": doc[\"cname\"]})\n for syn in whitelist:\n syn_list.append({\"name\": syn})\n\n # If index type is INDEX_TYPE_KB we import the synonym into knowledge base object\n # index by updating the knowledge base object with additional synonym whitelist\n # field. Otherwise, by default we import to synonym index in ES.\n if index_type == INDEX_TYPE_KB and field_name:\n syn_field = field_name + \"$whitelist\"\n action[\"_op_type\"] = \"update\"\n action[\"doc\"] = {syn_field: syn_list}\n else:\n action.update(doc)\n action[\"whitelist\"] = syn_list\n\n yield action\n\n mapping = (\n PHONETIC_ES_SYNONYM_MAPPING\n if use_double_metaphone\n else DEFAULT_ES_SYNONYM_MAPPING\n )\n es_client = es_client or create_es_client(es_host)\n mapping = resolve_es_config_for_version(mapping, es_client)\n load_index(\n app_namespace,\n index_name,\n _action_generator(data),\n len(data),\n mapping,\n DOC_TYPE,\n es_host,\n es_client,\n )","def produce_all_term_data(self):\n # remove cold start records if requested\n test = self.test.copy()\n test = self.handle_cold_start(test)\n\n outputs = self.output()\n trainf, testf = outputs['train'], outputs['test']\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\n self.write_libfm_data(ftrain, ftest, self.train, test)\n\n # Write the term-to-id guide\n test = test.sort(('termnum'))\n test['rownum'] = np.arange(len(test))\n guide = test.groupby('termnum').max()['rownum']\n with self.output()['guide'].open('w') as f:\n guide.to_csv(f, index_label='termnum', header=True)","def stokenizeKBD(TargetQuestionsD, StopWords):\n for i in TargetQuestionsD:\n mqstokens = [] \n for mq in TargetQuestionsD[i][\"matched questions\"]:\n mqstokens.extend(stokenize(mq, StopWords)[:])\n TargetQuestionsD[i][\"mq stokens\"] = mqstokens[:]\n\n TargetQuestionsD[i][\"ans stokens\"] = stokenize(TargetQuestionsD[i][\"answer\"], StopWords)[:]\n \n return \"TargetQuestionsD = {i : {'question': , 'answer': , 'resource': , 'matched questions': [], 'count': , 'mq stokens': [], 'ans stokens': []}}\"","def list_sequence_concept(self, name='list_concepts_found.tsv'):\n # Useful later #\n gi_to_key = lambda gi: self.a.db.get(\"gi\",\"id\",gi)[1]\n key_to_envos = lambda key: marshal.loads(self.a.db.get(\"isolation\",\"id\",key)[2])\n gi_to_envos = lambda gi: key_to_envos(gi_to_key(gi))\n # Loop #\n with open(self.a.out_dir + name, 'w') as handle:\n for seq, gis in self.a.seq_to_gis.items():\n gis = [gi for gi in gis if gi in self.a.db]\n isokeys = set(gi_to_key(gi) for gi in gis)\n envos = [e for key in isokeys for e in key_to_envos(key)]\n for envo in envos:\n seq_name = self.a.renamed_to_orig[seq]\n envo_id = \"ENVO:%08d\" % envo\n concept_name = self.a.integer_to_name.get(envo, envo_id)\n concept_gis = [gi for gi in gis if envo in gi_to_envos(gi)]\n count_gis = len(concept_gis)\n line = (seq_name, envo_id, concept_name, str(count_gis), str(concept_gis))\n handle.write('\\t'.join(line) + '\\n')","def load_synset_vectors(self, babelfied_synset_entry):\n synset_vectors = []\n for synset_id in babelfied_synset_entry.babelfied_synset_ids:\n if len(synset_id) > 0:\n babelfied_synset_pos = synset_id[-1] # wn:06681177n --> n\n if babelfied_synset_pos == \"n\": # is a noun --> it can potentially have a synset embedding\n self.statistics.synset_noun()\n babelfied_synset_id = synset_id[3:-1] # wn:06681177n --> 06681177\n s = babelfied_synset_pos + babelfied_synset_id # wn:06681177n --> n06681177\n if self.synset_embeddings.contains_word(s): \n vector = self.synset_embeddings.word_to_vec(s)\n synset_vectors.append(vector)\n self.statistics.known_synset()\n else:\n self.statistics.unknown_synset()\n \n if len(synset_vectors) == 0: # if no tokens has a synset, this sentence gets the zero_fallback embedding\n synset_vectors = self.synset_embeddings.get_zero_fallback()\n bool_synset_vectors_inSentence = False\n else:\n bool_synset_vectors_inSentence = True\n \n return synset_vectors, bool_synset_vectors_inSentence","def _solve_double_synonym(parse_tree, solution_format=None):\n def _get_value(solution_list, word):\n # Gets the value of a word in a solution list\n for solution in solution_list:\n if solution[0] == word:\n return solution[1]\n\n return 0\n\n # Get the two synonym parts\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\n first_syn = _create_sentence(first_syn)\n second_syn = _create_sentence(second_syn)\n\n # Get top 1000 matching scores for each part of the clue\n if solution_format is not None:\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\n else:\n first_solutions = SimilaritySolver.solve(first_syn)\n second_solutions = SimilaritySolver.solve(second_syn)\n second_words = [word for word, _ in second_solutions]\n\n # Combine both lists, with the value being the product of the value for eac syn part\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\n solution in first_solutions if solution[0] in second_words]\n\n return solutions","def save(self):\n lang = self.languageCombo.currentText()\n kwSet = self.setSpinBox.value()\n self.__keywords[lang][\"Sets\"][kwSet] = self.keywordsEdit.toPlainText()\n \n for lang, keywords in self.__keywords.items():\n Preferences.setEditorKeywords(lang, keywords[\"Sets\"])","def update_taxon_set(self):\n assert self.taxon_set is not None\n for taxon in self.taxon_seq_map:\n if taxon not in self.taxon_set:\n self.taxon_set.add(taxon)","def make_lexicon_words_txt(self):\n raise NotImplementedError","def expand_synset(neighbor_word_list, language):\n if not expand_synset_activated or not language.__eq__(\"English\"):\n return neighbor_word_list\n\n new_neighbor_word_set = set()\n for word in neighbor_word_list:\n new_neighbor_word_set.add(word)\n\n synsets = wn.synsets(word)\n synonyms_list = [item.name().split('.')[0] for item in synsets] # extract: \"dog.n.01\"->\"dog\"\n for new_word in synonyms_list:\n new_neighbor_word_set.add(new_word)\n\n for i in xrange(synonyms_list.__len__()):\n if synonyms_list[i].__eq__(word):\n hyponyms = synsets[i].hyponyms()\n hyponyms_list = [item.name().split('.')[0] for item in hyponyms] # extract: \"dog.n.01\"->\"dog\"\n for new_word1 in hyponyms_list:\n new_neighbor_word_set.add(new_word1)\n\n hypernyms = synsets[i].hypernyms()\n hypernyms_list = [item.name().split('.')[0] for item in hypernyms] # extract: \"dog.n.01\"->\"dog\"\n for new_word1 in hypernyms_list:\n new_neighbor_word_set.add(new_word1)\n return list(new_neighbor_word_set)","def get_well_aliases(self):\n return self.info_wells['well'].unique()","def disambiguate(self, sense_clusters:List[List[str]],\n definitions:List[str] = None) \\\n -> List[Union[float, Tuple[float, float]]]:\n\n def get_contextualized_embedding(ids):\n outputs = model(ids)[0]\n # out = torch.mean(torch.stack(hidden_states[-2:]), dim=0).squeeze()\n out = outputs.squeeze()\n return out\n\n if definitions is None:\n definitions = ['']*len(sense_clusters)\n load_model()\n hypers_scores = []\n defs_scores = []\n with torch.no_grad():\n cosine = torch.nn.CosineSimilarity(dim=0)\n\n tokens = self.tokenize(do_mask=False)\n target_start, target_end = self.target_indices(do_mask=False)\n cxt_ids = model_tok.encode(tokens)\n cxt_ids = torch.tensor(cxt_ids).unsqueeze(0).to(device)\n cxt_embedding = get_contextualized_embedding(cxt_ids)\n target_embeddings = cxt_embedding[target_start+1:target_end+1, :]\n target_embedding = torch.mean(target_embeddings, dim=0).squeeze()\n\n for sc in sense_clusters:\n if any(x.strip() for x in sc):\n sc_str = ', '.join(x.strip() for x in sc if x.strip())\n sc_tokens = model_tok.tokenize(sc_str)\n sc_inds = [ind+1 for ind in range(len(sc_tokens))\n if sc_tokens[ind] != ',']\n sc_ids = torch.tensor(model_tok.encode(sc_str)).unsqueeze(0).to(device)\n assert len(sc_ids[0]) == len(sc_tokens) + 2, (len(sc_ids[0]), len(sc_tokens))\n sc_embeddings = get_contextualized_embedding(sc_ids)\n sc_embedding = torch.mean(sc_embeddings[sc_inds, :], dim=0)\n sc_score = cosine(sc_embedding, target_embedding).item()\n assert isinstance(sc_score, float), sc_str\n hypers_scores.append(sc_score)\n else:\n hypers_scores.append(0)\n for def_ in definitions:\n if def_.strip():\n def_ids = torch.tensor(model_tok.encode(def_)).unsqueeze(0).to(device)\n def_embeddings = get_contextualized_embedding(def_ids)\n def_embedding = torch.mean(def_embeddings[1:-1, :], dim=0)\n def_score = cosine(def_embedding, target_embedding).item()\n assert isinstance(def_score, float), def_\n defs_scores.append(def_score)\n else:\n defs_scores.append(None)\n logger.debug(f'Sense clusters received: {sense_clusters}, '\n f'scores: {hypers_scores}')\n out = []\n for s_score, def_score in zip(hypers_scores, defs_scores):\n out.append((s_score, def_score) if def_score else s_score)\n return out","def save_dists(self, name):\n with open(name, \"w\", encoding=\"utf-8\") as f:\n for word in self._distWords:\n f.write(\"{} | {}\\n\".format(word, \",\".join(map(str_tuple, self._distWords[word].items()))))"],"string":"[\n \"def fill_stempool(self):\\n tokens = [apply_word_tokenize(x) for x in self.df['name']]\\n\\n flatten1 = itertools.chain.from_iterable\\n flat = list(flatten1(tokens))\\n\\n stems = [self.stemmer.stem(x) for x in flat]\\n\\n return set(stems)\",\n \"def nsrSynonyms():\\r\\n # Input file\\r\\n synonymsFile = pd.read_csv(args.indir+\\\"/\\\"+args.infile2, header=2,\\r\\n sep=\\\"\\\\t\\\", encoding=\\\"utf8\\\")\\r\\n\\r\\n # Parse taxonomic names into their elementary components\\r\\n synonyms = synonymsFile.loc[synonymsFile['language'] == 'Scientific']\\r\\n synonymDict = {}\\r\\n for synonym, taxon in zip(synonyms['synonym'], synonyms['taxon']):\\r\\n synonym = taxonParser(synonym)\\r\\n taxon = taxonParser(taxon)\\r\\n if not taxon or synonym is False or taxon is False:\\r\\n pass\\r\\n else:\\r\\n synonymDict[synonym] = taxon\\r\\n\\r\\n # Write dictionary to file\\r\\n with io.open(par_path+\\\"/results/nsr_synonyms.csv\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as outfile:\\r\\n outfile.write(\\\"synonym_name,identification_reference,taxon_name,taxon_author\\\\n\\\")\\r\\n for key, value in synonymDict.items():\\r\\n outfile.write('\\\"%s\\\",\\\"%s\\\",\\\"%s\\\",\\\"%s\\\"' % (' '.join(str(key).split()[:2]), ' '.join(str(key).split()[2:]),\\r\\n ' '.join(str(value).split()[:2]), ' '.join(str(value).split()[2:])))\\r\\n outfile.write(\\\"\\\\n\\\")\\r\\n return [*synonymDict], synonymDict\",\n \"def get_searched_single_word_synonym(self, content, stop_words):\\n content = re.sub(r\\\"[^\\\\w\\\\s]\\\", \\\"\\\", content)\\n content = re.sub(r\\\"[0-9]+\\\", \\\"\\\", content)\\n new_sent = [\\n Word(word).singularize()\\n for word in content.lower().split()\\n if Word(word).singularize() not in stop_words\\n ]\\n new_sent = [\\n Word(word).singularize()\\n for word in new_sent\\n if Word(word).singularize() in set(self.searched_words)\\n ]\\n\\n syn = []\\n for w in new_sent:\\n for s in wordnet.synsets(w):\\n for lemma in s.lemmas():\\n if len(syn) == SYNONYM_LIMIT:\\n break\\n syn.append(lemma.name())\\n syn = list(dict.fromkeys(syn)) #\\n syn = \\\" \\\".join(syn)\\n return syn\",\n \"def getLSASpace():\\n sids,documents = getSongTextInfo()\\n texts = [[word for word in document.lower().split()] for document in documents]\\n dictionary = corpora.Dictionary(texts)\\n corpus = [dictionary.doc2bow(text) for text in texts]\\n tfidf = models.TfidfModel(corpus)\\n corpus_tfidf = tfidf[corpus]\\n lsi = models.LsiModel(corpus_tfidf, id2word=dictionary, num_topics=30)\\n corpus_lsi = lsi[corpus_tfidf]\\n songMap = {}\\n index = 0\\n for doc in corpus_lsi:\\n sid = sids[index]\\n rMap = {}\\n for item in doc:\\n wid = item[0]\\n count = item[1]\\n rMap[wid] = count\\n songMap[sid] = rMap\\n index += 1\\n return songMap\",\n \"def synonyms(self) -> List[str]:\\n return self._synonyms\",\n \"def synonyms(self) -> List[str]:\\n return pulumi.get(self, \\\"synonyms\\\")\",\n \"def synonymic_list_generator(content):\\n\\tpass\",\n \"def getSynonyms(self, wordSet):\\n synonyms = {}\\n for w in wordSet:\\n # find synonyms\\n synsets = wn.synsets(w, pos=wn.NOUN)\\n if len(synsets) > 0: \\n # there are noun senses for this word, get synonyms\\n synonyms[w] = set([synset.name for synset in synsets])\\n \\n return synonyms\",\n \"def on_serialize(self):\\n for sw in self.sig_words:\\n sw[1] = set(map(lambda s: s.name(), sw[1]))\\n self.most_common_synsets = list(map(lambda s: s.name(), self.most_common_synsets))\",\n \"def antonym(self, sense=0):\\n s = self._synset(self.text, sense=sense)\\n\\n if not s:\\n return []\\n\\n lemmas = s.lemmas()\\n\\n result = list()\\n\\n for lemma in lemmas:\\n if lemma.antonyms():\\n result.append(lemma.antonyms()[0].name())\\n\\n return result if result else []\",\n \"def meronym(self, sense=0):\\n s = self._synset(self.text, sense=sense)\\n\\n if not s:\\n return []\\n\\n return s.member_meronyms()\",\n \"def get_synonyms(word):\\n synsets = [];\\n syns = wn.synsets(word)\\n for ss in syns:\\n lemmas = []\\n for l in ss.lemmas():\\n lemma = { \\\"name\\\": l.name(), \\\"related_forms\\\": [] }\\n for x in l.derivationally_related_forms():\\n lemma['related_forms'].append(x.name())\\n lemmas.append(lemma)\\n synsets.append({\\n \\\"lemmas\\\": lemmas,\\n \\\"d\\\": ss.definition(),\\n \\\"pos\\\": ss.pos(),\\n \\\"id\\\": ss.name()\\n })\\n return synsets\",\n \"def makeStems(self):\\r\\n clean_s = self.cleanString(self.text)\\r\\n LoW = clean_s.split() \\r\\n for x in LoW: \\r\\n if create_stem(x) not in self.stems: \\r\\n self.stems[create_stem(x)] = 1\\r\\n else: \\r\\n self.stems[create_stem(x)] += 1\\r\\n return self.stems\",\n \"def _add_to_existing_flowable(self, fb, new_terms):\\n biog = ('124-38-9' in fb)\\n for term in new_terms:\\n self._fm.add_synonym(fb, term)\\n if biog and bool(biogenic.search(term)):\\n self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym\",\n \"def get_words(self):\\r\\n\\r\\n #using database\\r\\n\\r\\n if self.using_database:\\r\\n value_tuple = (notebookname,)\\r\\n db_cursor.execute(\\\"SELECT word\\\"\\r\\n +\\\" FROM word_to_indexes\\\"\\r\\n +\\\" WHERE notebook=?;\\\",\\r\\n value_tuple)\\r\\n fetched = db_cursor.fetchall()\\r\\n if fetched:\\r\\n return {word[0] for word in fetched}\\r\\n\\r\\n return set()\\r\\n\\r\\n #using shelf\\r\\n\\r\\n return self.word_dict.keys()\",\n \"def __macronize(self):\\n self.macronizations = [Scansion(\\\"\\\")]\\n for i, word in enumerate(self.words):\\n new_macrons = []\\n for exist in self.macronizations:\\n for macrons in word.macronize():\\n new_macrons.append(exist + macrons)\\n self.macronizations = new_macrons\",\n \"def get_legal_synonyms(input_filepath):\\n syn_filepath = TestSystem.get_synonym_solution_filepath(input_filepath)\\n if not os.path.isfile(syn_filepath):\\n return None\\n with io.open(syn_filepath, 'r') as f:\\n result = dict()\\n for l in f:\\n if not l.startswith('#'):\\n [name, val] = l.rstrip().split(\\\"===\\\")\\n if name not in result:\\n result[name] = [val]\\n else:\\n result[name].append(val)\\n\\n return result\",\n \"def testOneWord(self):\\n\\n\\t\\t\\t\\tspinner.Synonym.objects.add('directory', 'catalog', 10)\\n\\t\\t\\t\\tspinner.Synonym.objects.add('list', 'directory', 20)\\n\\t\\t\\t\\tspinner.Synonym.objects.add('directory', 'guide', 10)\\n\\n\\t\\t\\t\\tsynonyms = spinner.Synonym.objects.get_synonyms(['directory'])\\n\\t\\t\\t\\tassert len(synonyms) < 3, synonyms\",\n \"def getLDASpace():\\n sids,documents = getSongTextInfo()\\n texts = [[word for word in document.lower().split()] for document in documents]\\n dictionary = corpora.Dictionary(texts)\\n corpus = [dictionary.doc2bow(text) for text in texts]\\n tfidf = models.TfidfModel(corpus)\\n corpus_tfidf = tfidf[corpus]\\n lda = models.LdaModel(corpus_tfidf, id2word=dictionary, num_topics=30)\\n corpus_lda = lda[corpus_tfidf]\\n songMap = {}\\n index = 0\\n for doc in corpus_lda:\\n sid = sids[index]\\n rMap = {}\\n for item in doc:\\n wid = item[0]\\n count = item[1]\\n rMap[wid] = count\\n songMap[sid] = rMap\\n index += 1\\n return songMap\",\n \"def get_synonyms(word,w2v,pos,max=20):\\n synonyms = []\\n count = 0\\n synsets = wordnet.synsets(word,pos=pos)\\n for synset in synsets:\\n candidate_names = []\\n for lemma in synset.lemma_names():\\n candidate_names.append(lemma)\\n for hypo in synset.hyponyms():\\n candidate_names.append(hypo)\\n for hyper in synset.hypernyms():\\n candidate_names.append(hyper)\\n\\n for lemma in candidate_names:\\n if count >= max:\\n break\\n # print pos,word,lemma\\n try:\\n similarity = w2v.n_similarity([word.lower()],[lemma.lower() ])\\n if similarity > .34 and lemma not in synonyms:\\n synonyms.append(lemma)\\n\\n count += 1\\n except:\\n continue\\n\\n return synonyms\",\n \"def _get_term_dictionaries(self):\\n\\t\\tforward_dict = {}\\n\\t\\treverse_dict = defaultdict(list)\\n\\t\\tfor term in self.terms():\\n\\t\\t\\tif (term.name is not None) and (\\\"obsolete\\\" not in term.name): \\n\\t\\t\\t\\twords = [term.name]\\n\\t\\t\\t\\twords.extend([x.description for x in list(term.synonyms)])\\t# Add all the synonyms\\n\\t\\t\\t\\twords = [re.sub(r\\\" ?\\\\([^)]+\\\\)\\\", \\\"\\\", x) for x in words]\\t\\t# Replace parenthetical text.\\n\\t\\t\\t\\tforward_dict[term.id] = words\\n\\t\\t\\t\\tfor word in words:\\n\\t\\t\\t\\t\\treverse_dict[word].append(term.id)\\n\\t\\treturn(forward_dict, reverse_dict)\",\n \"def synonyms(self, synonyms: List[str]):\\n\\n self._synonyms = synonyms\",\n \"def fit(self, clean=False):\\n if self._no_canonical_entity_map:\\n return\\n\\n if not self._use_text_rel:\\n self._fit_exact_match()\\n return\\n\\n if clean:\\n delete_index(\\n self._app_namespace, self._es_index_name, self._es_host, self._es_client\\n )\\n entity_map = self._resource_loader.get_entity_map(self.type)\\n\\n # list of canonical entities and their synonyms\\n entities = entity_map.get(\\\"entities\\\", [])\\n\\n # create synonym index and import synonyms\\n logger.info(\\\"Importing synonym data to synonym index '%s'\\\", self._es_index_name)\\n EntityResolver.ingest_synonym(\\n app_namespace=self._app_namespace,\\n index_name=self._es_index_name,\\n data=entities,\\n es_host=self._es_host,\\n es_client=self._es_client,\\n use_double_metaphone=self._use_double_metaphone,\\n )\\n\\n # It's supported to specify the KB object type and field name that the NLP entity type\\n # corresponds to in the mapping.json file. In this case the synonym whitelist is also\\n # imported to KB object index and the synonym info will be used when using Question Answerer\\n # for text relevance matches.\\n kb_index = entity_map.get(\\\"kb_index_name\\\")\\n kb_field = entity_map.get(\\\"kb_field_name\\\")\\n\\n # if KB index and field name is specified then also import synonyms into KB object index.\\n if kb_index and kb_field:\\n # validate the KB index and field are valid.\\n # TODO: this validation can probably be in some other places like resource loader.\\n if not does_index_exist(\\n self._app_namespace, kb_index, self._es_host, self._es_client\\n ):\\n raise ValueError(\\n \\\"Cannot import synonym data to knowledge base. The knowledge base \\\"\\n \\\"index name '{}' is not valid.\\\".format(kb_index)\\n )\\n if kb_field not in get_field_names(\\n self._app_namespace, kb_index, self._es_host, self._es_client\\n ):\\n raise ValueError(\\n \\\"Cannot import synonym data to knowledge base. The knowledge base \\\"\\n \\\"field name '{}' is not valid.\\\".format(kb_field)\\n )\\n if entities and not entities[0].get(\\\"id\\\"):\\n raise ValueError(\\n \\\"Knowledge base index and field cannot be specified for entities \\\"\\n \\\"without ID.\\\"\\n )\\n logger.info(\\\"Importing synonym data to knowledge base index '%s'\\\", kb_index)\\n EntityResolver.ingest_synonym(\\n app_namespace=self._app_namespace,\\n index_name=kb_index,\\n index_type=\\\"kb\\\",\\n field_name=kb_field,\\n data=entities,\\n es_host=self._es_host,\\n es_client=self._es_client,\\n use_double_metaphone=self._use_double_metaphone,\\n )\",\n \"def get_words_from_sysets(synset):\\n synlist = []\\n for s in synset:\\n syns = s.lemmas()[0].name()\\n synlist.append(syns)\\n return synlist\",\n \"def synonyms_pipeline(config: SettingConfig) -> None:\\n raw_synonym_pairs = generate_synonym_pairs(config)\\n for pos in config.pos.keys():\\n processed_synonym_pairs = postprocess_pairs(raw_synonym_pairs[pos], config)\\n write_pairs(processed_synonym_pairs, config.constraints_root_path, pos, \\\"synonyms\\\")\",\n \"def constitute_word_dict(self):\\r\\n\\r\\n #IS THIS NECESSARY WITH DATABASE??\\r\\n\\r\\n if self.using_shelf:\\r\\n for k_temp in self.get_words():\\r\\n self.delete_word(k_temp)\\r\\n\\r\\n for i_temp in [a_temp for a_temp in self.indexes()\\r\\n if Index(a_temp) > Index(str(0))]:\\r\\n\\r\\n self.add_search_words(Index(i_temp),\\r\\n self.get_text_from_note(i_temp))\\r\\n display.noteprint((alerts.ATTENTION,\\r\\n alerts.WORD_DICT_CONSTITUTED))\",\n \"def get_synonyms(word):\\n syns_sets = wordnet.synsets(word)\\n if syns_sets:\\n # if there's synonyms, take the first set\\n desired = syns_sets[0].lemma_names()\\n desired = [the_name.replace(\\\"_\\\", \\\" \\\") for the_name in desired]\\n return desired\\n\\n else:\\n return False\",\n \"def get_synonyms(word):\\n try:\\n query = {'word': word}\\n cursor = database['Words'].find(query)\\n synonym_set = set()\\n if cursor is None:\\n return None\\n for document in cursor:\\n if len(document['synsets']) > 0:\\n for key, synset in document['synsets'].items():\\n synonyms = synset['synonyms'].split(\\\",\\\")\\n for synonym in synonyms:\\n synonym_set.add(synonym.strip())\\n if len(synonym_set) == 0:\\n return None\\n return synonym_set\\n except Exception as e:\\n print(e)\\n return None\",\n \"def weed_out_synonyms(word, potential_synonyms):\\n real_synonyms = set()\\n for synonym in potential_synonyms:\\n max_distance = abs(len(word) - len(synonym))\\n abbr_len = min(len(word), len(synonym))\\n forgiveness = round(1/7 * abbr_len)\\n if lev.distance(word, synonym) <= max_distance + forgiveness:\\n # Then it's a synonym!\\n real_synonyms.add(synonym)\\n return real_synonyms\",\n \"def on_deserialize(self):\\n for sw in self.sig_words:\\n sw[1] = set(map(lambda s: wn.synset(s), sw[1]))\\n self.most_common_synsets = list(map(lambda s: wn.synset(s), self.most_common_synsets))\",\n \"def c_synonym_cd(self) -> str:\\n return \\\"N\\\"\",\n \"def load_known_corpora():\\n\\n print (\\\"Loading Corpora\\\")\\n\\n # For debugging purposes, comment out the definition of all but say the first\\n # corpus, to speed the ingest time.\\n shenoute_a22 = Corpus()\\n shenoute_a22.annis_corpus_name = \\\"shenoute.a22\\\"\\n shenoute_a22.title = \\\"Acephalous Work 22\\\"\\n shenoute_a22.slug = \\\"acephalous_work_22\\\"\\n shenoute_a22.urn_code = \\\"shenoute.a22\\\"\\n shenoute_a22.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-a22\\\"\\n\\n patrum = Corpus()\\n patrum.annis_corpus_name = \\\"apophthegmata.patrum\\\"\\n patrum.title = \\\"Apophthegmata Patrum\\\"\\n patrum.slug = \\\"ap\\\"\\n patrum.urn_code = \\\"ap\\\"\\n patrum.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/AP\\\"\\n\\n saof = Corpus()\\n saof.annis_corpus_name = \\\"shenoute.abraham.our.father\\\"\\n saof.title = \\\"Abraham Our Father\\\"\\n saof.slug = \\\"abraham_our_father\\\"\\n saof.urn_code = \\\"shenoute.abraham\\\"\\n saof.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/abraham\\\"\\n\\n besa_ap = Corpus()\\n besa_ap.annis_corpus_name = \\\"besa.letters\\\"\\n besa_ap.title = \\\"Letter to Aphthonia\\\"\\n besa_ap.slug = \\\"to_aphthonia\\\"\\n besa_ap.urn_code = \\\"besa.aphthonia\\\"\\n besa_ap.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\\\"\\n\\n fox = Corpus()\\n fox.annis_corpus_name = \\\"shenoute.fox\\\"\\n fox.title = \\\"Not Because a Fox Barks\\\"\\n fox.slug = \\\"not_because_a_fox_barks\\\"\\n fox.urn_code = \\\"shenoute.fox\\\"\\n fox.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-fox\\\"\\n\\n mark = Corpus()\\n mark.annis_corpus_name = \\\"sahidica.mark\\\"\\n mark.title = \\\"Gospel of Mark\\\"\\n mark.slug = \\\"gospel_of_mark\\\"\\n mark.urn_code = \\\"nt.mark\\\"\\n mark.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n corinth = Corpus()\\n corinth.annis_corpus_name = \\\"sahidica.1corinthians\\\"\\n corinth.title = \\\"1 Corinthians\\\"\\n corinth.slug = \\\"1st_corinthians\\\"\\n corinth.urn_code = \\\"nt.1cor\\\"\\n corinth.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n snt = Corpus()\\n snt.annis_corpus_name = \\\"sahidica.nt\\\"\\n snt.title = \\\"New Testament\\\"\\n snt.slug = \\\"new-testament\\\"\\n snt.urn_code = \\\"nt\\\"\\n snt.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n eager = Corpus()\\n eager.annis_corpus_name = \\\"shenoute.eagerness\\\"\\n eager.title = \\\"I See Your Eagerness\\\"\\n eager.slug = \\\"eagernesss\\\"\\n eager.urn_code = \\\"shenoute.eagerness\\\"\\n eager.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-eagerness\\\"\\n\\n besa_nuns = Corpus()\\n besa_nuns.annis_corpus_name = \\\"besa.letters\\\"\\n besa_nuns.title = \\\"Letter to Thieving Nuns\\\"\\n besa_nuns.slug = \\\"to_thieving_nuns\\\"\\n besa_nuns.urn_code = \\\"besa.thieving\\\"\\n besa_nuns.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\\\"\\n\\n doc_pap = Corpus()\\n doc_pap.annis_corpus_name = \\\"doc.papyri\\\"\\n doc_pap.title = \\\"Documentary Papyri\\\"\\n doc_pap.slug = \\\"papyri\\\"\\n doc_pap.urn_code = \\\"copticDoc:papyri_info\\\"\\n doc_pap.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/doc-papyri\\\"\\n\\n known_corpora = [shenoute_a22, patrum, saof, besa_ap, fox, mark, corinth, snt, eager, besa_nuns, doc_pap]\\n# known_corpora = [shenoute_a22]\\n \\n for one in known_corpora:\\n try:\\n Corpus.objects.get(slug__exact=one.slug)\\n except Corpus.DoesNotExist:\\n one.save()\",\n \"def name_synonym_lookup(self, fbids):\\n if not fbids:\\n warnings.warn(\\\"Empty fbid list provided to name_synonym_lookup\\\")\\n return False\\n # stypes: symbol nickname synonym fullname\\n query = \\\"SELECT f.uniquename as fbid, s.name as ascii_name, \\\" \\\\\\n \\\"stype.name AS stype, \\\" \\\\\\n \\\"fs.is_current, s.synonym_sgml as unicode_name \\\" \\\\\\n \\\"FROM feature f \\\" \\\\\\n \\\"JOIN feature_synonym fs on (f.feature_id=fs.feature_id) \\\" \\\\\\n \\\"JOIN synonym s on (fs.synonym_id=s.synonym_id) \\\" \\\\\\n \\\"JOIN cvterm stype on (s.type_id=stype.cvterm_id) \\\" \\\\\\n \\\"WHERE f.uniquename IN ('%s')\\\"\\n dc = self.query_fb(query % \\\"','\\\".join(fbids))\\n results = {}\\n old_key = ''\\n out = {}\\n for d in dc:\\n key = d['fbid']\\n if not (key == old_key):\\n if out:\\n results[old_key] = Feature(**out)\\n out = {}\\n out['fbid'] = key\\n out['iri'] = map_iri('fb') + key\\n out['synonyms'] = set()\\n if d['stype'] == 'symbol' and d['is_current']:\\n out['symbol'] = clean_sgml_tags(d['unicode_name'])\\n else:\\n out['synonyms'].add(clean_sgml_tags(d['ascii_name']))\\n out['synonyms'].add(clean_sgml_tags(d['unicode_name']))\\n old_key = key\\n return results\",\n \"def SetKeyWords(self, kw_lst):\\n # Parse Keyword Settings List simply ignoring bad values and badly\\n # formed lists\\n self._code['keywords'] = list()\\n kwlist = \\\"\\\"\\n for keyw in kw_lst:\\n if len(keyw) != 2:\\n continue\\n else:\\n if not isinstance(keyw[0], int) or \\\\\\n not isinstance(keyw[1], basestring):\\n continue\\n else:\\n kwlist += keyw[1]\\n super(EditraBaseStc, self).SetKeyWords(keyw[0], keyw[1])\\n\\n # Can't have ? in scintilla autocomp list unless specifying an image\\n # TODO: this should be handled by the autocomp service\\n if '?' in kwlist:\\n kwlist.replace('?', '')\\n\\n kwlist = kwlist.split() # Split into a list of words\\n kwlist = list(set(kwlist)) # Remove duplicates from the list\\n kwlist.sort() # Sort into alphabetical order\\n\\n self._code['keywords'] = kwlist\",\n \"def nsrGenera(taxonList, synonymList):\\r\\n species = list(filter(None, sorted(taxonList + synonymList)))\\r\\n generaList = [i.split()[0] for i in species]\\r\\n generaList = list(dict.fromkeys(generaList))\\r\\n return generaList\",\n \"def get_wordlists():\\n\\n\\tCS = {'ACM', 'IEEE', 'Computer Science', 'Artificial Intelligence',\\n\\t\\t'Pattern Recognition', 'Computer Vision', 'Machine Learning',\\n\\t\\t'Signal Processing', 'Electrical Engineering', 'Image Processing',\\n\\t\\t'Data Mining', 'Neural Networks', 'Computer Graphics', 'Graphics',\\n\\t\\t'Language Processing', 'Internet', 'Intelligent Systems',\\n\\t\\t'Robotic','Data','Software', 'Machine Vision', 'Image Analysis',\\n\\t\\t'Scientific Computing', 'SIAM', 'Malware','World Wide Web', \\n\\t\\t'Computational Intelligence', 'Computational Linguistics',\\n\\t\\t'Computational linguistics','Algorithm','Computer','ITiCSE',\\n\\t\\t'ITICSE','Machine learning','Learning','learning',\\n\\t\\t'Artificial intelligence','CIVR','Document Analysis'}\\n\\n\\tbio = {'Biology', 'Microbiology', 'Molecular', 'Medical', 'Biological',\\n\\t\\t'Cancer', 'Genome', 'Bioinformatics', 'Protein', 'Biocomputing',\\n\\t\\t'Biomedical', 'biology', 'Medicine', 'Biosystems', 'Virology',\\n\\t\\t'Brain', 'Psychology', 'Genetics', 'Bioengineering', 'Cell',\\n\\t\\t'Cardiology', 'Metabolic', 'Biotechnology', 'Pathogens',\\n\\t\\t'Pathology', 'Plant', 'PLANT', 'Virus', 'Drug','Medicinal',\\n\\t\\t'Neuro','Psych',\\n\\t\\t'Genomic','Diseases','Endocrinology', 'Epidemiology',\\n\\t\\t'Proteom','Biochem', 'DNA', 'Pharma', 'Biomedic', 'biomedica',\\n\\t\\t'Neurobiological'}\\n\\n\\tmath = {'Mathemati','Markov','Probability','Algebra','Network',\\n\\t\\t'Topology','Optimization', 'Geometr','Statistic','Algorithm',\\n\\t\\t'Graph ','Graphs','Combinatori','Riemann Surfaces','Permutation Groups',\\n\\t\\t'Functional Analysis', 'SIAM','Fixed Point','Wavelet','Statistics',\\n\\t\\t'Linear Regression','Fractal','geometry','Multivariate','Chaos',\\n\\t\\t'mathemati','Kernel'}\\n\\n\\tlinguistics = {}\\n\\n\\tcomputer_vision = {}\\n\\n\\tchemistry = {}\\n\\n\\tphysics = {}\\n\\n\\t# Rename \\\"Computer Vision\\\" to \\\"Image Processing\\\"?\\n\\ttopic_names = ['Computer Science','Biology','Mathematics','Chemistry',\\n\\t\\t'Physics','Computer Vision','Natural Language Processing']\\n\\ttopics = [CS, bio, math]#, linguistics, computer_vision, chemistry, physics]\\n\\n\\treturn {topic_names[i]:topics[i] for i in range(len(topics))}\",\n \"def testSynonym(self):\\n\\n\\t\\t\\t\\tone = spinner.Word.objects.get_single('mac', True)\\n\\t\\t\\t\\ttwo = spinner.Word.objects.get_single('macintosh', True)\\n\\n\\t\\t\\t\\tsyn = spinner.Synonym.objects.get_single(one, two, True)\\n\\t\\t\\t\\tassert isinstance(syn, spinner.Synonym), syn\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tsyn.delete()\\n\\t\\t\\t\\tone.delete()\\n\\t\\t\\t\\ttwo.delete()\",\n \"def synonyms(self):\\n\\n return [synonym[\\\"name\\\"] for synonym in self._get_synonym_json()]\",\n \"def __insert_random_synonym(self, tokenized_sentence: list) -> str:\\n sentence_length = len(tokenized_sentence)\\n # Initialize the return string\\n new_sentence = \\\"\\\"\\n # Some variables to keep track of changes and attempted changes\\n has_changed = False\\n attempts = 0\\n # Keep trying to make a change until either:\\n # 1) You've made a change, OR\\n # 2) You've tried to make a change for half the words in the sentence with no success\\n while has_changed is not True and attempts <= sentence_length/2:\\n # Grab a random word from the tokenized sentence\\n index_to_get_word_from = random.randint(0, sentence_length-1)\\n pair_to_get_word_from = tokenized_sentence[index_to_get_word_from]\\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_get_word_from)\\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \\n if len(list_of_syns) < 1: \\n # Failed synonym swap, so bump up the attempts tracker by one\\n attempts += 1\\n continue\\n # Else, the word does have synonyms we can swap the word for\\n else:\\n # Randomly pick a word from the synonym list\\n random_pick = random.randint(0, len(list_of_syns)-1)\\n new_word = list_of_syns[random_pick]\\n new_word_pair = (new_word, \\\"NA\\\") # \\\"NA\\\" is a dummy POS tag\\n # Now randomly find a spot to put the new word\\n index_to_place_new_word = random.randint(0, sentence_length-1)\\n # Now update the tokenized sentence with the new word\\n tokenized_sentence.insert(index_to_place_new_word, new_word_pair)\\n sentence_length += 1\\n # Pull the sentence back together\\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\\n # Now let's clean up our brand new sentence really quickly\\n new_sentence = nltk_methods.clean_sentence(new_sentence)\\n # BUT WAIT, what if this is a duplicate? We don't want that!\\n if new_sentence in self.return_augmented_sentences():\\n # Bump up the attempts and skip this sentence\\n attempts += 1\\n continue\\n # Update the flags\\n has_changed = True\\n return new_sentence\",\n \"def synonyms_keyword(self, p_keyword):\\n pass\",\n \"def get_synsets(words):\\n synsets = {}\\n for word in words:\\n for syn in wn.synsets(word):\\n synsets[syn.name] = tuple([lemma.name for lemma in syn.lemmas])\\n return synsets\",\n \"def setWordKnown(self):\\n self.wordKnown = ''.join(['_ ' if w not in self.guessedRight else w for w in self.getWord()])\",\n \"def store_names(self):\\n # clear the text buffer, or create new buffer\\n try:\\n namestxt = bpy.data.texts[\\\"FullNames\\\"]\\n namestxt.clear()\\n except KeyError:\\n namestxt = bpy.data.texts.new(\\\"FullNames\\\")\\n \\n # write the names to the text buffer\\n for block, shortname in self.nif_import.dict_names.items():\\n block_name = block.name.decode()\\n if block_name and shortname != block_name:\\n namestxt.write('%s;%s\\\\n' % (shortname, block_name))\",\n \"def get_chebi_synonyms(chebi_ent):\\n if hasattr(chebi_ent, 'Synonyms'):\\n return [entry.data for entry in chebi_ent.Synonyms]\\n else:\\n return []\",\n \"def learn_words(self):\\n codebook = N.array(self.vowel_map.keys())\\n for i in range(len(self.memory)):\\n codes, dist = vq.vq(self.memory[i], codebook)\\n self.stems[i] = N.array([self.vowel_map[tuple(codebook[x])] for x\\n in codes])\\n return self.stems\",\n \"def index_terms(self):\\n [[self.set_postings(term, id) for term in NLProcessor.process(doc)] for id, doc in\\n self.doc_store.dict.iteritems()]\",\n \"def __synonym_replacement(self, tokenized_sentence: list) -> str:\\n sentence_length = len(tokenized_sentence)\\n # Initialize the return string\\n new_sentence = \\\"\\\"\\n # Some variables to keep track of changes and attempted changes\\n has_changed = False\\n attempts = 0\\n # Keep trying to make a change until either:\\n # 1) You've made a change, OR\\n # 2) You've tried to make a change for half the words in the sentence with no success\\n while has_changed is not True and attempts <= sentence_length/2:\\n # Grab a random word from the tokenized sentence\\n index_to_change = random.randint(0, sentence_length-1)\\n pair_to_change = tokenized_sentence[index_to_change]\\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_change)\\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \\n if len(list_of_syns) < 1: \\n # Failed synonym swap, so bump up the attempts tracker by one\\n attempts += 1\\n continue\\n # Else, the word does have synonyms we can swap the word for\\n else:\\n # Randomly pick a word from the synonym list\\n random_pick = random.randint(0, len(list_of_syns)-1)\\n new_word = list_of_syns[random_pick]\\n new_word_pair = (new_word, \\\"NA\\\") # \\\"NA\\\" is a dummy POS tag\\n # Now update the tokenized sentence with the new word\\n tokenized_sentence[index_to_change] = new_word_pair\\n # Pull the sentence back together\\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\\n # Now let's clean up our brand new sentence really quickly\\n new_sentence = nltk_methods.clean_sentence(new_sentence)\\n # BUT WAIT, what if this is a duplicate? We don't want that!\\n if new_sentence in self.return_augmented_sentences():\\n # Bump up the attempts and skip this sentence\\n attempts += 1\\n continue\\n # Update the flags\\n has_changed = True\\n return new_sentence\",\n \"def wordnet_synsets(self):\\n new_var = \\\"n_synsets\\\"\\n wn_lemmas = [l.encode('ascii') for l in wn.all_lemma_names()]\\n has_item = self.compare_items(wn_lemmas)\\n new_column = []\\n if False in has_item:\\n self._warning_msg('wordnet_synsets', wn_lemmas)\\n for record, exists in zip(self._dict, has_item):\\n if exists:\\n n_synsets = len(wn.synsets(record))\\n else:\\n n_synsets = None\\n new_column.append(n_synsets)\\n self._append_column(new_column, new_var)\",\n \"def set_subhead_searched_words(self):\\n\\n searched_words = []\\n for i in range(self.subhead.shape[0]):\\n if (\\n self.subhead[\\\"searched_pair_word\\\"][i]\\n in self.subhead[\\\"searched_unique_single_word_synonym\\\"][i]\\n ):\\n searched_words.append(\\n self.subhead[\\\"searched_unique_single_word_synonym\\\"][i]\\n )\\n else:\\n searched_words.append(\\n self.subhead[\\\"searched_unique_single_word_synonym\\\"][i]\\n + self.subhead[\\\"searched_pair_word\\\"][i]\\n )\\n self.subhead[\\\"searched_words\\\"] = searched_words\",\n \"def main():\\n namelst = open('cor_lamp.lst').readlines()\\n namelst = ['awftbo'+i.strip() for i in namelst]\\n for name in namelst:\\n cor_keyword(name)\\n func.set_airmass(name)\",\n \"def build_sublemma_index(self):\\n terms = []\\n with open(self.path_lemma_terms, 'r', encoding='utf8') as f:\\n for line in f:\\n term = line.strip('\\\\n')\\n terms.append(term)\\n terms = set(terms)\\n for term in terms:\\n term_list = term.split('_')\\n subterms = get_sublists(term_list)\\n self.sublemma_index[term] = [t for t in subterms if t in terms]\",\n \"def reload_term_meta(self):\\n result = self.execute_prepared_query(\\\"get_classes\\\")\\n self.classes = set([row[0] for row in result])\\n\\n result = self.execute_prepared_query(\\\"get_properties\\\")\\n self.properties = set([row[0] for row in result])\\n\\n result = self.execute_prepared_query(\\\"get_term_to_label\\\")\\n self.term_to_label = {row[0]: row[1].toPython().strip() for row in result}\\n\\n result = self.execute_prepared_query(\\\"get_term_to_desc\\\")\\n self.term_to_desc = {row[0]: row[1].toPython() for row in result}\",\n \"def add_sr_synonyms(self,\\n seq_region_file: str,\\n seq_region_map: dict,\\n external_db_map: dict,\\n work_dir: str,\\n unversion: bool = False,\\n unversionable_sources_set: frozenset = frozenset([\\\"INSDC\\\", \\\"RefSeq\\\"])):\\n os.makedirs(work_dir, exist_ok=True)\\n\\n # return if there's nothing to add\\n if not seq_region_file: return\\n\\n # get seq_region ids, names, syns from db\\n synonyms_trios_db = self.load_seq_region_synonyms_trios_from_core_db(self.pjc(work_dir, \\\"syns_from_core\\\"))\\n\\n # form set of synonyms already present in db\\n synonyms_in_db = frozenset( [trio[2] for trio in synonyms_trios_db if trio[2] != \\\"NULL\\\"] )\\n\\n # subset of sources to use the allowed the unversion synonyms\\n unversionable_sources = unversion and unversionable_sources_set or frozenset()\\n\\n # technical / optimization. get external_db_id for \\\"ensembl_internal_synonym\\\"\\n ensembl_internal_synonym_ext_db_id = self.id_from_map_or_die(\\\"ensembl_internal_synonym\\\", external_db_map, \\\"external_db_map\\\")\\n\\n # get dict for additional mapping for sources to external_db names if there's one specified by \\\"external_db_map\\\" module param\\n # not to be confused with the external_db_map function parameter above\\n additional_sources_mapping = self.get_external_db_mapping()\\n\\n # load synonyms from the json file\\n synonyms_from_json = [] # [ (seq_region_id, synonym, external_db_id)... ] list of trios for inserting into db \\n with open(seq_region_file) as in_file:\\n seq_regions = list(json.load(in_file))\\n for seq_region in filter(lambda sr: sr.get(\\\"synonyms\\\", False), seq_regions):\\n # iterate through all seq_regions having \\\"synonyms\\\" \\n seq_region_name, seq_region_id, _ = \\\\\\n self.name_and_id_from_seq_region_item(seq_region, seq_region_map, try_unversion = unversion)\\n\\n # fill synonyms_from_json list of trios\\n for synonym_item in list(seq_region[\\\"synonyms\\\"]):\\n synonym_name = synonym_item[\\\"name\\\"]\\n source = synonym_item[\\\"source\\\"]\\n unversioned_name = \\\"\\\"\\n\\n # check if there's any addtional mapping for the source, remap if so\\n if additional_sources_mapping:\\n source = additional_sources_mapping.get(source, source) # use the same name if no matches in additional_sources_mapping dict\\n\\n # try to get unversioned name if applicable \\n if source in unversionable_sources:\\n unversioned_name = re.sub(r\\\"\\\\.\\\\d+$\\\", \\\"\\\", synonym_name)\\n\\n # put trios if names are not already seen in db \\n if synonym_name not in synonyms_in_db:\\n external_db_id = self.id_from_map_or_die(source, external_db_map, \\\"external_db_map\\\")\\n synonyms_from_json.append( (seq_region_id, self.quote_or_null(synonym_name), external_db_id) )\\n\\n # put additional unversioned synonyms if there's a sane one\\n if unversioned_name \\\\\\n and unversioned_name != synonym_name \\\\\\n and unversioned_name not in synonyms_in_db:\\n synonyms_from_json.append( (seq_region_id, self.quote_or_null(unversioned_name), ensembl_internal_synonym_ext_db_id) )\\n\\n # run insertion SQL\\n self.insert_to_db(\\n synonyms_from_json,\\n \\\"seq_region_synonym\\\",\\n [\\\"seq_region_id\\\", \\\"synonym\\\", \\\"external_db_id\\\"],\\n self.pjc(work_dir, \\\"new_seq_region_synonyms\\\"),\\n ignore = True\\n )\",\n \"def __settle_ttl(self):\\n self.ttl = {}\\n for v in self.g.nodes():\\n indices = [self.universe.index((v, w))\\n for w in self.g[v] if (v, w) in self.universe]\\n self.ttl[v] = max(indices) if len(indices) else 0\",\n \"def load_seq_region_synonyms_trios_from_core_db(self, work_dir: str) -> list:\\n # was get_db_syns\\n out_pfx = self.pjc(work_dir, f\\\"seq_region_synonyms\\\")\\n sql = r'''select sr.seq_region_id as seq_region_id, sr.name, srs.synonym\\n from seq_region sr left join seq_region_synonym srs\\n on sr.seq_region_id = srs.seq_region_id\\n order by sr.seq_region_id\\n ;'''\\n\\n res = self.run_sql_req(sql, out_pfx)\\n\\n syn_trios = []\\n out_file = out_pfx + \\\".stdout\\\"\\n with open(out_file) as syns_file:\\n skip_header = True\\n for line in syns_file:\\n if skip_header:\\n skip_header = False\\n continue\\n (sr_id, name, syn) = line.strip().split(\\\"\\\\t\\\")\\n syn_trios.append( (sr_id, name, syn) )\\n return syn_trios\",\n \"def copy_sr_name_to_syn(self, cs, x_db, log_pfx):\\n asm_v = self.asm_name()\\n sql = r'''insert into seq_region_synonym (seq_region_id, synonym, external_db_id)\\n select\\n sr.seq_region_id, sr.name, xdb.external_db_id\\n from\\n seq_region sr, external_db xdb, coord_system cs\\n where xdb.db_name = \\\"%s\\\"\\n and sr.coord_system_id = cs.coord_system_id\\n and cs.name = \\\"%s\\\"\\n and cs.version = \\\"%s\\\"\\n and sr.name like \\\"%%._\\\"\\n ;''' % (x_db, cs, asm_v)\\n return self.run_sql_req(sql, log_pfx)\",\n \"def populate_lexical():\\n in_dir = os.path.join(buildconfig.FORM_INDEX_DIR, 'refined')\\n frequency_cutoff = buildconfig.FREQUENCY_CUTOFF\\n\\n taxonomy = LanguageTaxonomy()\\n lemma_counter = 0\\n definition_counter = 0\\n\\n for letter in string.ascii_lowercase:\\n stdout.write('Inserting data for %s...\\\\n' % letter)\\n blocks = []\\n in_file = os.path.join(in_dir, letter + '.json')\\n with open(in_file, 'r') as filehandle:\\n for line in filehandle:\\n data = json.loads(line.strip())\\n blocks.append(BlockData(*data))\\n\\n lemmas = []\\n wordforms = []\\n definitions = []\\n for i, block in enumerate(blocks):\\n lang_node = taxonomy.node(language=block.language)\\n if lang_node is None:\\n language_id = None\\n else:\\n language_id = lang_node.id\\n\\n if block.definition and block.f2000 < frequency_cutoff:\\n definition_counter += 1\\n definitions.append(Definition(id=definition_counter,\\n text=block.definition[:100]))\\n definition_id = definition_counter\\n else:\\n definition_id = None\\n\\n lemma_counter += 1\\n lemmas.append(Lemma(id=lemma_counter,\\n lemma=block.lemma,\\n sort=block.sort,\\n wordclass=block.wordclass,\\n firstyear=block.start,\\n lastyear=block.end,\\n refentry=block.refentry,\\n refid=block.refid,\\n thesaurus_id=block.htlink,\\n language_id=language_id,\\n definition_id=definition_id,\\n f2000=_rounder(block.f2000),\\n f1950=_rounder(block.f1950),\\n f1900=_rounder(block.f1900),\\n f1850=_rounder(block.f1850),\\n f1800=_rounder(block.f1800),\\n f1750=_rounder(block.f1750),))\\n\\n for typelist in (block.standard_types,\\n block.variant_types,\\n block.alien_types):\\n for typeunit in typelist:\\n wordforms.append(Wordform(sort=typeunit[0],\\n wordform=typeunit[1],\\n wordclass=typeunit[2],\\n lemma_id=lemma_counter,\\n f2000=_rounder(typeunit[4]),\\n f1900=_rounder(typeunit[5]),\\n f1800=_rounder(typeunit[6]),))\\n\\n if i % 1000 == 0:\\n Definition.objects.bulk_create(definitions)\\n Lemma.objects.bulk_create(lemmas)\\n Wordform.objects.bulk_create(wordforms)\\n definitions = []\\n lemmas = []\\n wordforms = []\\n\\n Definition.objects.bulk_create(definitions)\\n Lemma.objects.bulk_create(lemmas)\\n Wordform.objects.bulk_create(wordforms)\",\n \"def applyStemFilter(self):\\n \\n \\\"\\\"\\\"\\n 027 Steps to do:\\n 1 Create temporary table with all \\\"candidates\\\".\\n 2 Select one line from temp_bow\\n 3 Issue the stem\\n 4 Select from bow result od stem\\n 5a If exists do mergelines\\n 5b Else nothing\\n 6 Remove processed line from temp_bow \\n \\n \\\"\\\"\\\"\\n\\n if not hasattr(self,\\\"stemmer\\\"): # 027 This is to really initialize stemmer.\\n self.initializeStemer() \\n if not hasattr(self,\\\"stemmer\\\") or not self.stemmer : # 027 This is to check if initialization succeded.\\n self.logger.error(\\\"Stemization failed, because stemmer is not initialized.\\\")\\n else:\\n # 027 1 Create temporary table:\\n # 027 Only survives with a current cursor instance\\n sql=\\\"create temporary table BOW_plural_candidates as select * from BOW where word like '%s';\\\"\\n args=()\\n self.DBcursor.execute(sql,args)\\n register=[] # 027 Registers which lines were modified to prevent overwrite in second modification.\\n for cx in range(self.getTableLinesCount(\\\"BOW_plural_candidates\\\",\\\"bow_id\\\")):\\n # 027 2 Select one line from temp_bow\\n sql=\\\"select * from BOW_plural_candidates limit 1;\\\"\\n args=()\\n self.DBcursor.execute(sql,args)\\n line = self.DBcursor.fetchone()\\n if line:\\n # 027 3 Issue the stem\\n stemmedWord=self.stemmer.stemWord(line[1])\\n else:\\n stemmedWord=\\\"\\\"\\n self.logger.debug(\\\"Got wrong input for stemization: %s\\\"%(str(line))) \\n line=[None,None]\\n if not self.getTableLinesCount(\\\"BOW_plural_candidates\\\", \\\"bow_id\\\"):\\n self.logger.debug(\\\"Bow plural candidates table is empty. Ending.\\\")\\n break\\n if stemmedWord in register:\\n self.logger.debug(\\\"Doing commit because word %s was found in register.\\\"%(stemmedWord)) \\n self.DBconnection.commit()\\n if not stemmedWord == line[1]:\\n # 027 4 Select from bow result od stem\\n sql=\\\"select * from BOW where word like ?\\\"\\n args=(stemmedWord,)\\n self.DBcursor.execute(sql,args)\\n singularCandidate = self.DBcursor.fetchall()\\n # 027 5a If exists do mergelines\\n # 027 Lines get merged only when there is exactly one line matching line.\\n # 027 If the stemmed word doesn't match anything original word is preserved.\\n # 027 More line - shall not happen. \\n if len(singularCandidate)==1: \\n self.mergeLines(singularCandidate[0][0], line[0])\\n register.append(stemmedWord)\\n self.logger.debug(\\\" Line %i with word %s was merged to line %i with word %s\\\"%(line[0],line[1],singularCandidate[0][0],singularCandidate[0][1])) \\n # 027 6 Remove processed line from temp_bow \\n sql=\\\"delete from BOW_plural_candidates where bow_id=?;\\\"\\n args=(line[0],)\\n self.DBcursor.execute(sql,args)\\n self.DBconnection.commit()\",\n \"def create_tokens_li():\\n cnt=0\\n for file in docs:\\n file_name = open(\\\"./corpus/\\\"+ str(file) + \\\".txt\\\")\\n print(cnt)\\n cnt+=1\\n words = file_name.read()\\n tokens_doc = nltk.word_tokenize(words)\\n tokens_doc = [w.lower() for w in tokens_doc]\\n #tokens_doc = [snowball_stemmer.stem(token) for token in tokens_doc]\\n tokens_doc = [token for token in tokens_doc if token not in nltk.corpus.stopwords.words('english')]\\n tokens_li.append(tokens_doc)\\n\\n\\n #storing in json file\\n with open('savers/tokens.json', 'w') as fp:\\n json.dump(tokens_li, fp)\",\n \"def attr_synonyms(self):\\n if self._modifier_exists(DUPLICATED_KEY):\\n synonyms = self[CONFIG_KEY][SAMPLE_MODS_KEY][DUPLICATED_KEY]\\n _LOGGER.debug(\\\"Applying synonyms: {}\\\".format(synonyms))\\n for sample in self.samples:\\n for attr, new in list(synonyms.items()):\\n if attr in sample:\\n setattr(sample, new, getattr(sample, attr))\",\n \"def test_synonym(self): \\n pass\",\n \"def scrapeSynonym(word,key='b08CVJHscZ6rRGfc7MzS',language='en_US', max=5):\\n endpoint = \\\"http://thesaurus.altervista.org/thesaurus/v1\\\"\\n url = endpoint + \\\"?word={}&language={}&key={}&output=json\\\".format(word,language,key)\\n r = requests.request('GET', url, timeout=5.0)\\n if r.status_code == 200:\\n try:\\n syns = r.json()['response'][0]['list']['synonyms'].split('|')\\n except KeyError or TypeError:\\n return None\\n\\n del syns[max:]\\n for i in range(len(syns)):\\n syns[i] = syns[i].split(' ')[0] \\n\\n return {'word' : word,'syns' : syns}\",\n \"def test_syndome_LUT(self):\\r\\n syns = []\\r\\n errvecs = golay._make_3bit_errors()\\r\\n for errvec in errvecs:\\r\\n syn = tuple(numpy.mod(numpy.dot(errvec, golay.DEFAULT_H.T), 2))\\r\\n syns.append(syn)\\r\\n self.assertEqual(set(syns), set(golay.DEFAULT_SYNDROME_LUT.keys()))\\r\\n self.assertEqual(len(set(syns)), len(syns))\\r\\n self.assertEqual(len(syns), len(errvecs))\\r\\n self.assertEqual(len(errvecs), 2325)\",\n \"def aliases():\\n fetch(\\\"PropertyValueAliases.txt\\\")\\n longforms = {}\\n shortforms = {}\\n re1 = re.compile(r\\\"^ *sc *; *(\\\\w+) *; *(\\\\w+)\\\")\\n for line in fileinput.input(os.path.basename(\\\"PropertyValueAliases.txt\\\")):\\n m = re1.match(line)\\n if m:\\n l = m.group(2).strip()\\n s = m.group(1).strip()\\n assert(s not in longforms)\\n assert(l not in shortforms)\\n longforms[s] = l\\n shortforms[l] = s\\n else:\\n continue\\n\\n return (longforms, shortforms)\",\n \"def add_entry(wn, synset, lemma, idx=0, n=-1, change_list=None):\\n print(\\\"Adding %s to synset %s\\\" % (lemma, synset.id))\\n n_entries = len(empty_if_none(wn.members_by_id(synset.id)))\\n entry_global = [entry for entry in empty_if_none(wn.entry_by_lemma(lemma))\\n if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech or\\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE and synset.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE or\\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE and synset.part_of_speech == PartOfSpeech.ADJECTIVE]\\n\\n if len(entry_global) == 1:\\n entry_global = wn.entry_by_id(entry_global[0])\\n n_senses = len(entry_global.senses)\\n else:\\n entry_global = None\\n n_senses = 0\\n\\n if idx <= 0:\\n idx = n_entries + 1\\n elif idx > n_entries + 1:\\n raise Exception(\\\"IDX value specified is higher than number of entries\\\")\\n elif idx == n_entries + 1:\\n pass\\n else:\\n for sense_id in sense_ids_for_synset(wn, synset):\\n this_idx = int(sense_id[-2:])\\n if this_idx >= idx:\\n change_sense_idx(wn, sense_id, this_idx + 1)\\n\\n if n < 0:\\n n = n_senses\\n elif n > n_senses:\\n raise Exception(\\\"n value exceeds number of senses for lemma\\\")\\n elif n == n_senses:\\n pass\\n else:\\n sense_n = 0\\n for sense in entry_global.senses:\\n if sense_n >= n:\\n change_sense_n(wn, entry_global, sense.id, sense_n + 1)\\n sense_n += 1\\n\\n wn_synset = wn\\n entries = [entry for entry in empty_if_none(wn_synset.entry_by_lemma(\\n lemma)) if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech]\\n\\n if entries:\\n if len(entries) != 1:\\n raise Exception(\\\"More than one entry for part of speech\\\")\\n print(\\\"Found an entry!\\\")\\n wn_entry = wn.entry_by_id(entries[0])\\n entry = wn_synset.entry_by_id(entries[0])\\n sense = Sense(\\n id=\\\"oewn-%s-%s-%s-%02d\\\" %\\n (escape_lemma(lemma),\\n synset.part_of_speech.value,\\n synset_key(\\n synset.id),\\n idx),\\n synset=synset.id,\\n n=n,\\n sense_key=None)\\n\\n wn_entry.senses.append(sense)\\n entry.senses.append(sense)\\n sense.sense_key = get_sense_key(wn, entry, sense, synset.lex_name)\\n if sense.synset not in wn.members:\\n wn.members[sense.synset] = []\\n wn.members[sense.synset].append(wn_entry.lemma.written_form)\\n else:\\n n = 0\\n print(\\\"Creating new entry\\\")\\n entry = LexicalEntry(\\n \\\"oewn-%s-%s\\\" % (escape_lemma(lemma), synset.part_of_speech.value))\\n entry.set_lemma(Lemma(lemma, synset.part_of_speech))\\n sense = Sense(\\n id=\\\"oewn-%s-%s-%s-%02d\\\" %\\n (escape_lemma(lemma),\\n synset.part_of_speech.value,\\n synset_key(\\n synset.id),\\n idx),\\n synset=synset.id,\\n n=n,\\n sense_key=None)\\n entry.add_sense(sense)\\n sense.sense_key = get_sense_key(wn, entry, sense, synset.lex_name)\\n wn.add_entry(entry)\\n if change_list:\\n change_list.change_entry(wn, entry)\\n return entry\",\n \"def senses(self):\\n sense_set = wordnet.synsets(self.text)\\n\\n result = list()\\n for s in sense_set:\\n result.append(s.lemma_names())\\n\\n return result\",\n \"def store_wn_lookup():\\n syns = list( wn.all_synsets() )\\n #syn_str = map(lambda s: str(s).replace(\\\"Synset\\\",'').strip('()').strip(\\\"'\\\"), syns)\\n syn_str = map(lambda s: str(s).replace(\\\"Synset\\\",'').strip('()').strip(\\\"'\\\").strip('\\\"'), syns)\\n #offsets_list = [(\\\"n%08d\\\" % s.offset, s) for s in syns]\\n olist = map(lambda a, b: (\\\"n%08d\\\" % a.offset, b), syns, syn_str)\\n offset_dict = dict(olist)\\n pickle.dump(offset_dict, open('/Users/xlx/Documents/proj/imgnet-flickr/db3/wn_offset_dict.pickle', 'wb'))\",\n \"def get_synsets_rt(word: str) -> List:\\n return rt.categories(word)\",\n \"def init_auto_alias(self):\\n for alias,cmd in self.auto_alias:\\n self.alias_table[alias] = (0,cmd)\",\n \"def Adjust_Keyword_List( self ):\\r\\n listing = list( self.system.Get_Term_List( ) ) #get the term list of the current profile\\r\\n\\r\\n d=ExpressionAdjust.ExpressionAdjuster( self.root, listing, 'Keywords' )\\r\\n if(d.return_state==0):\\r\\n return #Cancel hit\\r\\n self.system.Set_Term_List( d.profile_list )\\r\\n self.system.Apply_Profile_Term_List_2()\",\n \"def setLemmas(self, lemmas):\\n ankiwords = [Ankiword.fromLemma(lemma) for lemma in lemmas]\\n\\n # now find words from anki database and add it to list\\n letterings = {ankiword.lettering for ankiword in ankiwords}\\n for lettering in letterings:\\n ankiwords.extend(self.ankiInterface.findAnkiwords(lettering))\\n\\n self.ankiwordListWidget.resetAnkiwordList(ankiwords)\",\n \"def test_term_list_removes_duplicates():\\n term = SplineTerm(0)\\n term_list = term + term\\n\\n assert isinstance(term_list, TermList)\\n assert len(term_list) == 1\",\n \"def sents_2(list_of_tweets):\\n stopwords = nltk.corpus.stopwords.words('english')\\n contextTerms = []\\n for sent in list_of_tweets:\\n for word in sent.split():\\n word_lemmatizer = WordNetLemmatizer()\\n word = word_lemmatizer.lemmatize(word.lower())\\n if wordnet.synsets(word) and word not in stopwords and len(word)>2:\\n contextTerms.append(word)\\n\\n #print( contextTerms)\\n return contextTerms\",\n \"def synonyms_wiktionary(name, lang=\\\"fr\\\"):\\n import wptools\\n page = wptools.page(name, wiki='{0}.wiktionary.org'.format(\\n lang), lang=lang, silent=True)\\n page.get_parse()\\n text = page.data['wikitext']\\n syn = \\\"==== {{S|synonymes}} ====\\\"\\n if syn not in text:\\n return None\\n text = text.split(syn)[1].split(\\\"====\\\")[0]\\n reg = re.compile(\\\"[[]{2}(.*?)[]]{2}\\\")\\n res = reg.findall(text)\\n return res\",\n \"def ingest_synonym(\\n cls,\\n app_namespace,\\n index_name,\\n index_type=INDEX_TYPE_SYNONYM,\\n field_name=None,\\n data=None,\\n es_host=None,\\n es_client=None,\\n use_double_metaphone=False,\\n ):\\n data = data or []\\n\\n def _action_generator(docs):\\n\\n for doc in docs:\\n action = {}\\n\\n # id\\n if doc.get(\\\"id\\\"):\\n action[\\\"_id\\\"] = doc[\\\"id\\\"]\\n else:\\n # generate hash from canonical name as ID\\n action[\\\"_id\\\"] = hashlib.sha256(\\n doc.get(\\\"cname\\\").encode(\\\"utf-8\\\")\\n ).hexdigest()\\n\\n # synonym whitelist\\n whitelist = doc[\\\"whitelist\\\"]\\n syn_list = []\\n syn_list.append({\\\"name\\\": doc[\\\"cname\\\"]})\\n for syn in whitelist:\\n syn_list.append({\\\"name\\\": syn})\\n\\n # If index type is INDEX_TYPE_KB we import the synonym into knowledge base object\\n # index by updating the knowledge base object with additional synonym whitelist\\n # field. Otherwise, by default we import to synonym index in ES.\\n if index_type == INDEX_TYPE_KB and field_name:\\n syn_field = field_name + \\\"$whitelist\\\"\\n action[\\\"_op_type\\\"] = \\\"update\\\"\\n action[\\\"doc\\\"] = {syn_field: syn_list}\\n else:\\n action.update(doc)\\n action[\\\"whitelist\\\"] = syn_list\\n\\n yield action\\n\\n mapping = (\\n PHONETIC_ES_SYNONYM_MAPPING\\n if use_double_metaphone\\n else DEFAULT_ES_SYNONYM_MAPPING\\n )\\n es_client = es_client or create_es_client(es_host)\\n mapping = resolve_es_config_for_version(mapping, es_client)\\n load_index(\\n app_namespace,\\n index_name,\\n _action_generator(data),\\n len(data),\\n mapping,\\n DOC_TYPE,\\n es_host,\\n es_client,\\n )\",\n \"def get_synset(self, word):\\n #word = word.decode('utf-8')\\n if word in self.SYNSET_CACHE:\\n return self.SYNSET_CACHE[word]\\n else:\\n synset = set(wn.synsets(word))\\n self.SYNSET_CACHE[word] = synset\\n return synset\",\n \"def make_words(self,lm):\\n if \\\" \\\" in self.corpus[0] and \\\" \\\" in self.corpus[1]: \\n print \\\"assuming BLICK\\\"\\n self.corpus = [convert_to_disc(i) for i in self.corpus]\\n else:\\n self.disc = 1\\n print \\\"assuming Disc\\\" \\n if not os.path.isfile(self.f): ##check if it already exists\\n print \\\"generating 10 million words\\\"\\n outfile = open(self.f, \\\"w\\\")\\n outfile.write(\\\"word,blick,ngram,Real,T,disc\\\\n\\\")\\n for word in self.corpus:\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Real\\\", \\\"1\\\")\\n while len(self.wordlist)<10000000: \\n words = lm.generate(100)\\n for word in words:\\n if word not in self.wordlist and len(word) < 9: #keep only words less than len9\\n write_row_of_bigmatch(word, self.disc, outfile, lm, \\\"Simulated\\\", \\\"0\\\")\\n self.wordlist[word] = 0\\n return\",\n \"def change_entry(wn, synset, target_synset, lemma, change_list=None):\\n print(\\\"Adding %s to synset %s\\\" % (lemma, synset.id))\\n n_entries = len(empty_if_none(wn.members_by_id(target_synset.id)))\\n entry_global = [entry for entry in empty_if_none(wn.entry_by_lemma(lemma))\\n if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech or\\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE and synset.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE or\\n wn.entry_by_id(entry).lemma.part_of_speech == PartOfSpeech.ADJECTIVE_SATELLITE and synset.part_of_speech == PartOfSpeech.ADJECTIVE]\\n\\n if len(entry_global) == 1:\\n entry_global = wn.entry_by_id(entry_global[0])\\n n_senses = len(entry_global.senses)\\n else:\\n entry_global = None\\n n_senses = 0\\n\\n idx = n_entries + 1\\n n = n_senses\\n\\n wn_synset = wn\\n entries = [entry for entry in empty_if_none(wn_synset.entry_by_lemma(\\n lemma)) if wn.entry_by_id(entry).lemma.part_of_speech == synset.part_of_speech]\\n\\n for entry in entries:\\n for sense in wn_synset.entry_by_id(entry).senses:\\n if sense.synset == synset.id:\\n print(\\\"Moving %s to %s\\\" % (sense.id, target_synset.id))\\n sense.synset = target_synset.id\\n wn.change_sense_id(\\n sense,\\n \\\"oewn-%s-%s-%s-%02d\\\" %\\n (escape_lemma(lemma),\\n target_synset.part_of_speech.value,\\n synset_key(\\n target_synset.id),\\n idx),\\n change_list)\\n if change_list:\\n change_list.change_entry(wn, entry)\",\n \"def get_possible_synsets(self, word, pos=None):\\n candidates = wordnet.synsets(word)\\n return [self._synset_dict[SWNEntry.make_unique_key(synset.pos, synset.offset)] for synset in\\n candidates]\",\n \"def update_terms(verbose=False):\\n for be in settings.SOCIALDICT_BACKENDS:\\n try:\\n backends = __import__('socialdict.backends', fromlist=[be])\\n backend = getattr(backends, be)\\n status = backend.update_database_terms()\\n if verbose:\\n print \\\"\\\\nStatus for '%s'\\\" % backend.SOURCE\\n print_status(status)\\n except ImportError, e:\\n print e\\n pass\",\n \"def stemmerAplay(self ):\\n stemmer = nltk.stem.RSLPStemmer()\\n text = []\\n for (news, clazz) in self.dataSet:\\n comstemmer =[str(stemmer.stem(p)) for p in news.split() if p not in self.stopWords]\\n text.append((comstemmer, clazz))\\n return text\",\n \"def _append_CLDR_terms(self, _fallback=dict()):\\n if _fallback:\\n fallback = _fallback\\n else:\\n fallback = self.Fallback\\n for term, value in CLDR:\\n if term and term not in fallback:\\n fallback[term] = value\\n \\n return(fallback)\",\n \"def set_words(data_path):\\n w_df = pd.read_csv(data_path, names=['es','gn','syn1','syn2'], encoding='iso-8859-1') # file -i\\n gn_df = w_df[['gn','syn1','syn2']].drop_duplicates()\\n gn_lst = gn_df['gn'].tolist()+gn_df['syn1'].tolist()+gn_df['syn2'].tolist()\\n cleanedList = [x for x in gn_lst if str(x) != 'nan' and len(x)>=3]\\n gn_set = set(cleanedList)\\n \\n print(len(gn_set))\\n \\n f = open(data_path[:-4]+\\\".txt\\\", 'w')\\n for w in gn_set:\\n f.write('{}\\\\n'.format(w))\\n f.close()\\n \\n return list(gn_set)\",\n \"def analyze_words(self):\\n\\t\\t\\n\\t\\tword_analysis = {}\\n\\t\\tfor word in self.word_list:\\n\\t\\t\\tif word not in word_analysis:\\n\\t\\t\\t\\tacademic = (word in LEMMA_DICT)\\n\\t\\t\\t\\tlength = len(word)\\n\\t\\t\\t\\tfrequency = len(self.word_list[word])\\n\\t\\t\\t\\tstem = word\\t\\n\\t\\t\\t\\tword_location_index = len(self.sentence_index)-1 #first set it as the last index\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tfor index, sentence in self.sentence_index.items():\\n\\t\\t\\t\\t\\tif word in sentence.split():#need to be individual words, not parts of a word\\n\\t\\t\\t\\t\\t\\tword_location_index = index \\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\tif self.word_list[word][0] in sentence.split():#accounts for words with upper cases\\n\\t\\t\\t\\t\\t\\tword_location_index = index\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t#selection critera\\n\\t\\t\\t\\tif academic:\\n\\t\\t\\t\\t\\tselection_criteria = 'academic word'\\n\\t\\t\\t\\telif frequency > 1: \\n\\t\\t\\t\\t\\tselection_criteria = 'high frequency'\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tselection_criteria = 'word length'\\n\\n\\t\\t\\t\\tword_analysis[word] = (academic, length, frequency, stem, word_location_index, selection_criteria)\\n\\t\\t\\n\\t\\tself.word_analysis = word_analysis\\n\\t\\t\\n\\t\\treturn self.word_analysis\",\n \"def list_syms():\\n\\tSymStringVec=[];\\n\\tSymStringVec.append(\\\"CSYM\\\");\\n\\tSymStringVec.append(\\\"DSYM\\\");\\n\\tSymStringVec.append(\\\"TET_SYM\\\");\\n\\tSymStringVec.append(\\\"OCT_SYM\\\");\\n\\tSymStringVec.append(\\\"ICOS_SYM\\\");\\n\\tSymStringVec.append(\\\"ISYM\\\");\\n\\treturn SymStringVec\",\n \"def assume_alias(self):\\n\\n es = self.get_es()\\n if es.head(self.es_alias):\\n #remove all existing aliases - this is destructive and could be harmful, but for current\\n #uses, it is legal - in a more delicate routing arrangement, a configuration file of\\n # some sort should be in use.\\n alias_indices = es[self.es_alias].get('_status')['indices'].keys()\\n\\n remove_actions = [{\\\"remove\\\": {\\\"index\\\": x, \\\"alias\\\": self.es_alias}} for x in\\n alias_indices]\\n remove_data = {\\\"actions\\\": remove_actions}\\n es.post('_aliases', data=remove_data)\\n #now reapply HEAD/master index\\n es.post('_aliases', data={\\\"actions\\\": [{\\\"add\\\":\\n {\\\"index\\\": self.es_index,\\n \\\"alias\\\": self.es_alias}}]})\",\n \"def _tokens_to_terms(self, tokens: Sequence[str]) -> List[int]:\\n ret = []\\n for t in tokens:\\n term = self.stemmer(t)\\n if term in self.term2id_dict:\\n ret.append(self.term2id_dict[term])\\n else:\\n self.term2id_dict[term] = self.g_term_max_id\\n self.id2term_dict[self.g_term_max_id] = term\\n ret.append(self.g_term_max_id)\\n self.g_term_max_id += 1\\n return ret\",\n \"def ingest_synonym(\\n app_namespace,\\n index_name,\\n index_type=INDEX_TYPE_SYNONYM,\\n field_name=None,\\n data=None,\\n es_host=None,\\n es_client=None,\\n use_double_metaphone=False,\\n ):\\n data = data or []\\n\\n def _action_generator(docs):\\n\\n for doc in docs:\\n action = {}\\n\\n # id\\n if doc.get(\\\"id\\\"):\\n action[\\\"_id\\\"] = doc[\\\"id\\\"]\\n else:\\n # generate hash from canonical name as ID\\n action[\\\"_id\\\"] = hashlib.sha256(\\n doc.get(\\\"cname\\\").encode(\\\"utf-8\\\")\\n ).hexdigest()\\n\\n # synonym whitelist\\n whitelist = doc[\\\"whitelist\\\"]\\n syn_list = []\\n syn_list.append({\\\"name\\\": doc[\\\"cname\\\"]})\\n for syn in whitelist:\\n syn_list.append({\\\"name\\\": syn})\\n\\n # If index type is INDEX_TYPE_KB we import the synonym into knowledge base object\\n # index by updating the knowledge base object with additional synonym whitelist\\n # field. Otherwise, by default we import to synonym index in ES.\\n if index_type == INDEX_TYPE_KB and field_name:\\n syn_field = field_name + \\\"$whitelist\\\"\\n action[\\\"_op_type\\\"] = \\\"update\\\"\\n action[\\\"doc\\\"] = {syn_field: syn_list}\\n else:\\n action.update(doc)\\n action[\\\"whitelist\\\"] = syn_list\\n\\n yield action\\n\\n mapping = (\\n PHONETIC_ES_SYNONYM_MAPPING\\n if use_double_metaphone\\n else DEFAULT_ES_SYNONYM_MAPPING\\n )\\n es_client = es_client or create_es_client(es_host)\\n mapping = resolve_es_config_for_version(mapping, es_client)\\n load_index(\\n app_namespace,\\n index_name,\\n _action_generator(data),\\n len(data),\\n mapping,\\n DOC_TYPE,\\n es_host,\\n es_client,\\n )\",\n \"def produce_all_term_data(self):\\n # remove cold start records if requested\\n test = self.test.copy()\\n test = self.handle_cold_start(test)\\n\\n outputs = self.output()\\n trainf, testf = outputs['train'], outputs['test']\\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\\n self.write_libfm_data(ftrain, ftest, self.train, test)\\n\\n # Write the term-to-id guide\\n test = test.sort(('termnum'))\\n test['rownum'] = np.arange(len(test))\\n guide = test.groupby('termnum').max()['rownum']\\n with self.output()['guide'].open('w') as f:\\n guide.to_csv(f, index_label='termnum', header=True)\",\n \"def stokenizeKBD(TargetQuestionsD, StopWords):\\n for i in TargetQuestionsD:\\n mqstokens = [] \\n for mq in TargetQuestionsD[i][\\\"matched questions\\\"]:\\n mqstokens.extend(stokenize(mq, StopWords)[:])\\n TargetQuestionsD[i][\\\"mq stokens\\\"] = mqstokens[:]\\n\\n TargetQuestionsD[i][\\\"ans stokens\\\"] = stokenize(TargetQuestionsD[i][\\\"answer\\\"], StopWords)[:]\\n \\n return \\\"TargetQuestionsD = {i : {'question': , 'answer': , 'resource': , 'matched questions': [], 'count': , 'mq stokens': [], 'ans stokens': []}}\\\"\",\n \"def list_sequence_concept(self, name='list_concepts_found.tsv'):\\n # Useful later #\\n gi_to_key = lambda gi: self.a.db.get(\\\"gi\\\",\\\"id\\\",gi)[1]\\n key_to_envos = lambda key: marshal.loads(self.a.db.get(\\\"isolation\\\",\\\"id\\\",key)[2])\\n gi_to_envos = lambda gi: key_to_envos(gi_to_key(gi))\\n # Loop #\\n with open(self.a.out_dir + name, 'w') as handle:\\n for seq, gis in self.a.seq_to_gis.items():\\n gis = [gi for gi in gis if gi in self.a.db]\\n isokeys = set(gi_to_key(gi) for gi in gis)\\n envos = [e for key in isokeys for e in key_to_envos(key)]\\n for envo in envos:\\n seq_name = self.a.renamed_to_orig[seq]\\n envo_id = \\\"ENVO:%08d\\\" % envo\\n concept_name = self.a.integer_to_name.get(envo, envo_id)\\n concept_gis = [gi for gi in gis if envo in gi_to_envos(gi)]\\n count_gis = len(concept_gis)\\n line = (seq_name, envo_id, concept_name, str(count_gis), str(concept_gis))\\n handle.write('\\\\t'.join(line) + '\\\\n')\",\n \"def load_synset_vectors(self, babelfied_synset_entry):\\n synset_vectors = []\\n for synset_id in babelfied_synset_entry.babelfied_synset_ids:\\n if len(synset_id) > 0:\\n babelfied_synset_pos = synset_id[-1] # wn:06681177n --> n\\n if babelfied_synset_pos == \\\"n\\\": # is a noun --> it can potentially have a synset embedding\\n self.statistics.synset_noun()\\n babelfied_synset_id = synset_id[3:-1] # wn:06681177n --> 06681177\\n s = babelfied_synset_pos + babelfied_synset_id # wn:06681177n --> n06681177\\n if self.synset_embeddings.contains_word(s): \\n vector = self.synset_embeddings.word_to_vec(s)\\n synset_vectors.append(vector)\\n self.statistics.known_synset()\\n else:\\n self.statistics.unknown_synset()\\n \\n if len(synset_vectors) == 0: # if no tokens has a synset, this sentence gets the zero_fallback embedding\\n synset_vectors = self.synset_embeddings.get_zero_fallback()\\n bool_synset_vectors_inSentence = False\\n else:\\n bool_synset_vectors_inSentence = True\\n \\n return synset_vectors, bool_synset_vectors_inSentence\",\n \"def _solve_double_synonym(parse_tree, solution_format=None):\\n def _get_value(solution_list, word):\\n # Gets the value of a word in a solution list\\n for solution in solution_list:\\n if solution[0] == word:\\n return solution[1]\\n\\n return 0\\n\\n # Get the two synonym parts\\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\\n first_syn = _create_sentence(first_syn)\\n second_syn = _create_sentence(second_syn)\\n\\n # Get top 1000 matching scores for each part of the clue\\n if solution_format is not None:\\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\\n else:\\n first_solutions = SimilaritySolver.solve(first_syn)\\n second_solutions = SimilaritySolver.solve(second_syn)\\n second_words = [word for word, _ in second_solutions]\\n\\n # Combine both lists, with the value being the product of the value for eac syn part\\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\\n solution in first_solutions if solution[0] in second_words]\\n\\n return solutions\",\n \"def save(self):\\n lang = self.languageCombo.currentText()\\n kwSet = self.setSpinBox.value()\\n self.__keywords[lang][\\\"Sets\\\"][kwSet] = self.keywordsEdit.toPlainText()\\n \\n for lang, keywords in self.__keywords.items():\\n Preferences.setEditorKeywords(lang, keywords[\\\"Sets\\\"])\",\n \"def update_taxon_set(self):\\n assert self.taxon_set is not None\\n for taxon in self.taxon_seq_map:\\n if taxon not in self.taxon_set:\\n self.taxon_set.add(taxon)\",\n \"def make_lexicon_words_txt(self):\\n raise NotImplementedError\",\n \"def expand_synset(neighbor_word_list, language):\\n if not expand_synset_activated or not language.__eq__(\\\"English\\\"):\\n return neighbor_word_list\\n\\n new_neighbor_word_set = set()\\n for word in neighbor_word_list:\\n new_neighbor_word_set.add(word)\\n\\n synsets = wn.synsets(word)\\n synonyms_list = [item.name().split('.')[0] for item in synsets] # extract: \\\"dog.n.01\\\"->\\\"dog\\\"\\n for new_word in synonyms_list:\\n new_neighbor_word_set.add(new_word)\\n\\n for i in xrange(synonyms_list.__len__()):\\n if synonyms_list[i].__eq__(word):\\n hyponyms = synsets[i].hyponyms()\\n hyponyms_list = [item.name().split('.')[0] for item in hyponyms] # extract: \\\"dog.n.01\\\"->\\\"dog\\\"\\n for new_word1 in hyponyms_list:\\n new_neighbor_word_set.add(new_word1)\\n\\n hypernyms = synsets[i].hypernyms()\\n hypernyms_list = [item.name().split('.')[0] for item in hypernyms] # extract: \\\"dog.n.01\\\"->\\\"dog\\\"\\n for new_word1 in hypernyms_list:\\n new_neighbor_word_set.add(new_word1)\\n return list(new_neighbor_word_set)\",\n \"def get_well_aliases(self):\\n return self.info_wells['well'].unique()\",\n \"def disambiguate(self, sense_clusters:List[List[str]],\\n definitions:List[str] = None) \\\\\\n -> List[Union[float, Tuple[float, float]]]:\\n\\n def get_contextualized_embedding(ids):\\n outputs = model(ids)[0]\\n # out = torch.mean(torch.stack(hidden_states[-2:]), dim=0).squeeze()\\n out = outputs.squeeze()\\n return out\\n\\n if definitions is None:\\n definitions = ['']*len(sense_clusters)\\n load_model()\\n hypers_scores = []\\n defs_scores = []\\n with torch.no_grad():\\n cosine = torch.nn.CosineSimilarity(dim=0)\\n\\n tokens = self.tokenize(do_mask=False)\\n target_start, target_end = self.target_indices(do_mask=False)\\n cxt_ids = model_tok.encode(tokens)\\n cxt_ids = torch.tensor(cxt_ids).unsqueeze(0).to(device)\\n cxt_embedding = get_contextualized_embedding(cxt_ids)\\n target_embeddings = cxt_embedding[target_start+1:target_end+1, :]\\n target_embedding = torch.mean(target_embeddings, dim=0).squeeze()\\n\\n for sc in sense_clusters:\\n if any(x.strip() for x in sc):\\n sc_str = ', '.join(x.strip() for x in sc if x.strip())\\n sc_tokens = model_tok.tokenize(sc_str)\\n sc_inds = [ind+1 for ind in range(len(sc_tokens))\\n if sc_tokens[ind] != ',']\\n sc_ids = torch.tensor(model_tok.encode(sc_str)).unsqueeze(0).to(device)\\n assert len(sc_ids[0]) == len(sc_tokens) + 2, (len(sc_ids[0]), len(sc_tokens))\\n sc_embeddings = get_contextualized_embedding(sc_ids)\\n sc_embedding = torch.mean(sc_embeddings[sc_inds, :], dim=0)\\n sc_score = cosine(sc_embedding, target_embedding).item()\\n assert isinstance(sc_score, float), sc_str\\n hypers_scores.append(sc_score)\\n else:\\n hypers_scores.append(0)\\n for def_ in definitions:\\n if def_.strip():\\n def_ids = torch.tensor(model_tok.encode(def_)).unsqueeze(0).to(device)\\n def_embeddings = get_contextualized_embedding(def_ids)\\n def_embedding = torch.mean(def_embeddings[1:-1, :], dim=0)\\n def_score = cosine(def_embedding, target_embedding).item()\\n assert isinstance(def_score, float), def_\\n defs_scores.append(def_score)\\n else:\\n defs_scores.append(None)\\n logger.debug(f'Sense clusters received: {sense_clusters}, '\\n f'scores: {hypers_scores}')\\n out = []\\n for s_score, def_score in zip(hypers_scores, defs_scores):\\n out.append((s_score, def_score) if def_score else s_score)\\n return out\",\n \"def save_dists(self, name):\\n with open(name, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n for word in self._distWords:\\n f.write(\\\"{} | {}\\\\n\\\".format(word, \\\",\\\".join(map(str_tuple, self._distWords[word].items()))))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57324946","0.5650351","0.554946","0.5542705","0.5465308","0.54454356","0.5441436","0.53831476","0.5370351","0.5335252","0.5318396","0.5302473","0.5295376","0.5264259","0.52387655","0.5215229","0.5215099","0.5204873","0.5161386","0.51540685","0.513916","0.5135307","0.51185834","0.51160204","0.5097079","0.5086153","0.5076992","0.5065237","0.5061621","0.505156","0.5049513","0.5047816","0.50387293","0.5035599","0.5018663","0.49994925","0.49969926","0.4971931","0.49580476","0.4943553","0.49411657","0.49216336","0.4920106","0.49026367","0.4899389","0.48842114","0.48752588","0.48628867","0.48566845","0.48540285","0.48509568","0.4843715","0.48358566","0.4826558","0.4825982","0.48186374","0.48145136","0.48099175","0.48077956","0.48036042","0.4801332","0.48011076","0.47972438","0.47815058","0.47781664","0.47775117","0.47742355","0.47730437","0.4770151","0.47655112","0.4755579","0.4744059","0.4737872","0.4736744","0.47202978","0.4708924","0.47035748","0.4699208","0.46992064","0.46984518","0.4697215","0.4692604","0.46806955","0.4678264","0.4674542","0.46744534","0.46736446","0.4662865","0.46604466","0.46603516","0.46511278","0.46511042","0.46503562","0.4650172","0.464652","0.4639667","0.46387604","0.46309337","0.46275157","0.46243566"],"string":"[\n \"0.57324946\",\n \"0.5650351\",\n \"0.554946\",\n \"0.5542705\",\n \"0.5465308\",\n \"0.54454356\",\n \"0.5441436\",\n \"0.53831476\",\n \"0.5370351\",\n \"0.5335252\",\n \"0.5318396\",\n \"0.5302473\",\n \"0.5295376\",\n \"0.5264259\",\n \"0.52387655\",\n \"0.5215229\",\n \"0.5215099\",\n \"0.5204873\",\n \"0.5161386\",\n \"0.51540685\",\n \"0.513916\",\n \"0.5135307\",\n \"0.51185834\",\n \"0.51160204\",\n \"0.5097079\",\n \"0.5086153\",\n \"0.5076992\",\n \"0.5065237\",\n \"0.5061621\",\n \"0.505156\",\n \"0.5049513\",\n \"0.5047816\",\n \"0.50387293\",\n \"0.5035599\",\n \"0.5018663\",\n \"0.49994925\",\n \"0.49969926\",\n \"0.4971931\",\n \"0.49580476\",\n \"0.4943553\",\n \"0.49411657\",\n \"0.49216336\",\n \"0.4920106\",\n \"0.49026367\",\n \"0.4899389\",\n \"0.48842114\",\n \"0.48752588\",\n \"0.48628867\",\n \"0.48566845\",\n \"0.48540285\",\n \"0.48509568\",\n \"0.4843715\",\n \"0.48358566\",\n \"0.4826558\",\n \"0.4825982\",\n \"0.48186374\",\n \"0.48145136\",\n \"0.48099175\",\n \"0.48077956\",\n \"0.48036042\",\n \"0.4801332\",\n \"0.48011076\",\n \"0.47972438\",\n \"0.47815058\",\n \"0.47781664\",\n \"0.47775117\",\n \"0.47742355\",\n \"0.47730437\",\n \"0.4770151\",\n \"0.47655112\",\n \"0.4755579\",\n \"0.4744059\",\n \"0.4737872\",\n \"0.4736744\",\n \"0.47202978\",\n \"0.4708924\",\n \"0.47035748\",\n \"0.4699208\",\n \"0.46992064\",\n \"0.46984518\",\n \"0.4697215\",\n \"0.4692604\",\n \"0.46806955\",\n \"0.4678264\",\n \"0.4674542\",\n \"0.46744534\",\n \"0.46736446\",\n \"0.4662865\",\n \"0.46604466\",\n \"0.46603516\",\n \"0.46511278\",\n \"0.46511042\",\n \"0.46503562\",\n \"0.4650172\",\n \"0.464652\",\n \"0.4639667\",\n \"0.46387604\",\n \"0.46309337\",\n \"0.46275157\",\n \"0.46243566\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52873546"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":17088,"cells":{"query":{"kind":"string","value":"Harvest biogenic co2 synonyms (not worth correcting for other biogenic substances??)"},"document":{"kind":"string","value":"def _add_to_existing_flowable(self, fb, new_terms):\n biog = ('124-38-9' in fb)\n for term in new_terms:\n self._fm.add_synonym(fb, term)\n if biog and bool(biogenic.search(term)):\n self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym"},"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 nsrSynonyms():\r\n # Input file\r\n synonymsFile = pd.read_csv(args.indir+\"/\"+args.infile2, header=2,\r\n sep=\"\\t\", encoding=\"utf8\")\r\n\r\n # Parse taxonomic names into their elementary components\r\n synonyms = synonymsFile.loc[synonymsFile['language'] == 'Scientific']\r\n synonymDict = {}\r\n for synonym, taxon in zip(synonyms['synonym'], synonyms['taxon']):\r\n synonym = taxonParser(synonym)\r\n taxon = taxonParser(taxon)\r\n if not taxon or synonym is False or taxon is False:\r\n pass\r\n else:\r\n synonymDict[synonym] = taxon\r\n\r\n # Write dictionary to file\r\n with io.open(par_path+\"/results/nsr_synonyms.csv\", \"w\", encoding=\"utf-8\") as outfile:\r\n outfile.write(\"synonym_name,identification_reference,taxon_name,taxon_author\\n\")\r\n for key, value in synonymDict.items():\r\n outfile.write('\"%s\",\"%s\",\"%s\",\"%s\"' % (' '.join(str(key).split()[:2]), ' '.join(str(key).split()[2:]),\r\n ' '.join(str(value).split()[:2]), ' '.join(str(value).split()[2:])))\r\n outfile.write(\"\\n\")\r\n return [*synonymDict], synonymDict","def get_chebi_synonyms(chebi_ent):\n if hasattr(chebi_ent, 'Synonyms'):\n return [entry.data for entry in chebi_ent.Synonyms]\n else:\n return []","def find_synonymous(input_file, work_dir):\n # create the .ctl file\n ctl_file = op.join(work_dir, \"yn-input.ctl\")\n output_file = op.join(work_dir, \"nuc-subs.yn\")\n ctl_h = open(ctl_file, \"w\")\n ctl_h.write(\"seqfile = %s\\noutfile = %s\\nverbose = 0\\n\" %\n (input_file, output_file))\n ctl_h.write(\"icode = 0\\nweighting = 0\\ncommonf3x4 = 0\\n\")\n ctl_h.close()\n\n cl = YnCommandline(ctl_file)\n print >>sys.stderr, \"\\tyn00:\", cl\n r, e = cl.run()\n ds_value_yn = None\n ds_value_ng = None\n dn_value_yn = None\n dn_value_ng = None\n\n # Nei-Gojobori\n output_h = open(output_file)\n row = output_h.readline()\n while row:\n if row.find(\"Nei & Gojobori\") >=0:\n for x in xrange(5):\n row = output_h.next()\n dn_value_ng, ds_value_ng = row.split('(')[1].split(')')[0].split()\n break\n row = output_h.readline()\n output_h.close()\n\n # Yang\n output_h = open(output_file)\n for line in output_h:\n if line.find(\"+-\") >= 0 and line.find(\"dS\") == -1:\n parts = line.split(\" +-\")\n ds_value_yn = extract_subs_value(parts[1])\n dn_value_yn = extract_subs_value(parts[0])\n\n if ds_value_yn is None or ds_value_ng is None:\n h = open(output_file)\n print >>sys.stderr, \"yn00 didn't work: \\n%s\" % h.read()\n\n return ds_value_yn, dn_value_yn, ds_value_ng, dn_value_ng","def get_synonyms(word,w2v,pos,max=20):\n synonyms = []\n count = 0\n synsets = wordnet.synsets(word,pos=pos)\n for synset in synsets:\n candidate_names = []\n for lemma in synset.lemma_names():\n candidate_names.append(lemma)\n for hypo in synset.hyponyms():\n candidate_names.append(hypo)\n for hyper in synset.hypernyms():\n candidate_names.append(hyper)\n\n for lemma in candidate_names:\n if count >= max:\n break\n # print pos,word,lemma\n try:\n similarity = w2v.n_similarity([word.lower()],[lemma.lower() ])\n if similarity > .34 and lemma not in synonyms:\n synonyms.append(lemma)\n\n count += 1\n except:\n continue\n\n return synonyms","def scrapeSynonym(word,key='b08CVJHscZ6rRGfc7MzS',language='en_US', max=5):\n endpoint = \"http://thesaurus.altervista.org/thesaurus/v1\"\n url = endpoint + \"?word={}&language={}&key={}&output=json\".format(word,language,key)\n r = requests.request('GET', url, timeout=5.0)\n if r.status_code == 200:\n try:\n syns = r.json()['response'][0]['list']['synonyms'].split('|')\n except KeyError or TypeError:\n return None\n\n del syns[max:]\n for i in range(len(syns)):\n syns[i] = syns[i].split(' ')[0] \n\n return {'word' : word,'syns' : syns}","def getSynonyms(graph, verbose=False):\n # create list containing all nodes\n pages = [node for node in graph.nodes]\n\n # loop through all nodes by intervals of 50\n lastcount = 0\n for count in range(50, len(pages), 50):\n # send 50 nodes to getRedirects()\n getRedirects(pages[lastcount:count])\n if verbose:\n print(\"DONE \" + str(count) + \"/\" + str(len(pages)))\n # update lastcount for next cycle\n lastcount = count\n\n # send leftover nodes to getRedirects()\n getRedirects(pages[lastcount: lastcount + (len(pages) % 50)])\n\n if verbose:\n print(\"DONE \" + str(len(pages)) + \"/\" + str(len(pages)))\n\n # return completed SYNONYM_DICT\n return SYNONYM_DICT","def synonyms_wiktionary(name, lang=\"fr\"):\n import wptools\n page = wptools.page(name, wiki='{0}.wiktionary.org'.format(\n lang), lang=lang, silent=True)\n page.get_parse()\n text = page.data['wikitext']\n syn = \"==== {{S|synonymes}} ====\"\n if syn not in text:\n return None\n text = text.split(syn)[1].split(\"====\")[0]\n reg = re.compile(\"[[]{2}(.*?)[]]{2}\")\n res = reg.findall(text)\n return res","def information_content_similarity(s1, s2):\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\n\n # Disambiguate words and create list of sysnsets \n synsets_sentence_1 = []\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_1.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_1.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n synsets_sentence_2 = []\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_2.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_2.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n\n score, count = 0.0, 0\n # For each word in the first sentence\n for synset in synsets_sentence_1:\n L = []\n for ss in synsets_sentence_2:\n try:\n L.append(synset.lin_similarity(ss, brown_ic))\n except:\n continue\n if L: \n best_score = max(L)\n score += best_score\n count += 1\n # Average the values\n if count > 0: score /= count\n return score","def get_synonyms(word):\n try:\n query = {'word': word}\n cursor = database['Words'].find(query)\n synonym_set = set()\n if cursor is None:\n return None\n for document in cursor:\n if len(document['synsets']) > 0:\n for key, synset in document['synsets'].items():\n synonyms = synset['synonyms'].split(\",\")\n for synonym in synonyms:\n synonym_set.add(synonym.strip())\n if len(synonym_set) == 0:\n return None\n return synonym_set\n except Exception as e:\n print(e)\n return None","def get_synonym(name: str) -> str:\n return s2n.get_name(n2s.get_smiles(name))","def get_synonyms(word):\n syns_sets = wordnet.synsets(word)\n if syns_sets:\n # if there's synonyms, take the first set\n desired = syns_sets[0].lemma_names()\n desired = [the_name.replace(\"_\", \" \") for the_name in desired]\n return desired\n\n else:\n return False","def get_synonyms(word):\n synsets = [];\n syns = wn.synsets(word)\n for ss in syns:\n lemmas = []\n for l in ss.lemmas():\n lemma = { \"name\": l.name(), \"related_forms\": [] }\n for x in l.derivationally_related_forms():\n lemma['related_forms'].append(x.name())\n lemmas.append(lemma)\n synsets.append({\n \"lemmas\": lemmas,\n \"d\": ss.definition(),\n \"pos\": ss.pos(),\n \"id\": ss.name()\n })\n return synsets","def synonymic_list_generator(content):\n\tpass","def _flow_terms(flow):\n return flow.synonyms","def lookup_in_taxonomy(results):\n from unidecode import unidecode\n\n base_url = \"http://taxonomy.projectchronos.eu/space/dbpediadocs/{}\"\n labels = []\n resource = None\n for res in results:\n res = unidecode(res)\n try:\n # print base_url.format(res)\n resource = retrieve_json(base_url.format(res))\n except Exception as e:\n print Exception('Cannot fetch taxonomy: ' + res.encode('ascii', 'replace') + ' ' + str(e))\n\n if resource and 'relatedConcepts' in resource.keys():\n for c in resource['relatedConcepts']:\n if c:\n label = c[c.rfind('/') + 1:].replace('+', ' ')\n # print 'Found! ' + label\n labels.append(str(label))\n return set(labels)","def test_synonym(self): \n pass","def synsets_similarity(s1, s2):\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\n\n # Disambiguate words and create list of sysnsets \n synsets_sentence_1 = []\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\n if lemma in stop_words:\n continue\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_1.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_1.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n\n synsets_sentence_2 = []\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\n if lemma in stop_words:\n continue\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_2.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_2.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n\n # Compute similarity\n if len(synsets_sentence_1) != 0 and len(synsets_sentence_2) != 0:\n similarity = 1 - jaccard_distance(set(synsets_sentence_1), set(synsets_sentence_2))\n return similarity\n else:\n return 0","def get_hyponyms(word):\n syn = wn.synsets(word)\n hnyms = []\n for h in syn[0].hyponyms():\n print h\n hnyms.append({\n \"lemmas\": h.lemma_names(),\n \"d\": h.definition(),\n \"pos\": h.pos(),\n \"id\": h.name()\n })\n return hnyms","def test_analytics_synonyms(self):\n class Query:\n \"\"\" A class to execute analytics queries \"\"\"\n\n def __init__(self, server, username, password):\n self.restconn = RestConnection(server)\n\n def execute(self, query):\n return self.restconn.execute_statement_on_cbas(query, None)\n\n def get_synonyms(self):\n synonyms = set()\n\n for result in json.loads(self.execute(\"select * from Metadata.`Synonym`\"))['results']:\n synonym = result['Synonym']\n synonym_name = synonym['SynonymName']\n synonym_target = synonym['ObjectDataverseName'] + '.' + synonym['ObjectName']\n synonym_dataverse = synonym['DataverseName']\n synonyms.add((synonym_name, synonym_target, synonym_dataverse))\n\n return synonyms\n\n def get_synonyms_count(self):\n return json.loads(self.execute(\"select count(*) as count from Metadata.`Synonym`;\"))['results'][0]['count']\n\n class Dataset:\n\n def __init__(self, name, bucket, clause=None):\n self.name, self.bucket, self.clause = name, bucket, clause\n\n def get_where_clause(self):\n return f\" WHERE {self.clause}\" if self.clause else \"\"\n\n class Synonym:\n\n def __init__(self, name, target):\n self.name, self.target = name, target\n\n class Dataverse:\n\n def __init__(self, name):\n self.name = name\n self.datasets = set()\n self.synonyms = set()\n\n def add_dataset(self, dataset):\n self.datasets.add(dataset)\n\n def add_synonym(self, synonym):\n self.synonyms.add(synonym)\n\n def next_dataset_name(self):\n return f\"dat_{len(self.datasets)}\"\n\n def next_synonym_name(self):\n return f\"syn_{len(self.synonyms)}\"\n\n class Analytics:\n\n def __init__(self, query):\n self.query, self.dataverses = query, set()\n\n def add_dataverse(self, dataverse):\n self.dataverses.add(dataverse)\n\n def next_dataverse_name(self):\n return f\"dtv_{len(self.dataverses)}\"\n\n def pick_target_for_synonym(self):\n choices = [f\"{dataverse.name}.{dataset.name}\" for dataverse in self.dataverses for dataset in dataverse.datasets]\n\n if choices:\n return choice(choices)\n\n return None\n\n def create(self):\n # Create daterverses and datasets\n for dataverse in self.dataverses:\n self.query.execute(f\"CREATE dataverse {dataverse.name}\")\n\n for dataset in dataverse.datasets:\n self.query.execute(f\"CREATE DATASET {dataverse.name}.{dataset.name} ON {dataset.bucket}{dataset.get_where_clause()}\")\n\n # Create synonyms\n for dataverse in self.dataverses:\n for synonym in dataverse.synonyms:\n self.query.execute(f\"CREATE analytics synonym {dataverse.name}.{synonym.name} FOR {synonym.target}\")\n\n def delete(self):\n for dataverse in self.dataverses:\n for dataset in dataverse.datasets:\n self.query.execute(f\"DROP DATASET {dataverse.name}.{dataset.name}\")\n\n for synonym in dataverse.synonyms:\n self.query.execute(f\"DROP analytics synonym {dataverse.name}.{synonym.name}\")\n\n self.query.execute(f\"DROP dataverse {dataverse.name}\")\n\n class AnalyticsTest:\n\n def __init__(self, backup, no_of_dataverses, no_of_datasets, no_of_synonyms, analytics_server):\n # The base class\n self.backup = backup\n\n # Test parameters\n self.no_of_dataverses, self.no_of_datasets, self.no_of_synonyms = no_of_dataverses, no_of_datasets, no_of_synonyms\n\n # The number of synonyms that get created\n self.no_of_synonyms_created = no_of_dataverses * no_of_synonyms\n\n # The object thats used to run queries on the server running analytics\n self.query = Query(analytics_server, analytics_server.rest_username, analytics_server.rest_password)\n\n # The object that represents our current model of analytics\n self.analytics = Analytics(self.query)\n\n def test_analytics(self):\n # Define the analytics model (i.e. which dataverses, datasets and synonyms are present)\n for i in range(self.no_of_dataverses):\n dataverse = Dataverse(self.analytics.next_dataverse_name())\n self.analytics.add_dataverse(dataverse)\n\n for j in range(self.no_of_datasets):\n dataset = Dataset(dataverse.next_dataset_name(), 'default')\n dataverse.add_dataset(dataset)\n\n for j in range(self.no_of_synonyms):\n synonym = Synonym(dataverse.next_synonym_name(), self.analytics.pick_target_for_synonym())\n dataverse.add_synonym(synonym)\n\n # Create dataverses, datasets and synonyms\n self.analytics.create()\n self.backup.assertEqual(self.query.get_synonyms_count(), self.no_of_synonyms_created)\n\n # Create a repository\n self.backup.backup_create()\n\n # Take a backup\n self.backup.backup_cluster()\n\n # Delete all analytics related stuff\n self.analytics.delete()\n self.backup.assertEqual(self.query.get_synonyms_count(), 0)\n\n # Perform a one off restore\n self.backup.backup_restore()\n synonyms = self.query.get_synonyms()\n\n # Check synonyms have been restored\n for dataverse in self.analytics.dataverses:\n for synonym in dataverse.synonyms:\n self.backup.assertIn((synonym.name, synonym.target, dataverse.name), synonyms)\n\n # The server that will be reprovisioned with analytics\n analytics_server = self.restore_cluster_host = self.servers[2]\n\n # Add a server and provision it with analytics\n self.add_server_with_custom_services(analytics_server, services=[\"cbas\"])\n\n # A little sleep for services to warmup\n self.assertTrue(RestConnection(analytics_server).wait_until_cbas_is_ready(100))\n\n # Run the analytics test\n AnalyticsTest(self, self.input.param(\"dataverses\", 5), self.input.param(\"datasets\", 5), self.input.param(\"synonyms\", 5), analytics_server).test_analytics()","def find_hypernyms(self, syns):\n names = set()\n # Find hypernyms of each syn\n for syn in syns:\n hypernyms = syn.hypernyms()\n # find hypernyms one more level up\n for hypernym in hypernyms:\n names.add(hypernym.name())\n hypernyms_second = hypernym.hypernyms()\n for h in hypernyms_second:\n names.add(h.name())\n return names","def get_searched_single_word_synonym(self, content, stop_words):\n content = re.sub(r\"[^\\w\\s]\", \"\", content)\n content = re.sub(r\"[0-9]+\", \"\", content)\n new_sent = [\n Word(word).singularize()\n for word in content.lower().split()\n if Word(word).singularize() not in stop_words\n ]\n new_sent = [\n Word(word).singularize()\n for word in new_sent\n if Word(word).singularize() in set(self.searched_words)\n ]\n\n syn = []\n for w in new_sent:\n for s in wordnet.synsets(w):\n for lemma in s.lemmas():\n if len(syn) == SYNONYM_LIMIT:\n break\n syn.append(lemma.name())\n syn = list(dict.fromkeys(syn)) #\n syn = \" \".join(syn)\n return syn","def find_all_ORFs_both_strands(dna):\n \n # YOUR IMPLEMENTATION HERE","def fetch_synsets(w, tag):\n if tag in ['PUNC', 'CONJe', 'RESe', 'DETe', 'Pe', 'DET', 'NUM', 'CL', 'P', 'NUMe', 'RES', 'CONJ', 'PRO', 'POSTP', 'INT']:\n return []\n #if tag not in tag_map:\n # return []\n pos = tag_map[tag]\n w = re.sub(r'[ی]', 'ي', w)\n query = \"SELECT id FROM synset WHERE pos=\\\"\" + pos + \"\\\" and id IN (SELECT synset FROM sense WHERE value LIKE \\\"\" + w + \"\\\")\"\n cur.execute(query)\n\n output = []\n for row in cur.fetchall():\n output.append(row[0])\n return output","def testTwoWords(self):\n\n\t\t\t\twords = ['business', 'directory']\n\t\t\t\tsynonyms = spinner.Synonym.objects.get_synonyms(words)\n\n\t\t\t\tassert len(synonyms)","def main():\n tl = TwoLocus(in_path='/csbiodata/public/www.csbio.unc.edu/htdocs/sgreens/pairwise_origins/')\n # tl = TwoLocus()\n # tl.preprocess(glob.glob('OR_ss_origins/*.hap'))\n print len(tl.list_available_strains())\n exit()\n # print len(tl.list_available_strains())\n # tl.preprocess(['cc_origins.csv'])\n # tl.preprocess(['ccv_origins.csv'])\n classical = [s for s in\n [\"129P1/ReJ\", # \"129P3/J\", \"129S1SvlmJ\", \"129S6\", \"129T2/SvEmsJ\", \"129X1/SvJ\", \"A/J\", \"A/WySnJ\",\n \"AEJ/GnLeJ\", \"AEJ/GnRk\", \"AKR/J\", \"ALR/LtJ\", \"ALS/LtJ\", \"BALB/cByJ\", \"BALB/cJ\", \"BDP/J\", \"BPH/2J\",\n # \"BPL/1J\", \"BPN/3J\", \"BTBR T<+>tf/J\", \"BUB/BnJ\", \"BXSB/MpJ\", \"C3H/HeJ\", \"C3HeB/FeJ\", \"C57BL/10J\",\n # \"C57BL/10ScNJ\", \"C57BL/10SAAAJ\", \"C57BL/6CR\", \"C57BL/6J\", \"C57BL/6NCI\", \"C57BL/6Tc\", \"C57BLKS/J\",\n # \"C57BR/cdJ\", \"C57L/J\", \"C58/J\", \"CBA/CaJ\", \"CBA/J\", \"CE/J\", \"CHMU/LeJ\", \"DBA/1J\", \"DBA/1LacJ\",\n # \"DBA/2DeJ\", \"DBA/2HaSmnJ\", \"DBA/2J\", \"DDK/Pas\", \"DDY/JclSidSeyFrkJ\", \"DLS/LeJ\", \"EL/SuzSeyFrkJ\",\n # \"FVB/NJ\", \"HPG/BmJ\", \"I/LnJ\", \"IBWSP2\", \"IBWSR2\", \"ICOLD2\", \"IHOT1\", \"IHOT2\", \"ILS\", \"ISS\", \"JE/LeJ\",\n # \"KK/HlJ\", \"LG/J\", \"LP/J\", \"LT/SvEiJ\", \"MRL/MpJ\", \"NOD/ShiLtJ\", \"NON/ShiLtJ\", \"NONcNZO10/LtJ\",\n # \"NONcNZO5/LtJ\", \"NOR/LtJ\", \"NU/J\", \"NZB/BlNJ\", \"NZL/LtJ\", \"NZM2410/J\", \"NZO/HlLtJ\", \"NZW/LacJ\", \"P/J\",\n # \"PL/J\", \"PN/nBSwUmabJ\", \"RF/J\", \"RHJ/LeJ\", \"RIIIS/J\", \"RSV/LeJ\", \"SB/LeJ\", \"SEA/GnJ\", \"SEC/1GnLeJ\",\n # \"SEC/1ReJ\", \"SH1/LeJ\", \"SI/Col Tyrp1 Dnahc11/J\", \"SJL/Bm\", \"SJL/J\", \"SM/J\", \"SSL/LeJ\", \"ST/bJ\",\n \"STX/Le\", ] # \"SWR/J\", \"TALLYHO/JngJ\", \"TKDU/DnJ\", \"TSJ/LeJ\", \"YBR/EiJ\", \"ZRDCT Rax<+>ChUmdJ\"]\n if tl.is_available(s)]\n wild_derived = [s for s in\n ['22MO',\n # 'BIK/g', 'BULS', 'BUSNA', 'BZO', 'CALB/RkJ', 'CASA/RkJ', 'CAST/EiJ', 'CIM', 'CKN', 'CKS',\n 'CZECHI/EiJ', 'CZECHII/EiJ', 'DCA', 'DCP', 'DDO', 'DEB', 'DGA', 'DIK', 'DJO', 'DKN', 'DMZ', 'DOT',\n # 'IS/CamRkJ', 'JF1/Ms', 'LEWES/EiJ', 'MBK', 'MBS', 'MCZ', 'MDG', 'MDGI', 'MDH', 'MGA', 'MH',\n # 'MOLD/RkJ', 'MOLF/EiJ', 'MOLG/DnJ', 'MOR/RkJ', 'MPB', 'MSM/Ms', 'PERA/EiJ', 'PERC/EiJ', 'POHN/Deh',\n # 'PWD/PhJ', 'PWK/PhJ', 'RBA/DnJ', 'RBB/DnJ', 'RBF/DnJ', 'SF/CamEiJ', 'SKIVE/EiJ', 'SOD1/EiJ',\n # 'STLT', 'STRA', 'STRB', 'STUF', 'STUP', 'STUS', 'TIRANO/EiJ', 'WLA', 'WMP', 'WSB/EiJ',\n 'ZALENDE/EiJ'] if tl.is_available(s)]\n tl.contingency_table(classical, wild_derived, '/csbiohome01/sgreens/Projects/intervals/contingency.csv')\n exit()\n x = TwoLocus(chrom_sizes=[20e6, 20e6])\n x.preprocess([\"test2.csv\"])\n x.unique_combos(['A', 'B', 'D'], ['C', 'E'])\n x.sources_at_point_pair('1', 1, '1', 10000000, ['A'])\n # x.interlocus_dependence([chr(c) for c in xrange(ord('A'), ord('J')+1)])\n # exit()\n\n x = TwoLocus(chrom_sizes=[20 * 10 ** 6, 20 * 10 ** 6])\n x.preprocess([\"test.csv\"])\n rez = x.pairwise_frequencies([\"A\"])\n\n areas = x.calculate_genomic_area(rez[0], rez[1])\n total = 0.0\n\n for combo in subspecies.iter_combos():\n print \"\\t{:15s}({:4d}):{:1.5f}\".format(subspecies.to_string(combo), combo,\n areas[str(subspecies.to_string(combo))])\n total += areas[str(subspecies.to_string(combo))]\n print \"\\t{:21s}:{:1.5f}\".format(\"Total\", total)\n\n sys.exit(1)\n # for code, combo in combos.iteritems():\n # print \"\\n\", rez[1]\n # print \"\\t{} ({}):\\n{}\".format(combo, code, rez[0][code])","def get_person_text(self, uid):\n words = \"\"\n\n query = \"\"\"\nSELECT ?overview ?researchO ?label\nWHERE\n{\n <%s> <http://vivoweb.org/ontology/core#overview> ?overview .\n <%s> <http://vivoweb.org/ontology/core#researchOverview> ?researchO .\n <%s> <http://www.w3.org/2000/01/rdf-schema#label> ?label .\n}\n \"\"\" % (uid, uid, uid)\n self.setQuery(query)\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n words = \"%s %s %s\" % (g['results']['bindings'][0]['overview']['value'], g['results']['bindings'][0]['researchO']['value'], g['results']['bindings'][0]['label']['value'])\n except:\n print \"Select failed: %s\" % query\n\n self.setQuery(\"\"\"\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\nSELECT ?name\nWHERE\n{\n ?auth vivo:relates <%s> .\n ?auth rdf:type vivo:Authorship .\n ?auth vivo:relates ?art .\n filter (?art!=<%s>) .\n ?art <http://vivoweb.org/ontology/core#dateTimeValue> ?date .\n ?date <http://vivoweb.org/ontology/core#dateTime> ?year .\n filter (?year>\"2009-01-01T00:00:00Z\"^^xsd:dateTime) .\n ?art rdfs:label ?name .\n}\nLIMIT 20\n\"\"\" % (uid, uid))\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n for t in g['results']['bindings']:\n words = words + \" \" + t['name']['value']\n\n except:\n print \"Select failed\"\n traceback.print_exc(file=sys.stdout)\n\n self.setQuery(\"\"\"\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n\nSELECT ?name\nWHERE\n{\n ?grant vivo:relates <%s> .\n ?grant rdf:type vivo:Grant .\n ?grant <http://vivoweb.org/ontology/core#dateTimeInterval> ?date .\n ?date <http://vivoweb.org/ontology/core#end> ?end .\n ?end <http://vivoweb.org/ontology/core#dateTime> ?year .\n filter (?year>\"2009-01-01T00:00:00Z\"^^xsd:dateTime) .\n ?grant rdfs:label ?name .\n}\n\n \"\"\" % (uid))\n try:\n rval = self.query()\n try:\n g = rval.convert()\n except:\n pass\n\n for t in g['results']['bindings']:\n words = words + \" \" + t['name']['value']\n\n except:\n print \"Select failed\"\n traceback.print_exc(file=sys.stdout)\n\n\n\n\n return words","def get_legal_synonyms(input_filepath):\n syn_filepath = TestSystem.get_synonym_solution_filepath(input_filepath)\n if not os.path.isfile(syn_filepath):\n return None\n with io.open(syn_filepath, 'r') as f:\n result = dict()\n for l in f:\n if not l.startswith('#'):\n [name, val] = l.rstrip().split(\"===\")\n if name not in result:\n result[name] = [val]\n else:\n result[name].append(val)\n\n return result","def nsrGenera(taxonList, synonymList):\r\n species = list(filter(None, sorted(taxonList + synonymList)))\r\n generaList = [i.split()[0] for i in species]\r\n generaList = list(dict.fromkeys(generaList))\r\n return generaList","def synonyms(self) -> List[str]:\n return pulumi.get(self, \"synonyms\")","def weed_out_synonyms(word, potential_synonyms):\n real_synonyms = set()\n for synonym in potential_synonyms:\n max_distance = abs(len(word) - len(synonym))\n abbr_len = min(len(word), len(synonym))\n forgiveness = round(1/7 * abbr_len)\n if lev.distance(word, synonym) <= max_distance + forgiveness:\n # Then it's a synonym!\n real_synonyms.add(synonym)\n return real_synonyms","def extract_abbreviation_synonyms(self, corpus, use_gold, use_pred):\n assert not (use_gold and use_pred), \"No support for both\"\n entities = corpus.entities() if use_gold else corpus.predicted_entities()\n\n for entity in entities:\n prev2 = entity.prev_tokens(entity.sentence, 2)\n next1 = entity.next_tokens(entity.sentence, 1)\n in_parenthesis = len(prev2) == 2 and prev2[-1].word == \"(\" and len(next1) == 1 and next1[0].word == \")\"\n\n if (in_parenthesis):\n prev_entity = prev2[0].get_entity(entity.part, use_gold, use_pred)\n\n if prev_entity is not None and prev_entity.class_id == entity.class_id:\n # We could combine features already -- Yet, give more freedom to final clients to use the synonym's features or not\n # merged_binary_features = {key: (b1 or b2) for ((key, b1), (_, b2)) in zip(prev_entity.features.items(), entity.features.items())}\n\n prev_entity.features['synonym'] = entity\n entity.features['synonym'] = prev_entity","def test_synonymizer_with_other(self):\n resource = OntologyResource(slug=\"foo_bar.obo\", directory=INPUT_DIR, local=True)\n oi = SimpleOboImplementation(resource)\n syn_param = [\n Synonymizer(\n the_rule=\"Broad match terms with the term 'other' in them.\",\n match=\"(?i)^Other \", # noqa W605\n match_scope=\"*\",\n replacement=\"\",\n qualifier=\"broad\",\n ),\n ]\n synonymization = LexicalTransformation(TransformationType.Synonymization, params=syn_param)\n pipelines = [\n LexicalTransformationPipeline(name=\"test_other\", transformations=synonymization)\n ]\n lexical_index = create_lexical_index(oi, pipelines=pipelines, synonym_rules=syn_param)\n\n for _, v in lexical_index.groupings.items():\n relation = [x for x in v.relationships if x.synonymized is True]\n self.assertTrue(len(relation), 1)\n self.assertEqual(relation[0].predicate, \"oio:hasBroadSynonym\")","def wordNet_similarity(sentence1, sentence2):\r\n # Tokenize and tag\r\n \r\n # sentence1 = pos_tag(word_tokenize(sentence1))\r\n sentence1=st_tagger.tag(word_tokenize(sentence1))\r\n \r\n # sentence2 = pos_tag(word_tokenize(sentence2))\r\n sentence2=st_tagger.tag(word_tokenize(sentence2))\r\n\r\n \r\n # Get the synsets for the tagged words\r\n #################################################\r\n\r\n # synsets1=[]\r\n # synsets2=[]\r\n # for tagged_word in sentence1:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n # for tagged_word in sentence2:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # print(tagged_word)\r\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n\r\n # The code above is the elaboration of code below\r\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\r\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\r\n \r\n # Filter out the Nones in the synonym set\r\n synsets1 = [ss for ss in synsets1 if ss]\r\n synsets2 = [ss for ss in synsets2 if ss]\r\n \r\n score, count = 0.0, 0\r\n \r\n###########################################################################\r\n # for syn1 in synsets1:\r\n # arr_simi_score = []\r\n # print('=========================================')\r\n # print(syn1)\r\n # print('----------------')\r\n # for syn2 in synsets2:\r\n # print(syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n # print(simi_score)\r\n # if simi_score is not None:\r\n # arr_simi_score.append(simi_score)\r\n # print('----------------')\r\n # print(arr_simi_score)\r\n # if(len(arr_simi_score) > 0):\r\n # best = max(arr_simi_score)\r\n # print(best)\r\n # score += best\r\n # count += 1\r\n # # Average the values\r\n # print('score: ', score)\r\n # print('count: ', count)\r\n # score /= count\r\n\r\n###########################################################################\r\n\r\n for syn1 in synsets1:\r\n arr_simi_score = []\r\n # print('=========================================')\r\n print(\"Each word from Synonym se1\",syn1)\r\n # print('----------------')\r\n for syn2 in synsets2:\r\n print(\"Each word from Synonym se2\",syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n simi_score = syn1.wup_similarity(syn2)\r\n print(\"word to word path_similarity score\",simi_score)\r\n if simi_score is not None:\r\n arr_simi_score.append(simi_score)\r\n print('----------------')\r\n print(arr_simi_score)\r\n if(len(arr_simi_score) > 0):\r\n best = max(arr_simi_score)\r\n print(\"best score so far\", best)\r\n score += best\r\n count += 1\r\n # Average the values\r\n print('score: ', score)\r\n print('count: ', count)\r\n if count!=0:\r\n score /= count\r\n else:\r\n score=0.0\r\n return score","def generate_antonym_pairs(config: SettingConfig) -> dict:\n print(f\"Generating initial antonym pairs from RoWordNet @ {datetime.now()}\")\n wn = rwn.RoWordNet()\n\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\n # the PoS and the value is a set of pairs of words of PoS specified by the key\n pairs = dict()\n\n # Iterate over the selected parts of speech\n for part_of_speech in config.pos.values():\n\n pos_pairs = list()\n\n # Return all synsets corresponding to the PoS\n synset_ids = wn.synsets(pos=part_of_speech)\n\n # Iterate all the synsets for the current PoS\n for synset_id in synset_ids:\n\n # Get the synset object specified by synset_id\n synset = wn.synset(synset_id)\n\n # Get the outbound relations of type antonym from\n outbound_relations = filter(lambda x: x[1] == 'near_antonym', wn.outbound_relations(synset_id))\n\n # Iterate outbound relations\n for relation in outbound_relations:\n # Get the synset corresponding to the target of the outbound relation\n target_synset = wn.synset(relation[0])\n\n # Get all the pairs, sort them by first word to keep set entries unique\n current_iteration_pairs = get_cross_synset_pairs(synset, target_synset)\n\n # Add the current set of pairs\n pos_pairs.extend(current_iteration_pairs)\n\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\n for key, value in config.pos.items():\n if value == part_of_speech:\n pairs[key] = unique(pos_pairs)\n\n # Return the whole dictionary\n print(f\"Successfully generated antonym paris @ {datetime.now()}\")\n return pairs","def covid_mention(text, synonyms=covid_list):\n for term in synonyms:\n if term in text:\n return 'Yes'\n continue\n return 'No'","def cousins(word, level):\r\n parents = [get_synset(word)]\r\n for _ in range(level):\r\n parent_hypernyms = [parent.hypernyms() for parent in parents]\r\n parents = list(chain(*parent_hypernyms))\r\n\r\n children = parents\r\n for _ in range(level):\r\n children_hyponyms = [child.hyponyms() for child in children]\r\n children = list(chain(*children_hyponyms))\r\n\r\n children = set(children)\r\n children -= {get_synset(word)}\r\n return set(map(synset_name, children))","def load_known_corpora():\n\n print (\"Loading Corpora\")\n\n # For debugging purposes, comment out the definition of all but say the first\n # corpus, to speed the ingest time.\n shenoute_a22 = Corpus()\n shenoute_a22.annis_corpus_name = \"shenoute.a22\"\n shenoute_a22.title = \"Acephalous Work 22\"\n shenoute_a22.slug = \"acephalous_work_22\"\n shenoute_a22.urn_code = \"shenoute.a22\"\n shenoute_a22.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-a22\"\n\n patrum = Corpus()\n patrum.annis_corpus_name = \"apophthegmata.patrum\"\n patrum.title = \"Apophthegmata Patrum\"\n patrum.slug = \"ap\"\n patrum.urn_code = \"ap\"\n patrum.github = \"https://github.com/CopticScriptorium/corpora/tree/master/AP\"\n\n saof = Corpus()\n saof.annis_corpus_name = \"shenoute.abraham.our.father\"\n saof.title = \"Abraham Our Father\"\n saof.slug = \"abraham_our_father\"\n saof.urn_code = \"shenoute.abraham\"\n saof.github = \"https://github.com/CopticScriptorium/corpora/tree/master/abraham\"\n\n besa_ap = Corpus()\n besa_ap.annis_corpus_name = \"besa.letters\"\n besa_ap.title = \"Letter to Aphthonia\"\n besa_ap.slug = \"to_aphthonia\"\n besa_ap.urn_code = \"besa.aphthonia\"\n besa_ap.github = \"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\"\n\n fox = Corpus()\n fox.annis_corpus_name = \"shenoute.fox\"\n fox.title = \"Not Because a Fox Barks\"\n fox.slug = \"not_because_a_fox_barks\"\n fox.urn_code = \"shenoute.fox\"\n fox.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-fox\"\n\n mark = Corpus()\n mark.annis_corpus_name = \"sahidica.mark\"\n mark.title = \"Gospel of Mark\"\n mark.slug = \"gospel_of_mark\"\n mark.urn_code = \"nt.mark\"\n mark.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n corinth = Corpus()\n corinth.annis_corpus_name = \"sahidica.1corinthians\"\n corinth.title = \"1 Corinthians\"\n corinth.slug = \"1st_corinthians\"\n corinth.urn_code = \"nt.1cor\"\n corinth.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n snt = Corpus()\n snt.annis_corpus_name = \"sahidica.nt\"\n snt.title = \"New Testament\"\n snt.slug = \"new-testament\"\n snt.urn_code = \"nt\"\n snt.github = \"https://github.com/CopticScriptorium/corpora/tree/master/bible\"\n\n eager = Corpus()\n eager.annis_corpus_name = \"shenoute.eagerness\"\n eager.title = \"I See Your Eagerness\"\n eager.slug = \"eagernesss\"\n eager.urn_code = \"shenoute.eagerness\"\n eager.github = \"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-eagerness\"\n\n besa_nuns = Corpus()\n besa_nuns.annis_corpus_name = \"besa.letters\"\n besa_nuns.title = \"Letter to Thieving Nuns\"\n besa_nuns.slug = \"to_thieving_nuns\"\n besa_nuns.urn_code = \"besa.thieving\"\n besa_nuns.github = \"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\"\n\n doc_pap = Corpus()\n doc_pap.annis_corpus_name = \"doc.papyri\"\n doc_pap.title = \"Documentary Papyri\"\n doc_pap.slug = \"papyri\"\n doc_pap.urn_code = \"copticDoc:papyri_info\"\n doc_pap.github = \"https://github.com/CopticScriptorium/corpora/tree/master/doc-papyri\"\n\n known_corpora = [shenoute_a22, patrum, saof, besa_ap, fox, mark, corinth, snt, eager, besa_nuns, doc_pap]\n# known_corpora = [shenoute_a22]\n \n for one in known_corpora:\n try:\n Corpus.objects.get(slug__exact=one.slug)\n except Corpus.DoesNotExist:\n one.save()","def meet(self, word, sense1=0, sense2=0):\n s1 = self._synset(self.text, sense1)\n s2 = self._synset(word, sense2)\n\n common = s1.lowest_common_hypernyms(s2)\n\n result = list()\n for c in common:\n result.append(c.name()[:5])\n\n return result if result else []","def recommend_cosim():\n pass","def poem_generation(magnet,topic):\r\n e = inflect.engine()\r\n antonyms = []\r\n synonyms = []\r\n poem = \"\"\r\n verb = \"\"\r\n # plural\r\n if (e.singular_noun(topic) is False):\r\n verb = \"is\"\r\n else:\r\n verb = \"are\"\r\n \r\n for syn in wordnet.synsets(topic):\r\n for l in syn.lemmas():\r\n synonyms.append(l.name())\r\n if l.antonyms():\r\n antonyms.append(l.antonyms()[0].name())\r\n if (len(set(antonyms)) < 1):\r\n for syn in wordnet.synsets(RAND_LIST[random.randint(0,len(RAND_LIST)-1)]):\r\n for l in syn.lemmas():\r\n synonyms.append(l.name())\r\n if l.antonyms():\r\n antonyms.append(l.antonyms()[0].name())\r\n topic = topic.capitalize()\r\n for i in range(0,random.randint(5,15)):\r\n verse = random.randint(0,6)\r\n question = random.randint(0,6)\r\n # structure\r\n # antonyms\r\n if (verse < 2) and len(antonyms) > 0:\r\n ant_magnet = metaphor_magnet(antonyms[random.randint(0,len(antonyms)-1)])\r\n choice = random.randint(0,len(ant_magnet)-1)\r\n detail = ant_magnet[choice].split(\":\")\r\n if (question < 2):\r\n index = random.randint(0,len(QUESTION)-1)\r\n if (detail[0][0] in ['a','e','i','o','u']):\r\n poem += QUESTION[index] + \" \" + verb + \" \" + topic + \" not like an \" + detail[0] + \" \" + detail[1] + \"?\\n\" \r\n else:\r\n poem += QUESTION[index] + \" \" + verb + \" \" + topic + \" not like a \" + detail[0] + \" \" + detail[1] + \"?\\n\" \r\n else:\r\n if (detail[0][0] in ['a','e','i','o','u']):\r\n poem += topic + \" \" + verb + \" not like an \" + detail[0] + \" \" + detail[1] + \".\\n\" \r\n else:\r\n poem += topic + \" \" + verb + \" not like a \" + detail[0] + \" \" + detail[1] + \".\\n\" \r\n \r\n else:\r\n choice = random.randint(0,len(magnet)-1)\r\n detail = magnet[choice].split(\":\")\r\n if (question < 2):\r\n index = random.randint(0,len(QUESTION)-1)\r\n if (detail[0][0] in ['a','e','i','o','u']):\r\n poem += QUESTION[index] + \" \" + verb + \" \" + topic + \" like an \" + detail[0] + \" \" + detail[1] + \"?\\n\" \r\n else:\r\n poem += QUESTION[index] + \" \" + verb + \" \" + topic + \" like a \" + detail[0] + \" \" + detail[1] + \"?\\n\" \r\n else:\r\n if (detail[0][0] in ['a','e','i','o','u']):\r\n poem += topic + \" \" + verb + \" like an \" + detail[0] + \" \" + detail[1] + \"\\n\" \r\n else:\r\n poem += topic + \" \" + verb + \" like a \" + detail[0] + \" \" + detail[1] + \"\\n\" \r\n \r\n return poem","def synonyms_pipeline(config: SettingConfig) -> None:\n raw_synonym_pairs = generate_synonym_pairs(config)\n for pos in config.pos.keys():\n processed_synonym_pairs = postprocess_pairs(raw_synonym_pairs[pos], config)\n write_pairs(processed_synonym_pairs, config.constraints_root_path, pos, \"synonyms\")","def main():\n long_sequence = input(\"Please give ne a DNA sequence to search: \")\n short_sequence = input(\"What DNA sequence would you like to match? \")\n\n # converts characters to uppercase\n new_long_sequence = long_sequence.upper()\n new_short_sequence = short_sequence.upper()\n\n ans = homology(new_long_sequence, new_short_sequence)\n print(\"The best match is \" + ans)","def composeWorkplaceOntology():\n\n import ossPyFuncs \n import pandas as pd\n \n #mysql query to extract full table from government organizations\n #certian table columns feature capital letters which cases uproblems\n postgreSql_selectQuery=\"SELECT * FROM us_gov_manual.us_govman_2019 ;\"\n #pass querry and obtain table\n govTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n\n #mysql query to obtain academic instutions\n postgreSql_selectQuery=\"SELECT institution FROM hipolabs.universities ;\"\n #pass querry and obtain table\n univTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2018_us1000;\"\n businesses1=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2019_us1000;\"\n businesses2=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n \n postgreSql_selectQuery=\"SELECT company FROM forbes.fortune2020_global2000;\"\n businesses3=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\n\n #combine theinsitutions into a vector\n combinedSeries=[govTable['AgencyName'],univTable['institution'],businesses1['company'],businesses2['company'],businesses3['company']]\n #turn the multi item vector into a single series\n fullWordbank=pd.concat(combinedSeries)\n #turn that series into a pd dataframe\n wordbankTable=pd.DataFrame(fullWordbank.unique())\n\n return wordbankTable","def getSynonyms(self, wordSet):\n synonyms = {}\n for w in wordSet:\n # find synonyms\n synsets = wn.synsets(w, pos=wn.NOUN)\n if len(synsets) > 0: \n # there are noun senses for this word, get synonyms\n synonyms[w] = set([synset.name for synset in synsets])\n \n return synonyms","def return_wikipedia_term(res):\n rst = []\n if res['spotted']:\n for s in [s['spot'] for s in res['value']['spots']]:\n r = TagMeService.retrieve_taggings(s.encode('utf-8'), method='POST')\n if len(r['annotations']) != 0:\n for n in r['annotations']:\n if 'title' in n.keys():\n title = n['title'].replace(' ', '_') # strip whitespaces from dbpedia tag\n rst.append(title)\n else:\n print \"Cannot find title in annotations: \" + str(n)\n return rst","def get_hypernyms(word):\n syn = wn.synsets(word)\n hnyms = []\n for h in syn[0].hypernyms():\n hnyms.append({\n \"lemmas\": h.lemma_names(),\n \"d\": h.definition(),\n \"pos\": h.pos(),\n \"id\": h.name()\n })\n return hnyms","def synonyms(self) -> List[str]:\n return self._synonyms","def substantiate():","def generate_synonym_pairs(config: SettingConfig) -> dict:\n wn = rwn.RoWordNet()\n\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\n # the PoS and the value is a set of pairs of words of PoS specified by the key\n pairs = dict()\n\n # Iterate over the selected parts of speech\n for part_of_speech in config.pos.values():\n\n pos_pairs = list()\n\n # Return all synsets corresponding to the PoS\n synset_ids = wn.synsets(pos=part_of_speech)\n\n # Iterate all the synsets for the current PoS\n for synset_id in synset_ids:\n # Get the synset object specified by synset_id\n synset = wn.synset(synset_id)\n\n # Get all the pairs, sort them by first word to keep set entries unique\n current_iteration_pairs = get_synset_pairs(synset)\n\n # Append all pairs from the current PoS to the global set\n pos_pairs.extend(current_iteration_pairs)\n\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\n for key, value in config.pos.items():\n if value == part_of_speech:\n pairs[key] = unique(pos_pairs)\n\n return pairs","def boldNSR(species, synonyms, syn_dict, zip_path):\r\n # Loop over each genus(file) downloaded from BOLD\r\n print('Comparing sequence data to list of species...')\r\n # Open genera file from zip\r\n with zipfile.ZipFile(zip_path) as z:\r\n for file in z.namelist():\r\n if not os.path.isdir(file):\r\n # Read genera file\r\n filename = os.fsdecode(file)\r\n if filename.endswith(\".tsv\"):\r\n with z.open(filename, 'r') as zfile:\r\n zfile = io.TextIOWrapper(io.BytesIO(zfile.read()), errors='ignore')\r\n tsvreader = csv.DictReader(zfile, delimiter=\"\\t\")\r\n # Read each record\r\n for line in tsvreader:\r\n # Filter on Geographical site\r\n if (line['country'] == \"Netherlands\"):\r\n bold_identification = re.sub('[()]', '', str(line['identification_reference']))\r\n bold_name = line['species_name'] + \" \" + bold_identification\r\n # Compare BOLD with NSR species names\r\n if (bold_name in species):\r\n boldOutput(args.outfile1, line)\r\n # Check for synonyms, apply accepted name\r\n elif (bold_name in synonyms):\r\n for synonym, taxon in syn_dict.items():\r\n synonym = ' '.join(synonym.split()[:2])\r\n if synonym == line['species_name']:\r\n taxon = ' '.join(taxon.split()[:2])\r\n line['species_name'] = taxon\r\n boldOutput(args.outfile1, line)\r\n # Write missmatches to seperate file\r\n else:\r\n boldOutput(args.outfile2, line)\r\n continue\r\n else:\r\n continue","def known_organisms():\n return [\"rat\"]","def _solve_double_synonym(parse_tree, solution_format=None):\n def _get_value(solution_list, word):\n # Gets the value of a word in a solution list\n for solution in solution_list:\n if solution[0] == word:\n return solution[1]\n\n return 0\n\n # Get the two synonym parts\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\n first_syn = _create_sentence(first_syn)\n second_syn = _create_sentence(second_syn)\n\n # Get top 1000 matching scores for each part of the clue\n if solution_format is not None:\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\n else:\n first_solutions = SimilaritySolver.solve(first_syn)\n second_solutions = SimilaritySolver.solve(second_syn)\n second_words = [word for word, _ in second_solutions]\n\n # Combine both lists, with the value being the product of the value for eac syn part\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\n solution in first_solutions if solution[0] in second_words]\n\n return solutions","def get_speech(self, word):\n posses = ['verb', 'noun', 'adj', 'adv', 'as in', 'conjunction']\n speeches = []\n\n def get_all_synonyms(word1, speech1):\n for w in Word(word1).synonyms('all', partOfSpeech=speech1):\n if not w == []:\n return w\n return []\n\n def empty_tree(input_list):\n # print(input_list)\n if type(input_list) == type([]):\n for l in input_list:\n if not empty_tree(l):\n return False\n return True\n else:\n return False\n\n for poss in posses:\n if not empty_tree(get_all_synonyms(word, poss)):\n speeches.append(poss)\n return speeches","def synonyms(self):\n\n return [synonym[\"name\"] for synonym in self._get_synonym_json()]","def select_syninfo(self, cellname, srctype, syntype):\n idx = np.char.startswith(self.syntab['dest'], cellname+'/') & \\\n np.char.startswith(self.syntab['source'], srctype) & \\\n np.char.startswith(self.syntab['type'], syntype)\n return self.syntab[idx]","def find_pseudonyms(original_name, gender, topk):\n firstnames = load_firstnames(gender)\n model = load_model()\n whitelist = LetterBag(slugify.slugify(\n WORD_SPLIT_PATTERN.sub(\"\", original_name)))\n for firstname in firstnames:\n if not whitelist.includes(firstname):\n continue\n for lastname, proba in generate_word(model, whitelist.sub(firstname), topk):\n yield firstname.surface, lastname, proba","def get_words_from_sysets(synset):\n synlist = []\n for s in synset:\n syns = s.lemmas()[0].name()\n synlist.append(syns)\n return synlist","def sample_sonnet(hmm, obs_map, n_words):\n sonnetLines = []\n sonnet = ''\n\n for numLines in range(14):\n line = sample_sentence(hmm, obs_map, n_words)\n sonnetLines.append(''.join(line).capitalize() + '\\n')\n\n for line in sonnetLines:\n sonnet += line\n\n return sonnet","def make_concordance(debug=False):\n query = \"\"\"\n SELECT ?uri ?name\n WHERE {\n ?uri a skos:Concept .\n ?uri rdfs:label ?name .\n }\"\"\"\n result = vivo_sparql_query(query)\n\n if 'results' in result and 'bindings' in result['results']:\n rows = result[\"results\"][\"bindings\"]\n else:\n return concordance\n if debug:\n print query\n if len(rows) >= 2:\n print rows[0],rows[1]\n elif len(rows) == 1:\n print rows[0]\n concordance = shelve.open(\"concordance\")\n for row in rows:\n name = row['name']['value']\n uri = str(row['uri']['value'])\n concordance[uri] = name\n if debug:\n print concordance.items()[1:3]\n return concordance","def Path_Similarity(word1, word2):\n\n # Initial test to confirm unique nouns, otherwise passes back 1\n\n if word1 == word2:\n return 1, word1\n\n # Sets up Initial Variables & Dictionaries\n\n stepup1 = [word1]\n stepup2 = [word2]\n dict1= {}\n dict2= {}\n currentstep1 = []\n currentstep2 = []\n\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\n # for each word to individual dictionaries with the number of iterations\n # as the key to the dictionary. The two dictionaries are saved perpetually\n\n for la in range(50):\n for i in range(len(stepup1)):\n currentstep1 += (stepup1[i].hypernyms())\n for syn in stepup1:\n dict1[syn] = la\n for i in range(len(stepup2)):\n currentstep2 = (stepup2[i].hypernyms())\n for syn in stepup2:\n dict2[syn] = la\n\n # Variables are reset and converted to continue the next stage of the loop\n\n stepup1 = currentstep1\n stepup2 = currentstep2\n currentstep1 = []\n currentstep2 = []\n\n\n # Each loop the dictionaries are checked for matches. I have confirmed that\n # checking each cycle is faster than checking at the end of an arbitrary\n # number of cycles.\n\n # Removes applied words as Possible Subsumers Per Fridays Clas\n dict1.pop(word1)\n dict2.pop(word2)\n\n #Gets possible Least Common Subsumers\n dict1Set = set(dict1)\n dict2Set = set(dict2)\n d = {}\n for name in dict1Set.intersection(dict2Set):\n d[name] = dict1[name]\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\n\n #Returns Actual LCS\n key_lcs = []\n for i in pos_lcs:\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\n\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\n\n return 1/(dict1[lcs] + dict2[lcs]), lcs","def hypernym(self, sense=None):\n s = self._synset(self.text)\n\n if not s:\n return []\n\n hyper = s.hypernyms()\n\n results = list()\n for h in hyper:\n results.append(h.lemma_names())\n\n if not sense:\n return results\n\n return results[:sense]","def find_all_ORFs(dna):\n \n # YOUR IMPLEMENTATION HERE","def nsrTaxonomy():\r\n # Input file\r\n taxonomyFile = pd.read_csv(args.indir+\"/\"+args.infile1, header=2,\r\n sep=\"\\t\", encoding=\"utf8\")\r\n\r\n # Parse taxonomic names into their elementary components\r\n taxonomy = taxonomyFile.loc[taxonomyFile['rank'] == 'soort']\r\n taxonList = []\r\n for taxon in taxonomy['scientific_name']:\r\n parser = taxonParser(taxon)\r\n if not parser or parser is False:\r\n pass\r\n else:\r\n taxonList.append(parser)\r\n\r\n # Write taxonomy to file\r\n index = 0\r\n with io.open(par_path+\"/results/nsr_species.csv\", \"w\", encoding=\"utf-8\") as outfile:\r\n outfile.write('\"species_id\",\"species_name\",\"identification_reference\"\\n')\r\n for i in taxonList:\r\n binomial = ' '.join(str(i).split()[:2])\r\n authorship = ' '.join(str(i).split()[2:])\r\n outfile.write('%s,%s,\"%s\"\\n' % (index, binomial, authorship))\r\n index += 1\r\n\r\n return taxonList","def get(self, request, format=None):\n user = request.user\n user.backend = 'django.contrib.auth.backends.ModelBackend'\n login(request, user)\n data = {}\n data['synonyms'] = []\n tags = request.GET.get('tags', '')\n for tag in tags.split(','):\n result = requests.get('https://wordsapiv1.p.mashape.com/words/{0}/synonyms'.format(tag),\n headers={\n \"X-Mashape-Key\": settings.MASHAPE,\n \"Accept\": \"application/json\",\n })\n if 'synonyms' in result.json():\n data['synonyms'] += result.json()['synonyms']\n return Response(data)","def generateWord2(self, parameters=None):\n\n\t\t##Initial set-up\n\t\t#A syllable consists of an optional onset, a nucleus, and an optional coda\n\t\t#Sources:\n\t\t# http://en.wikipedia.org/wiki/English_phonology#Phonotactics\n\t\t# http://en.wiktionary.org/wiki/Appendix:English_pronunciation\n\t\tonsets = [\"ch\", \"pl\", \"bl\", \"cl\", \"gl\", \"pr\", \"br\", \"tr\", \"dr\", \"cr\", \"gr\", \"tw\", \"dw\", \"qu\", \"pu\",\n\t\t\t\t \"fl\", \"sl\", \"fr\", \"thr\", \"shr\", \"wh\", \"sw\",\n\t\t\t\t \"sp\", \"st\", \"sk\", \"sm\", \"sn\", \"sph\", \"spl\", \"spr\", \"str\", \"scr\", \"squ\", \"sm\"] #Plus the normal consonants\n\t\tnuclei = [\"ai\", \"ay\", \"ea\", \"ee\", \"y\", \"oa\", \"au\", \"oi\", \"oo\", \"ou\"] #Plus the normal vowels\n\t\tcodas = [\"ch\", \"lp\", \"lb\", \"lt\", \"ld\", \"lch\", \"lg\", \"lk\", \"rp\", \"rb\", \"rt\", \"rd\", \"rch\", \"rk\", \"lf\", \"lth\",\n\t\t\t\t \"lsh\", \"rf\", \"rth\", \"rs\", \"rsh\", \"lm\", \"ln\", \"rm\", \"rn\", \"rl\", \"mp\", \"nt\", \"nd\", \"nch\", \"nk\", \"mph\",\n\t\t\t\t \"mth\", \"nth\", \"ngth\", \"ft\", \"sp\", \"st\", \"sk\", \"fth\", \"pt\", \"ct\", \"kt\", \"pth\", \"ghth\", \"tz\", \"dth\",\n\t\t\t\t \"ks\", \"lpt\", \"lfth\", \"ltz\", \"lst\", \"lct\", \"lx\",\"rmth\", \"rpt\", \"rtz\", \"rst\", \"rct\",\"mpt\", \"dth\",\n\t\t\t\t \"nct\", \"nx\", \"xth\", \"xt\"] #Plus normal consonants\n\n\t\tsimpleLetterChance = 65 #percent, whether a single letter is chosen instead of an onset/nucleus/coda\n\t\tbasicLetterChance = 75 #percent, whether a simple consonant/vowel is chosen over a more rare one\n\n\t\t#Prevent unnecessary and ugly code repetition\n\n\t\t#Start the word\n\t\trepeats = 1\n\t\tif parameters and len(parameters) > 0:\n\t\t\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\n\n\t\twords = []\n\t\tfor i in xrange(0, repeats):\n\t\t\tsyllableCount = 2\n\t\t\tif random.randint(1, 100) <= 50:\n\t\t\t\tsyllableCount -= 1\n\t\t\tif random.randint(1, 100) <= 35:\n\t\t\t\tsyllableCount += 1\n\n\t\t\tword = u\"\"\n\t\t\tfor j in range(0, syllableCount):\n\t\t\t\t#In most cases, add an onset\n\t\t\t\tif random.randint(1, 100) <= 75:\n\t\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"consonant\", basicLetterChance)\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(onsets)\n\n\t\t\t\t#Nucleus!\n\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"vowel\", basicLetterChance)\n\t\t\t\telse:\n\t\t\t\t\tword += random.choice(nuclei)\n\n\t\t\t\t#Add a coda in most cases (Always add it if this is the last syllable of the word and it'd be too short otherwise)\n\t\t\t\tif (j == syllableCount - 1 and len(word) < 3) or random.randint(1, 100) <= 75:\n\t\t\t\t\tif random.randint(1, 100) <= simpleLetterChance:\n\t\t\t\t\t\tword += self.getBasicOrSpecialLetter(\"consonant\", basicLetterChance)\n\t\t\t\t\telse:\n\t\t\t\t\t\tword += random.choice(codas)\n\n\t\t\tword = word[0].upper() + word[1:]\n\t\t\twords.append(word)\n\n\t\treturn u\", \".join(words)","def get_wiki_synonyms_mapping() -> Dict[str, str]:\n with open(Config.Path.synonym_mapping, \"r\") as f:\n return json.load(f)","def get_synsets(words):\n synsets = {}\n for word in words:\n for syn in wn.synsets(word):\n synsets[syn.name] = tuple([lemma.name for lemma in syn.lemmas])\n return synsets","def testOneWord(self):\n\n\t\t\t\tspinner.Synonym.objects.add('directory', 'catalog', 10)\n\t\t\t\tspinner.Synonym.objects.add('list', 'directory', 20)\n\t\t\t\tspinner.Synonym.objects.add('directory', 'guide', 10)\n\n\t\t\t\tsynonyms = spinner.Synonym.objects.get_synonyms(['directory'])\n\t\t\t\tassert len(synonyms) < 3, synonyms","def get_synsets_rt(word: str) -> List:\n return rt.categories(word)","def read_syn_data():\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\n folder = pjoin(dipy_home, 'syn_test')\n t1_name = pjoin(folder, 't1.nii.gz')\n b0_name = pjoin(folder, 'b0.nii.gz')\n\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\n\n check_md5(t1_name, md5_dict['t1'])\n check_md5(b0_name, md5_dict['b0'])\n\n t1 = nib.load(t1_name)\n b0 = nib.load(b0_name)\n return t1, b0","def meronym(self, sense=0):\n s = self._synset(self.text, sense=sense)\n\n if not s:\n return []\n\n return s.member_meronyms()","def onto(disgenet, edam):\n disgenet = disgenet.replace(' ', '+').replace(\"'\", \"%27\")\n edam = edam.replace(' ', '+').replace(\"'\", \"%27\")\n disid = subprocess.Popen(\n [\"curl -s -k http://127.0.0.1:3030/ds/query -X POST --data \" +\n \"'query=PREFIX+rdf%3A+%3Chttp%3A%2F%2Fwww.w3.org%2F1999%2F02%2F22-rdf-syntax-ns%23%3E%0A\" +\n \"PREFIX+dcterms%3A+%3Chttp%3A%2F%2Fpurl.org%2Fdc%2Fterms%2F%3E%0A\" +\n \"PREFIX+ncit%3A+%3Chttp%3A%2F%2Fncicb.nci.nih.gov%2Fxml%2Fowl%2FEVS%2FThesaurus.owl%23%3E%0A\" +\n \"SELECT+DISTINCT+%0A%09%3Fdisease+%0AFROM+%3Chttp%3A%2F%2Frdf.disgenet.org%3E+%0AWHERE+%7B%0A++\" +\n \"SERVICE+%3Chttp%3A%2F%2Frdf.disgenet.org%2Fsparql%2F%3E+%7B%0A++++\" +\n \"%3Fdisease+rdf%3Atype+ncit%3AC7057+%3B%0A++++%09dcterms%3Atitle+%22\" + disgenet +\n \"%22%40en+.%0A%7D%0A%7D' -H 'Accept: application/sparql-results+json,*/*;q=0.9'\"],\n stdout=subprocess.PIPE, shell=True).communicate()[0]\n edam_id = subprocess.Popen([\"curl -s 'http://www.ebi.ac.uk/ols/api/search?q=\" + edam + \"&ontology=edam' 'Accept: application/json'\"],\n stdout=subprocess.PIPE, shell=True).communicate()[0]\n try:\n jdisease = json.loads(disid)\n umllist = []\n umls = jdisease['results']['bindings'][0]['disease']['value']\n except (IndexError, ValueError):\n umls = \"No disgenet record\"\n try:\n jedam = json.loads(edam_id)\n eid = jedam['response']['docs'][0]['iri']\n except (IndexError, ValueError):\n eid = \"No EDAM record\"\n return umls, eid","def create_syn(dataframe, col):\n\n hypernym_e = {}\n hyper = []\n for i, val in enumerate(dataframe[col]):\n if wn.synsets(val):\n syn = wn.synsets(val)[0]\n s = syn.hypernyms()\n if s:\n for val in s:\n hyper.append(str(val)[8:-3].split('.')[0])\n\n hypernym_e[i] = ', '.join(v for v in hyper)\n hyper = []\n else:\n hypernym_e[i] = 'None'\n else:\n hypernym_e[i] = 'None'\n\n colname = col + '_syn'\n\n hypernym_e_dataframe = create_dataframe(hypernym_e, [colname])\n dataframe[colname] = hypernym_e_dataframe[colname]\n\n return dataframe","def get_acid_name(seq):\n term_list = []\n for i in __kmers(seq,k=3):\n res = __get_key(i,full_amino_acid_name)\n term_list.append(res)\n return ''.join(term_list)","def match_taxon(name):\n taxid = None\n scientific_name = None\n automatic_replacement = False\n iname = name.strip().lower().replace(' ', ' ')\n\n if name:\n # 1. 'name' matches the scientific name of a virus:\n if name in scientific_names:\n taxid = scientific_names[name]\n scientific_name = name\n # 2. 'name' is a close case-insensitive match for a virus:\n elif iname in lowercase_names:\n taxid = lowercase_names[iname]\n scientific_name = taxid_names[taxid]\n automatic_replacement = True\n # 3. 'name' is the exact synonym of some taxon\n elif name in synonyms:\n taxid = synonyms[name]\n scientific_name = taxid_names[taxid]\n # 4. 'name' is a substring of exactly one scientific name:\n else:\n matches = []\n for scientific_name in scientific_names.keys():\n if name in scientific_name:\n matches.append(scientific_name)\n if len(matches) > 1:\n break\n if len(matches) == 1:\n scientific_name = matches[0]\n taxid = scientific_names[scientific_name]\n\n return (name, taxid, scientific_name, automatic_replacement)","def find_related_concepts(text):\n #\n # Find wikipedia terms in text\n # Spot terms in text\n text = text.encode('ascii', 'replace')\n response = TagMeService.check_spotting(text)\n\n results = return_wikipedia_term(response)\n\n #\n # Lookup terms in taxonomy and fetch relatedConcepts (keywords)\n # return related terms if they are found in the taxonomy\n\n return lookup_in_taxonomy(results)","def __synonym_replacement(self, tokenized_sentence: list) -> str:\n sentence_length = len(tokenized_sentence)\n # Initialize the return string\n new_sentence = \"\"\n # Some variables to keep track of changes and attempted changes\n has_changed = False\n attempts = 0\n # Keep trying to make a change until either:\n # 1) You've made a change, OR\n # 2) You've tried to make a change for half the words in the sentence with no success\n while has_changed is not True and attempts <= sentence_length/2:\n # Grab a random word from the tokenized sentence\n index_to_change = random.randint(0, sentence_length-1)\n pair_to_change = tokenized_sentence[index_to_change]\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_change)\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \n if len(list_of_syns) < 1: \n # Failed synonym swap, so bump up the attempts tracker by one\n attempts += 1\n continue\n # Else, the word does have synonyms we can swap the word for\n else:\n # Randomly pick a word from the synonym list\n random_pick = random.randint(0, len(list_of_syns)-1)\n new_word = list_of_syns[random_pick]\n new_word_pair = (new_word, \"NA\") # \"NA\" is a dummy POS tag\n # Now update the tokenized sentence with the new word\n tokenized_sentence[index_to_change] = new_word_pair\n # Pull the sentence back together\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\n # Now let's clean up our brand new sentence really quickly\n new_sentence = nltk_methods.clean_sentence(new_sentence)\n # BUT WAIT, what if this is a duplicate? We don't want that!\n if new_sentence in self.return_augmented_sentences():\n # Bump up the attempts and skip this sentence\n attempts += 1\n continue\n # Update the flags\n has_changed = True\n return new_sentence","def generate_wordnet_candidates(self, word):\n candidates = set()\n if self.check_if_replacable(word):\n for synset in wordnet.synsets(word):\n for lemma in synset.lemmas():\n converted = convert(lemma.name().lower(), word)\n if converted != word and converted != None:\n try:\n w1 = wordnet.synsets(word)[0]\n w2 = wordnet.synsets(converted)[0]\n similarity = w1.wup_similarity(w2)\n if isinstance(similarity,float) and w1.wup_similarity(w2) >0.6 :\n candidates.add(converted)\n except:\n pass\n # print(\"candidate\",word,candidates)\n return candidates","def get_abbreviation_matches(dddb, org_concepts):\n try:\n for org in org_concepts:\n acronym = Acronym(org['canon_name'])\n\n for abbrev in acronym.get_possible_acronyms():\n abbrev = \"'\" + abbrev + \" %'\"\n\n dddb.execute(SELECT_ORG_ABBREVIATIONS.format(abbrev))\n\n abbrev_orgs = dddb.fetchall()\n\n for row in abbrev_orgs:\n dup_org = {'oid': int(row[0]), 'name': row[1], 'is_abbreviation': 1, 'can_delete': 0}\n dup_org = identify_subchapter_abbreviation(abbrev, dup_org)\n org['duplicates'].append(dup_org)\n\n return org_concepts\n\n except MySQLdb.Error:\n print(traceback.format_exc())","def GetSynonymTerm(con, cur, synonym):\n err, termid = GetSynonymTermId(con, cur, synonym)\n if err:\n debug(2, 'ontology term %s is not a synonym' % synonym)\n return err, str(termid)\n err, term = dbidval.GetDescriptionFromId(con, cur, 'ontologyTable', termid)\n if err:\n debug(3, 'ontology term not found for termid %d (synonym %s)' % (termid, synonym))\n return err, term\n return '', term","def _generator():\n filename_1 = 'gene.txt'\n filename_2 = 'geneSynonym.txt'\n gene_set_1 = gene_names(filename_1)\n gene_syn = gene_names(filename_2, complete=False)\n genes = gene_set_1 | gene_syn\n return genes","def c_synonym_cd(self) -> str:\n return \"N\"","def main():\n\n # Remove the files if existing before creating new ones\n OUT_VOCAB = \"results/vocabs.txt\"\n OUT_SYN = \"results/syn.txt\"\n OUT_EXCP = \"results/exception.txt\"\n for f in [OUT_SYN, OUT_VOCAB, OUT_EXCP]:\n if os.path.isfile(f):\n os.remove(f)\n\n \"\"\"\n Now we do the recursion:\n Step 1: Find the children link;\n Step 2: Add to the url_list;\n Step: Move to next entry of the url_list and Go to Step 1;\n \"\"\"\n with open(DATA, \"r\") as fin:\n url_list = fin.readlines()\n\n # Write down the urls as tuples, 0 as the first level\n url_list = [((PREFIX_URL + subURL).strip(), 0) for subURL in url_list]\n\n with open(OUT_VOCAB, \"w\") as vocab_file, \\\n open(OUT_SYN, \"w\") as syn_file, \\\n open(OUT_EXCP, \"w\") as exp_file:\n cur_index = 0\n while cur_index < len(url_list):\n # Current url of the term, current level number (hierarchy) of the term\n cur_url, cur_hrc = url_list[cur_index]\n try:\n # Get the current sub-url\n time.sleep(0.1)\n r = requests.get(cur_url + \"?\" + API_KEY)\n source_dict = json.loads(r.text)\n\n # Getting the vocabulary and the synonym from this page.\n vocab, syn = parse_words(source_dict=source_dict)\n if cur_hrc + 1 < int(level):\n # Fetch all the children's name and url\n children_urls = fetch_children_url(source_dict=source_dict, hrc=cur_hrc + 1)\n # print children_urls\n url_list = url_list + children_urls # Concatenate the lists\n\n if vocab is not None:\n syn_file.write(json.dumps({vocab: syn}) + \"\\n\")\n vocab_file.write(vocab + \"\\n\")\n\n if cur_index % 100 == 0:\n print \"\\tNow at index # {}, {} in total.\".format(str(cur_index), str(len(url_list)))\n except UnicodeEncodeError as unicode_err:\n exp_file.write(str(unicode_err))\n except KeyError as key_err:\n exp_file.write(str(key_err))\n except:\n pass\n cur_index += 1","def bioinfo():\n\n pass","def sample_sonnet_syl_and_rhyme(hmm, obs_map, rhyme_dict, n_syl = 10):\n sonnetLines = []\n r_sonnetLines = []\n sonnet = ''\n sonnet_length = 14\n count = 0\n syl_counts = syllable_dict()\n # print(syl_counts)\n \n while count < sonnet_length:\n # Pick a random word from the rhyming dictionary that the line has to start with. \n \n start_word = np.random.choice(list(rhyme_dict.keys()))\n rhyme_word = np.random.choice(rhyme_dict[start_word])\n line1 = sample_sentence_syl(hmm, obs_map, rhyme_dict, start_word, n_syl)\n line2 = sample_sentence_syl(hmm, obs_map, rhyme_dict, rhyme_word, n_syl)\n (worked1, nline1) = make_line(line1, n_syl, syl_counts)\n (worked2, nline2) = make_line(line2, n_syl, syl_counts)\n if worked1 and worked2:\n sonnetLines.append(nline1)\n sonnetLines.append(nline2)\n count += 2\n\n # Now flip the order of each line.\n for line in sonnetLines:\n line_reversed = ' '.join(reversed(line.split(' '))).capitalize()\n r_sonnetLines.append(line_reversed + '\\n')\n\n # Rearrange 7 couplets into a sonnet.\n for stanza in range(0, 3):\n idx = [0, 1, 2, 3]\n for i in range(len(idx)):\n idx[i] += stanza * 4\n sonnet += r_sonnetLines[idx[0]] + r_sonnetLines[idx[2]] + r_sonnetLines[idx[1]] + r_sonnetLines[idx[3]]\n\n for line_num in range(12, 14):\n sonnet += r_sonnetLines[line_num]\n\n return sonnet","def find_discordant_snps(\n self, individual1, individual2, individual3=None, save_output=False\n ):\n self._remap_snps_to_GRCh37([individual1, individual2, individual3])\n\n df = individual1.snps\n\n # remove nulls for reference individual\n df = df.loc[df[\"genotype\"].notnull()]\n\n # add SNPs shared with `individual2`\n df = df.join(individual2.snps[\"genotype\"], rsuffix=\"2\")\n\n genotype1 = \"genotype_\" + individual1.get_var_name()\n genotype2 = \"genotype_\" + individual2.get_var_name()\n\n if individual3 is None:\n df = df.rename(columns={\"genotype\": genotype1, \"genotype2\": genotype2})\n\n # find discordant SNPs between reference and comparison individuals\n df = df.loc[\n df[genotype2].notnull()\n & (\n (df[genotype1].str.len() == 1)\n & (df[genotype2].str.len() == 1)\n & (df[genotype1] != df[genotype2])\n )\n | (\n (df[genotype1].str.len() == 2)\n & (df[genotype2].str.len() == 2)\n & (df[genotype1].str[0] != df[genotype2].str[0])\n & (df[genotype1].str[0] != df[genotype2].str[1])\n & (df[genotype1].str[1] != df[genotype2].str[0])\n & (df[genotype1].str[1] != df[genotype2].str[1])\n )\n ]\n if save_output:\n save_df_as_csv(\n df,\n self._output_dir,\n \"discordant_snps_{}_{}_GRCh37.csv\".format(\n individual1.get_var_name(), individual2.get_var_name()\n ),\n comment=self._get_csv_header(),\n prepend_info=False,\n )\n else:\n # add SNPs shared with `individual3`\n df = df.join(individual3.snps[\"genotype\"], rsuffix=\"3\")\n\n genotype3 = \"genotype_\" + individual3.get_var_name()\n\n df = df.rename(\n columns={\n \"genotype\": genotype1,\n \"genotype2\": genotype2,\n \"genotype3\": genotype3,\n }\n )\n\n # find discordant SNPs between child and two parents\n df = df.loc[\n (\n df[genotype2].notnull()\n & (\n (df[genotype1].str.len() == 1)\n & (df[genotype2].str.len() == 1)\n & (df[genotype1] != df[genotype2])\n )\n | (\n (df[genotype1].str.len() == 2)\n & (df[genotype2].str.len() == 2)\n & (df[genotype1].str[0] != df[genotype2].str[0])\n & (df[genotype1].str[0] != df[genotype2].str[1])\n & (df[genotype1].str[1] != df[genotype2].str[0])\n & (df[genotype1].str[1] != df[genotype2].str[1])\n )\n )\n | (\n df[genotype3].notnull()\n & (\n (df[genotype1].str.len() == 1)\n & (df[genotype3].str.len() == 1)\n & (df[genotype1] != df[genotype3])\n )\n | (\n (df[genotype1].str.len() == 2)\n & (df[genotype3].str.len() == 2)\n & (df[genotype1].str[0] != df[genotype3].str[0])\n & (df[genotype1].str[0] != df[genotype3].str[1])\n & (df[genotype1].str[1] != df[genotype3].str[0])\n & (df[genotype1].str[1] != df[genotype3].str[1])\n )\n )\n | (\n df[genotype2].notnull()\n & df[genotype3].notnull()\n & (df[genotype2].str.len() == 2)\n & (df[genotype2].str[0] == df[genotype2].str[1])\n & (df[genotype2] == df[genotype3])\n & (df[genotype1] != df[genotype2])\n )\n ]\n\n if save_output:\n save_df_as_csv(\n df,\n self._output_dir,\n \"discordant_snps_{}_{}_{}_GRCh37.csv\".format(\n individual1.get_var_name(),\n individual2.get_var_name(),\n individual3.get_var_name(),\n ),\n comment=self._get_csv_header(),\n prepend_info=False,\n )\n\n return df","def query_synapses(self, pre_name, post_name):\n return self.sql_query(\n \"\"\" select from Synapse where uname = \"{}--{}\" \"\"\".format(pre_name, post_name))","def antonym(self, sense=0):\n s = self._synset(self.text, sense=sense)\n\n if not s:\n return []\n\n lemmas = s.lemmas()\n\n result = list()\n\n for lemma in lemmas:\n if lemma.antonyms():\n result.append(lemma.antonyms()[0].name())\n\n return result if result else []","def queryYM( self, geneName, level ):\n result = [] \n \n # Get a new query on the table\n query = service.new_query(\"Gene\")\n query.add_constraint(\"interactions.participant2\", \"Gene\") \n \n query.add_view( \"primaryIdentifier\", \"symbol\", \"secondaryIdentifier\", \"sgdAlias\", \"name\",\n \"organism.shortName\", \"interactions.details.annotationType\",\n \"interactions.details.phenotype\", \"interactions.details.role1\",\n \"interactions.details.experimentType\", \"interactions.participant2.symbol\",\n \"interactions.participant2.secondaryIdentifier\",\n \"interactions.details.experiment.name\",\n \"interactions.details.relationshipType\" )\n \n query.add_constraint(\"organism.shortName\", \"=\", \"S. cerevisiae\", code = \"B\")\n query.add_constraint(\"Gene\", \"LOOKUP\", geneName, code = \"A\")\n \n for row in query.rows():\n data = level, row[\"primaryIdentifier\"], row[\"symbol\"], row[\"secondaryIdentifier\"], row[\"sgdAlias\"], \\\n row[\"name\"], row[\"organism.shortName\"], row[\"interactions.details.annotationType\"], \\\n row[\"interactions.details.phenotype\"], row[\"interactions.details.role1\"], \\\n row[\"interactions.details.experimentType\"], row[\"interactions.participant2.symbol\"], \\\n row[\"interactions.participant2.secondaryIdentifier\"], \\\n row[\"interactions.details.experiment.name\"], row[\"interactions.details.relationshipType\"]\n item = list(data)\n result.append(item) \n \n return result","def get_synopsis(file_data):\n for individual in file_data:\n if 'synopsis' in individual:\n synopsis = individual.split('\"')\n return synopsis[1]","def try1():\n path = '/Users/mayankkejriwal/datasets/eswc2017/disasters/'\n model = Word2Vec.load_word2vec_format(path+'GoogleNews-vectors-negative300.bin', binary=True)\n model.init_sims(replace=True)\n keys = ['charlotte', 'Charlotte', 'yorktown', 'LA']\n for key in keys:\n try:\n # print model.most_similar(positive=['woman', 'king'], negative=['man'])\n j = model[key]\n print 'found...',\n print key\n except KeyError:\n print 'not found...',\n print key\n continue\n print model.similarity('charlotte', 'carolina')\n print model.similarity('LA', 'California')","def test_genbank_to_genome_taxonomy(self):\n result = self.gfu.genbank_to_genome(self.ctx, {\n 'workspace_name': self.ws_name,\n 'generate_ids_if_needed': 'true', # why is this a string\n 'taxon_id': '3702',\n 'file': {\n 'path': f\"{_DATA_PATH}/wigglesworthia/genome.gb\"\n },\n 'genome_name': str(uuid4()),\n })\n ('result', result)\n ref = result[0]['genome_ref']\n self.assertTrue(ref, 'Genome ref exists')\n info = result[0]['genome_info']\n typ = info[2]\n self.assertTrue(typ.startswith('KBaseGenomes.Genome'))\n info_details = info[-1]\n self.assertEqual(info_details['Taxonomy'], (\n \"cellular organisms;Eukaryota;Viridiplantae;\"\n \"Streptophyta;Streptophytina;Embryophyta;Tracheophyta;\"\n \"Euphyllophyta;Spermatophyta;Magnoliopsida;Mesangiospermae;\"\n \"eudicotyledons;Gunneridae;Pentapetalae;rosids;malvids;\"\n \"Brassicales;Brassicaceae;Camelineae;Arabidopsis\"\n ))\n self.assertEqual(info_details['Size'], '697724')\n self.assertEqual(info_details['Source'], 'Genbank')\n self.assertEqual(info_details['Name'], 'Wigglesworthia glossinidia endosymbiont of Glossina brevipalpis')\n self.assertEqual(info_details['GC content'], '0.22479')\n self.assertEqual(info_details['Genetic code'], '11')\n self.assertEqual(info_details['Number of Genome Level Warnings'], '1')\n self.assertEqual(info_details['Source ID'], 'BA000021')\n self.assertEqual(info_details['Number of Protein Encoding Genes'], '20')\n self.assertEqual(info_details['Domain'], 'Eukaryota')\n self.assertTrue(info_details['Assembly Object'])\n self.assertEqual(info_details['Number contigs'], '1')\n self.assertEqual(info_details['Number of CDS'], '20')\n self.assertTrue(info_details['MD5'])","def parse_obo(obo,\n output_file=None,\n id2name_file=None,\n id2namespace_file=None,\n alt_id_file=None):\n\n ## Keywords that screw up parsing:\n # import, is_anonymous, intersection_of, union_of\n\n ## Relations\n # 'is_a:'\n # 'relationship: has_part' # Not in filtered GO\n # 'relationship: occurs_in' # Not in filtered GO\n # 'relationship: part_of' \n # 'relationship: positively_regulates' \n # 'relationship: negatively_regulates'\n # 'relationship: regulates'\n # 'relationship: results_in' # Not in filtered GO\n\n stanza, edges = [], []\n id2name = dict()\n id2namespace = dict()\n alt_id = dict()\n in_term_stanza = False\n default_namespace_exists = False\n for line in io.open(obo).read().splitlines():\n\n line = line.split('!')[0].strip() # Remove comments\n\n if len(line)>0 and line[0]=='[' and line[-1]==']':\n # Add last stanza if it was a term stanza. Include namespace.\n if in_term_stanza:\n edges.extend(x+(namespace, ) for x in stanza)\n\n # Start new term stanza\n stanza = []\n \n # Set the default namespace, if it exists\n if default_namespace_exists:\n namespace = default_namespace\n \n # In a term stanzo or not\n in_term_stanza = line =='[Term]'\n\n name = None\n \n #if 'alt_id:' in line: assert False\n\n if 'id:' == line[:3]:\n curr_term = line.split('id:')[1].strip()\n elif 'alt_id:' in line:\n alt_term = line.split('alt_id:')[1].strip()\n if curr_term in alt_id: alt_id[curr_term].append(alt_term)\n else: alt_id[curr_term] = [alt_term]\n id2name[alt_term] = name\n elif 'name:' in line:\n name = line.split('name:')[1].strip()\n #assert not curr_term in id2name\n id2name[curr_term] = name\n elif 'is_a:' in line:\n parent = line.split('is_a:')[1].strip()\n stanza.append((parent, curr_term, 'is_a'))\n elif 'relationship:' in line:\n line = line.split('relationship:')[1].strip().split()\n if len(line)!=2: print(line)\n assert len(line)==2\n relation, parent = line\n stanza.append((parent, curr_term, relation))\n elif 'namespace:' == line[:10]:\n namespace = line.split('namespace:')[1].strip()\n assert not curr_term in id2namespace\n id2namespace[curr_term] = namespace\n elif 'default-namespace:' == line[:18]:\n namespace = line.split('default-namespace:')[1].strip()\n default_namespace_exists = True\n default_namespace = namespace\n\n pd.DataFrame(edges).to_csv(output_file, header=False, index=False, sep='\\t')\n pd.Series(id2name).to_csv(id2name_file, sep='\\t')\n pd.Series(id2namespace).to_csv(id2namespace_file, sep='\\t')\n pd.Series(dict([(a, c) for a, b in alt_id.items() for c in b])).to_csv(alt_id_file, sep='\\t')","def test_create_gene_ontology(self):\n\n # Here are mappings for just a few yeast genes.\n\n mapping = {}\n mapping['STE7'] = ['GO:0000187']\n mapping['PBS2'] = ['GO:0000187']\n mapping['NOP8'] = [\n 'GO:0003676', 'GO:0003723', 'GO:0042254', 'GO:0005634', 'GO:0005730'\n ]\n\n # Build the ontology, then see if it looks correct.\n\n root = dc.models.tensorgraph.models.ontology.create_gene_ontology(\n mapping, min_node_features=1)\n assert len(root.feature_ids) == 0\n\n def find_features(node, features):\n features.update(node.feature_ids)\n for child in node.children:\n find_features(child, features)\n\n all_features = set()\n find_features(root, all_features)\n assert len(all_features) == 3\n for key in mapping:\n assert key in all_features","def TrinityAnnotation(Trinityfa,fileBlast6,GIfa,output):\n from Bio import SeqIO\n myTrinity = list(SeqIO.parse(Trinityfa,\"fasta\"))\n mygislist = list(SeqIO.parse(GIfa,\"fasta\"))\n mygis = {}\n for giseq in mygislist:\n mygis[giseq.id.split(\"|\")[1]] = giseq\n mylist = open(fileBlast6,\"r\").readlines()\n fout = open(output,\"w\")\n sqdic = {}\n queryset = set()\n for ele in mylist:\n subject = ele.split()[1] +\"|\" + ele.split()[3]+\" Identity: \" + ele.split()[2]\n query = ele.split()[0]\n if query not in queryset:\n sqdic[query]=subject\n queryset.add(query)\n for ele in myTrinity:\n if ele.id not in queryset:\n fout.write(ele.id +\"\\t\"+\"NA\\n\")\n else:\n fout.write(ele.id +\"\\t\"+mygis[sqdic[ele.id].split(\"|\")[1]].description+\" QL:\"+\\\n str(len(ele.seq)) +\" SL: \"+str(len(mygis[sqdic[ele.id].split(\"|\")[1]].seq)) +\\\n \" ML: \"+ sqdic[ele.id].split(\"|\")[-1] +\"\\n\")\n fout.close()","def print_common_hub_words(rem_stop_words):\n results = {'_removing stop-words':rem_stop_words}\n\n print '------ CLASSIFICATION EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/tasa/TASA900_dependencies'\n texts, labels = data.read_files(descriptions_path)\n\n print '> Creating representations..'\n fd = nltk.probability.FreqDist()\n for i, text in enumerate(texts):\n if i%100==0: print ' ',str(i)+'/'+str(len(texts))\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\n hubs = graph.get_hubs(g, 10)\n for h in hubs:\n fd.inc(h[0])\n g = None # just to make sure..\n\n results['tasa'] = fd.keys()\n\n print '------ RETRIEVAL EVALUATION --------'\n print '> Reading cases..'\n descriptions_path = '../data/air/problem_descriptions_dependencies'\n description_texts, labels = data.read_files(descriptions_path)\n\n print '> Creating representations..'\n fd = nltk.probability.FreqDist()\n for i, text in enumerate(description_texts):\n if i%100==0: print ' ',str(i)+'/'+str(len(description_texts))\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\n hubs = graph.get_hubs(g, 10)\n for h in hubs:\n fd.inc(h[0])\n g = None # just to make sure..\n\n results['air'] = fd.keys()\n\n if rem_stop_words:\n modifier = 'without'\n else:\n modifier = 'with'\n data.pickle_to_file(results, 'output/dependencies/common_hubs_'+modifier+'stop_words')\n\n pp.pprint(results)\n return results","def generate_similar_sentences(sentence,w2v,percentage_to_replace=1,max_syn=10,num_outputs=50):\n\n list_of_sentences = []\n\n words = pairwise_tokenize(sentence,w2v,remove_stopwords=False) #This has combined any compound words found in word2vec\n\n #if word contains underscore don't sub in synonyms\n dont_sub_idx = []\n compound_word_idx = []\n deleted_idx = []\n for idx,word in enumerate(words):\n if \"_\" in word or word in stopwords.words('english'):\n dont_sub_idx.append(idx)\n if \"_\" in word:\n compound_word_idx.append(idx)\n deleted_idx.append(idx+1)\n if not word:\n dont_sub_idx.append(idx)\n\n pattern = re.compile('[\\W_]+') \n sentence = pattern.sub(\" \",sentence).lower().strip()\n tagged = pos_tag(sentence.split(\" \")) #Pos_tag needs to use the original sentence to tag parts of speech, we will now delete indices that correspond to words that no longer exist b/c of compound\n \n for idx in reversed(compound_word_idx):\n tagged.pop(idx+1)\n \n for tag in tagged:\n if tag[1] == 'NNP':\n dont_sub_idx.append(idx)\n \n for i in xrange(num_outputs):\n new_words = words\n mask = np.random.random_sample(len(words))\n for j in xrange(len(words)):\n if mask[j] < .5 and j not in dont_sub_idx:\n pos = wordnet_pos_code(tagged[j][1])\n synonyms = get_synonyms(words[j],w2v,pos,max=max_syn)\n if len(synonyms) != 0:\n new_words[j] = synonyms[np.random.randint(0,min(max_syn,len(synonyms)))]\n list_of_sentences.append(\" \".join(new_words))\n\n list_of_sentences = set(list_of_sentences)\n return list(list_of_sentences)","def parse_words(source_dict):\n name, syn = None, []\n if 'synonym' in source_dict:\n syn = source_dict['synonym']\n if 'prefLabel' in source_dict:\n name = source_dict['prefLabel']\n return name, syn","def try2():\n path = '/Users/mayankkejriwal/datasets/heiko-vectors/'\n model = Word2Vec.load(path+'DB2Vec_sg_500_5_5_15_4_500')\n\n print model['http://purl.org/dc/terms/subject']\n print model['dbo:birthPlace']\n print model['http://dbpedia.org/ontology/birthPlace']\n print len(model)\n print 'success'","def __insert_random_synonym(self, tokenized_sentence: list) -> str:\n sentence_length = len(tokenized_sentence)\n # Initialize the return string\n new_sentence = \"\"\n # Some variables to keep track of changes and attempted changes\n has_changed = False\n attempts = 0\n # Keep trying to make a change until either:\n # 1) You've made a change, OR\n # 2) You've tried to make a change for half the words in the sentence with no success\n while has_changed is not True and attempts <= sentence_length/2:\n # Grab a random word from the tokenized sentence\n index_to_get_word_from = random.randint(0, sentence_length-1)\n pair_to_get_word_from = tokenized_sentence[index_to_get_word_from]\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_get_word_from)\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \n if len(list_of_syns) < 1: \n # Failed synonym swap, so bump up the attempts tracker by one\n attempts += 1\n continue\n # Else, the word does have synonyms we can swap the word for\n else:\n # Randomly pick a word from the synonym list\n random_pick = random.randint(0, len(list_of_syns)-1)\n new_word = list_of_syns[random_pick]\n new_word_pair = (new_word, \"NA\") # \"NA\" is a dummy POS tag\n # Now randomly find a spot to put the new word\n index_to_place_new_word = random.randint(0, sentence_length-1)\n # Now update the tokenized sentence with the new word\n tokenized_sentence.insert(index_to_place_new_word, new_word_pair)\n sentence_length += 1\n # Pull the sentence back together\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\n # Now let's clean up our brand new sentence really quickly\n new_sentence = nltk_methods.clean_sentence(new_sentence)\n # BUT WAIT, what if this is a duplicate? We don't want that!\n if new_sentence in self.return_augmented_sentences():\n # Bump up the attempts and skip this sentence\n attempts += 1\n continue\n # Update the flags\n has_changed = True\n return new_sentence","def get_concepts_for_text(f2t, adir, ptext2ptmk, ptmk2sk):\n print \"Getting concepts for texts (returns pointmention pks for a text)\"\n cpco2ptmk = {} # simple hash\n vbco2ptmk = {} # verbose hash\n for idx, fn in enumerate(os.listdir(adir)):\n sfn = fn.replace(\"pointmention_nbr_\", \"\")\n with codecs.open(os.path.join(adir, fn), \"r\", \"utf8\") as ifd:\n jso = js.loads(ifd.read().strip())\n for co in jso[\"concepts\"]:\n txt = f2t[sfn]\n # only value is a set with the pointmention pks\n ptmpks = ptext2ptmk[txt].values()\n assert len(ptmpks) == 1\n assert isinstance(ptmpks[0], set)\n ptmpks = ptmpks[0]\n # smaller hash, all ptmkeys for a concept go in a set\n cpco2ptmk.setdefault(co[\"prefLabel\"].strip(),\n {\"uri\": co[\"uri\"].replace(RPREF, \"\"),\n \"ptmks\": set()})\n cpco2ptmk[co[\"prefLabel\"].strip()][\"ptmks\"].update(ptmpks)\n # verbose hash (with sentence id and score per mention)\n for ptmpk in ptmpks:\n curkey = (co[\"prefLabel\"].strip(),\n co[\"uri\"].replace(RPREF, \"\"))\n curdict = {\"ptmk\": ptmpk, \"spk\": ptmk2sk[ptmpk],\n \"sco\": co[\"score\"] / 100.0}\n vbco2ptmk.setdefault(curkey, [])\n if curdict not in vbco2ptmk[curkey]:\n vbco2ptmk[curkey].append(curdict)\n if idx and not idx % 10000:\n print \"- Done concepts for {} texts, {}\".format(\n idx, time.strftime(\"%H:%M:%S\", time.localtime()))\n return cpco2ptmk, vbco2ptmk"],"string":"[\n \"def nsrSynonyms():\\r\\n # Input file\\r\\n synonymsFile = pd.read_csv(args.indir+\\\"/\\\"+args.infile2, header=2,\\r\\n sep=\\\"\\\\t\\\", encoding=\\\"utf8\\\")\\r\\n\\r\\n # Parse taxonomic names into their elementary components\\r\\n synonyms = synonymsFile.loc[synonymsFile['language'] == 'Scientific']\\r\\n synonymDict = {}\\r\\n for synonym, taxon in zip(synonyms['synonym'], synonyms['taxon']):\\r\\n synonym = taxonParser(synonym)\\r\\n taxon = taxonParser(taxon)\\r\\n if not taxon or synonym is False or taxon is False:\\r\\n pass\\r\\n else:\\r\\n synonymDict[synonym] = taxon\\r\\n\\r\\n # Write dictionary to file\\r\\n with io.open(par_path+\\\"/results/nsr_synonyms.csv\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as outfile:\\r\\n outfile.write(\\\"synonym_name,identification_reference,taxon_name,taxon_author\\\\n\\\")\\r\\n for key, value in synonymDict.items():\\r\\n outfile.write('\\\"%s\\\",\\\"%s\\\",\\\"%s\\\",\\\"%s\\\"' % (' '.join(str(key).split()[:2]), ' '.join(str(key).split()[2:]),\\r\\n ' '.join(str(value).split()[:2]), ' '.join(str(value).split()[2:])))\\r\\n outfile.write(\\\"\\\\n\\\")\\r\\n return [*synonymDict], synonymDict\",\n \"def get_chebi_synonyms(chebi_ent):\\n if hasattr(chebi_ent, 'Synonyms'):\\n return [entry.data for entry in chebi_ent.Synonyms]\\n else:\\n return []\",\n \"def find_synonymous(input_file, work_dir):\\n # create the .ctl file\\n ctl_file = op.join(work_dir, \\\"yn-input.ctl\\\")\\n output_file = op.join(work_dir, \\\"nuc-subs.yn\\\")\\n ctl_h = open(ctl_file, \\\"w\\\")\\n ctl_h.write(\\\"seqfile = %s\\\\noutfile = %s\\\\nverbose = 0\\\\n\\\" %\\n (input_file, output_file))\\n ctl_h.write(\\\"icode = 0\\\\nweighting = 0\\\\ncommonf3x4 = 0\\\\n\\\")\\n ctl_h.close()\\n\\n cl = YnCommandline(ctl_file)\\n print >>sys.stderr, \\\"\\\\tyn00:\\\", cl\\n r, e = cl.run()\\n ds_value_yn = None\\n ds_value_ng = None\\n dn_value_yn = None\\n dn_value_ng = None\\n\\n # Nei-Gojobori\\n output_h = open(output_file)\\n row = output_h.readline()\\n while row:\\n if row.find(\\\"Nei & Gojobori\\\") >=0:\\n for x in xrange(5):\\n row = output_h.next()\\n dn_value_ng, ds_value_ng = row.split('(')[1].split(')')[0].split()\\n break\\n row = output_h.readline()\\n output_h.close()\\n\\n # Yang\\n output_h = open(output_file)\\n for line in output_h:\\n if line.find(\\\"+-\\\") >= 0 and line.find(\\\"dS\\\") == -1:\\n parts = line.split(\\\" +-\\\")\\n ds_value_yn = extract_subs_value(parts[1])\\n dn_value_yn = extract_subs_value(parts[0])\\n\\n if ds_value_yn is None or ds_value_ng is None:\\n h = open(output_file)\\n print >>sys.stderr, \\\"yn00 didn't work: \\\\n%s\\\" % h.read()\\n\\n return ds_value_yn, dn_value_yn, ds_value_ng, dn_value_ng\",\n \"def get_synonyms(word,w2v,pos,max=20):\\n synonyms = []\\n count = 0\\n synsets = wordnet.synsets(word,pos=pos)\\n for synset in synsets:\\n candidate_names = []\\n for lemma in synset.lemma_names():\\n candidate_names.append(lemma)\\n for hypo in synset.hyponyms():\\n candidate_names.append(hypo)\\n for hyper in synset.hypernyms():\\n candidate_names.append(hyper)\\n\\n for lemma in candidate_names:\\n if count >= max:\\n break\\n # print pos,word,lemma\\n try:\\n similarity = w2v.n_similarity([word.lower()],[lemma.lower() ])\\n if similarity > .34 and lemma not in synonyms:\\n synonyms.append(lemma)\\n\\n count += 1\\n except:\\n continue\\n\\n return synonyms\",\n \"def scrapeSynonym(word,key='b08CVJHscZ6rRGfc7MzS',language='en_US', max=5):\\n endpoint = \\\"http://thesaurus.altervista.org/thesaurus/v1\\\"\\n url = endpoint + \\\"?word={}&language={}&key={}&output=json\\\".format(word,language,key)\\n r = requests.request('GET', url, timeout=5.0)\\n if r.status_code == 200:\\n try:\\n syns = r.json()['response'][0]['list']['synonyms'].split('|')\\n except KeyError or TypeError:\\n return None\\n\\n del syns[max:]\\n for i in range(len(syns)):\\n syns[i] = syns[i].split(' ')[0] \\n\\n return {'word' : word,'syns' : syns}\",\n \"def getSynonyms(graph, verbose=False):\\n # create list containing all nodes\\n pages = [node for node in graph.nodes]\\n\\n # loop through all nodes by intervals of 50\\n lastcount = 0\\n for count in range(50, len(pages), 50):\\n # send 50 nodes to getRedirects()\\n getRedirects(pages[lastcount:count])\\n if verbose:\\n print(\\\"DONE \\\" + str(count) + \\\"/\\\" + str(len(pages)))\\n # update lastcount for next cycle\\n lastcount = count\\n\\n # send leftover nodes to getRedirects()\\n getRedirects(pages[lastcount: lastcount + (len(pages) % 50)])\\n\\n if verbose:\\n print(\\\"DONE \\\" + str(len(pages)) + \\\"/\\\" + str(len(pages)))\\n\\n # return completed SYNONYM_DICT\\n return SYNONYM_DICT\",\n \"def synonyms_wiktionary(name, lang=\\\"fr\\\"):\\n import wptools\\n page = wptools.page(name, wiki='{0}.wiktionary.org'.format(\\n lang), lang=lang, silent=True)\\n page.get_parse()\\n text = page.data['wikitext']\\n syn = \\\"==== {{S|synonymes}} ====\\\"\\n if syn not in text:\\n return None\\n text = text.split(syn)[1].split(\\\"====\\\")[0]\\n reg = re.compile(\\\"[[]{2}(.*?)[]]{2}\\\")\\n res = reg.findall(text)\\n return res\",\n \"def information_content_similarity(s1, s2):\\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\\n\\n # Disambiguate words and create list of sysnsets \\n synsets_sentence_1 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_1.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_1.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n synsets_sentence_2 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_2.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_2.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n\\n score, count = 0.0, 0\\n # For each word in the first sentence\\n for synset in synsets_sentence_1:\\n L = []\\n for ss in synsets_sentence_2:\\n try:\\n L.append(synset.lin_similarity(ss, brown_ic))\\n except:\\n continue\\n if L: \\n best_score = max(L)\\n score += best_score\\n count += 1\\n # Average the values\\n if count > 0: score /= count\\n return score\",\n \"def get_synonyms(word):\\n try:\\n query = {'word': word}\\n cursor = database['Words'].find(query)\\n synonym_set = set()\\n if cursor is None:\\n return None\\n for document in cursor:\\n if len(document['synsets']) > 0:\\n for key, synset in document['synsets'].items():\\n synonyms = synset['synonyms'].split(\\\",\\\")\\n for synonym in synonyms:\\n synonym_set.add(synonym.strip())\\n if len(synonym_set) == 0:\\n return None\\n return synonym_set\\n except Exception as e:\\n print(e)\\n return None\",\n \"def get_synonym(name: str) -> str:\\n return s2n.get_name(n2s.get_smiles(name))\",\n \"def get_synonyms(word):\\n syns_sets = wordnet.synsets(word)\\n if syns_sets:\\n # if there's synonyms, take the first set\\n desired = syns_sets[0].lemma_names()\\n desired = [the_name.replace(\\\"_\\\", \\\" \\\") for the_name in desired]\\n return desired\\n\\n else:\\n return False\",\n \"def get_synonyms(word):\\n synsets = [];\\n syns = wn.synsets(word)\\n for ss in syns:\\n lemmas = []\\n for l in ss.lemmas():\\n lemma = { \\\"name\\\": l.name(), \\\"related_forms\\\": [] }\\n for x in l.derivationally_related_forms():\\n lemma['related_forms'].append(x.name())\\n lemmas.append(lemma)\\n synsets.append({\\n \\\"lemmas\\\": lemmas,\\n \\\"d\\\": ss.definition(),\\n \\\"pos\\\": ss.pos(),\\n \\\"id\\\": ss.name()\\n })\\n return synsets\",\n \"def synonymic_list_generator(content):\\n\\tpass\",\n \"def _flow_terms(flow):\\n return flow.synonyms\",\n \"def lookup_in_taxonomy(results):\\n from unidecode import unidecode\\n\\n base_url = \\\"http://taxonomy.projectchronos.eu/space/dbpediadocs/{}\\\"\\n labels = []\\n resource = None\\n for res in results:\\n res = unidecode(res)\\n try:\\n # print base_url.format(res)\\n resource = retrieve_json(base_url.format(res))\\n except Exception as e:\\n print Exception('Cannot fetch taxonomy: ' + res.encode('ascii', 'replace') + ' ' + str(e))\\n\\n if resource and 'relatedConcepts' in resource.keys():\\n for c in resource['relatedConcepts']:\\n if c:\\n label = c[c.rfind('/') + 1:].replace('+', ' ')\\n # print 'Found! ' + label\\n labels.append(str(label))\\n return set(labels)\",\n \"def test_synonym(self): \\n pass\",\n \"def synsets_similarity(s1, s2):\\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\\n\\n # Disambiguate words and create list of sysnsets \\n synsets_sentence_1 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\\n if lemma in stop_words:\\n continue\\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_1.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_1.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n\\n synsets_sentence_2 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\\n if lemma in stop_words:\\n continue\\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_2.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_2.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n\\n # Compute similarity\\n if len(synsets_sentence_1) != 0 and len(synsets_sentence_2) != 0:\\n similarity = 1 - jaccard_distance(set(synsets_sentence_1), set(synsets_sentence_2))\\n return similarity\\n else:\\n return 0\",\n \"def get_hyponyms(word):\\n syn = wn.synsets(word)\\n hnyms = []\\n for h in syn[0].hyponyms():\\n print h\\n hnyms.append({\\n \\\"lemmas\\\": h.lemma_names(),\\n \\\"d\\\": h.definition(),\\n \\\"pos\\\": h.pos(),\\n \\\"id\\\": h.name()\\n })\\n return hnyms\",\n \"def test_analytics_synonyms(self):\\n class Query:\\n \\\"\\\"\\\" A class to execute analytics queries \\\"\\\"\\\"\\n\\n def __init__(self, server, username, password):\\n self.restconn = RestConnection(server)\\n\\n def execute(self, query):\\n return self.restconn.execute_statement_on_cbas(query, None)\\n\\n def get_synonyms(self):\\n synonyms = set()\\n\\n for result in json.loads(self.execute(\\\"select * from Metadata.`Synonym`\\\"))['results']:\\n synonym = result['Synonym']\\n synonym_name = synonym['SynonymName']\\n synonym_target = synonym['ObjectDataverseName'] + '.' + synonym['ObjectName']\\n synonym_dataverse = synonym['DataverseName']\\n synonyms.add((synonym_name, synonym_target, synonym_dataverse))\\n\\n return synonyms\\n\\n def get_synonyms_count(self):\\n return json.loads(self.execute(\\\"select count(*) as count from Metadata.`Synonym`;\\\"))['results'][0]['count']\\n\\n class Dataset:\\n\\n def __init__(self, name, bucket, clause=None):\\n self.name, self.bucket, self.clause = name, bucket, clause\\n\\n def get_where_clause(self):\\n return f\\\" WHERE {self.clause}\\\" if self.clause else \\\"\\\"\\n\\n class Synonym:\\n\\n def __init__(self, name, target):\\n self.name, self.target = name, target\\n\\n class Dataverse:\\n\\n def __init__(self, name):\\n self.name = name\\n self.datasets = set()\\n self.synonyms = set()\\n\\n def add_dataset(self, dataset):\\n self.datasets.add(dataset)\\n\\n def add_synonym(self, synonym):\\n self.synonyms.add(synonym)\\n\\n def next_dataset_name(self):\\n return f\\\"dat_{len(self.datasets)}\\\"\\n\\n def next_synonym_name(self):\\n return f\\\"syn_{len(self.synonyms)}\\\"\\n\\n class Analytics:\\n\\n def __init__(self, query):\\n self.query, self.dataverses = query, set()\\n\\n def add_dataverse(self, dataverse):\\n self.dataverses.add(dataverse)\\n\\n def next_dataverse_name(self):\\n return f\\\"dtv_{len(self.dataverses)}\\\"\\n\\n def pick_target_for_synonym(self):\\n choices = [f\\\"{dataverse.name}.{dataset.name}\\\" for dataverse in self.dataverses for dataset in dataverse.datasets]\\n\\n if choices:\\n return choice(choices)\\n\\n return None\\n\\n def create(self):\\n # Create daterverses and datasets\\n for dataverse in self.dataverses:\\n self.query.execute(f\\\"CREATE dataverse {dataverse.name}\\\")\\n\\n for dataset in dataverse.datasets:\\n self.query.execute(f\\\"CREATE DATASET {dataverse.name}.{dataset.name} ON {dataset.bucket}{dataset.get_where_clause()}\\\")\\n\\n # Create synonyms\\n for dataverse in self.dataverses:\\n for synonym in dataverse.synonyms:\\n self.query.execute(f\\\"CREATE analytics synonym {dataverse.name}.{synonym.name} FOR {synonym.target}\\\")\\n\\n def delete(self):\\n for dataverse in self.dataverses:\\n for dataset in dataverse.datasets:\\n self.query.execute(f\\\"DROP DATASET {dataverse.name}.{dataset.name}\\\")\\n\\n for synonym in dataverse.synonyms:\\n self.query.execute(f\\\"DROP analytics synonym {dataverse.name}.{synonym.name}\\\")\\n\\n self.query.execute(f\\\"DROP dataverse {dataverse.name}\\\")\\n\\n class AnalyticsTest:\\n\\n def __init__(self, backup, no_of_dataverses, no_of_datasets, no_of_synonyms, analytics_server):\\n # The base class\\n self.backup = backup\\n\\n # Test parameters\\n self.no_of_dataverses, self.no_of_datasets, self.no_of_synonyms = no_of_dataverses, no_of_datasets, no_of_synonyms\\n\\n # The number of synonyms that get created\\n self.no_of_synonyms_created = no_of_dataverses * no_of_synonyms\\n\\n # The object thats used to run queries on the server running analytics\\n self.query = Query(analytics_server, analytics_server.rest_username, analytics_server.rest_password)\\n\\n # The object that represents our current model of analytics\\n self.analytics = Analytics(self.query)\\n\\n def test_analytics(self):\\n # Define the analytics model (i.e. which dataverses, datasets and synonyms are present)\\n for i in range(self.no_of_dataverses):\\n dataverse = Dataverse(self.analytics.next_dataverse_name())\\n self.analytics.add_dataverse(dataverse)\\n\\n for j in range(self.no_of_datasets):\\n dataset = Dataset(dataverse.next_dataset_name(), 'default')\\n dataverse.add_dataset(dataset)\\n\\n for j in range(self.no_of_synonyms):\\n synonym = Synonym(dataverse.next_synonym_name(), self.analytics.pick_target_for_synonym())\\n dataverse.add_synonym(synonym)\\n\\n # Create dataverses, datasets and synonyms\\n self.analytics.create()\\n self.backup.assertEqual(self.query.get_synonyms_count(), self.no_of_synonyms_created)\\n\\n # Create a repository\\n self.backup.backup_create()\\n\\n # Take a backup\\n self.backup.backup_cluster()\\n\\n # Delete all analytics related stuff\\n self.analytics.delete()\\n self.backup.assertEqual(self.query.get_synonyms_count(), 0)\\n\\n # Perform a one off restore\\n self.backup.backup_restore()\\n synonyms = self.query.get_synonyms()\\n\\n # Check synonyms have been restored\\n for dataverse in self.analytics.dataverses:\\n for synonym in dataverse.synonyms:\\n self.backup.assertIn((synonym.name, synonym.target, dataverse.name), synonyms)\\n\\n # The server that will be reprovisioned with analytics\\n analytics_server = self.restore_cluster_host = self.servers[2]\\n\\n # Add a server and provision it with analytics\\n self.add_server_with_custom_services(analytics_server, services=[\\\"cbas\\\"])\\n\\n # A little sleep for services to warmup\\n self.assertTrue(RestConnection(analytics_server).wait_until_cbas_is_ready(100))\\n\\n # Run the analytics test\\n AnalyticsTest(self, self.input.param(\\\"dataverses\\\", 5), self.input.param(\\\"datasets\\\", 5), self.input.param(\\\"synonyms\\\", 5), analytics_server).test_analytics()\",\n \"def find_hypernyms(self, syns):\\n names = set()\\n # Find hypernyms of each syn\\n for syn in syns:\\n hypernyms = syn.hypernyms()\\n # find hypernyms one more level up\\n for hypernym in hypernyms:\\n names.add(hypernym.name())\\n hypernyms_second = hypernym.hypernyms()\\n for h in hypernyms_second:\\n names.add(h.name())\\n return names\",\n \"def get_searched_single_word_synonym(self, content, stop_words):\\n content = re.sub(r\\\"[^\\\\w\\\\s]\\\", \\\"\\\", content)\\n content = re.sub(r\\\"[0-9]+\\\", \\\"\\\", content)\\n new_sent = [\\n Word(word).singularize()\\n for word in content.lower().split()\\n if Word(word).singularize() not in stop_words\\n ]\\n new_sent = [\\n Word(word).singularize()\\n for word in new_sent\\n if Word(word).singularize() in set(self.searched_words)\\n ]\\n\\n syn = []\\n for w in new_sent:\\n for s in wordnet.synsets(w):\\n for lemma in s.lemmas():\\n if len(syn) == SYNONYM_LIMIT:\\n break\\n syn.append(lemma.name())\\n syn = list(dict.fromkeys(syn)) #\\n syn = \\\" \\\".join(syn)\\n return syn\",\n \"def find_all_ORFs_both_strands(dna):\\n \\n # YOUR IMPLEMENTATION HERE\",\n \"def fetch_synsets(w, tag):\\n if tag in ['PUNC', 'CONJe', 'RESe', 'DETe', 'Pe', 'DET', 'NUM', 'CL', 'P', 'NUMe', 'RES', 'CONJ', 'PRO', 'POSTP', 'INT']:\\n return []\\n #if tag not in tag_map:\\n # return []\\n pos = tag_map[tag]\\n w = re.sub(r'[ی]', 'ي', w)\\n query = \\\"SELECT id FROM synset WHERE pos=\\\\\\\"\\\" + pos + \\\"\\\\\\\" and id IN (SELECT synset FROM sense WHERE value LIKE \\\\\\\"\\\" + w + \\\"\\\\\\\")\\\"\\n cur.execute(query)\\n\\n output = []\\n for row in cur.fetchall():\\n output.append(row[0])\\n return output\",\n \"def testTwoWords(self):\\n\\n\\t\\t\\t\\twords = ['business', 'directory']\\n\\t\\t\\t\\tsynonyms = spinner.Synonym.objects.get_synonyms(words)\\n\\n\\t\\t\\t\\tassert len(synonyms)\",\n \"def main():\\n tl = TwoLocus(in_path='/csbiodata/public/www.csbio.unc.edu/htdocs/sgreens/pairwise_origins/')\\n # tl = TwoLocus()\\n # tl.preprocess(glob.glob('OR_ss_origins/*.hap'))\\n print len(tl.list_available_strains())\\n exit()\\n # print len(tl.list_available_strains())\\n # tl.preprocess(['cc_origins.csv'])\\n # tl.preprocess(['ccv_origins.csv'])\\n classical = [s for s in\\n [\\\"129P1/ReJ\\\", # \\\"129P3/J\\\", \\\"129S1SvlmJ\\\", \\\"129S6\\\", \\\"129T2/SvEmsJ\\\", \\\"129X1/SvJ\\\", \\\"A/J\\\", \\\"A/WySnJ\\\",\\n \\\"AEJ/GnLeJ\\\", \\\"AEJ/GnRk\\\", \\\"AKR/J\\\", \\\"ALR/LtJ\\\", \\\"ALS/LtJ\\\", \\\"BALB/cByJ\\\", \\\"BALB/cJ\\\", \\\"BDP/J\\\", \\\"BPH/2J\\\",\\n # \\\"BPL/1J\\\", \\\"BPN/3J\\\", \\\"BTBR T<+>tf/J\\\", \\\"BUB/BnJ\\\", \\\"BXSB/MpJ\\\", \\\"C3H/HeJ\\\", \\\"C3HeB/FeJ\\\", \\\"C57BL/10J\\\",\\n # \\\"C57BL/10ScNJ\\\", \\\"C57BL/10SAAAJ\\\", \\\"C57BL/6CR\\\", \\\"C57BL/6J\\\", \\\"C57BL/6NCI\\\", \\\"C57BL/6Tc\\\", \\\"C57BLKS/J\\\",\\n # \\\"C57BR/cdJ\\\", \\\"C57L/J\\\", \\\"C58/J\\\", \\\"CBA/CaJ\\\", \\\"CBA/J\\\", \\\"CE/J\\\", \\\"CHMU/LeJ\\\", \\\"DBA/1J\\\", \\\"DBA/1LacJ\\\",\\n # \\\"DBA/2DeJ\\\", \\\"DBA/2HaSmnJ\\\", \\\"DBA/2J\\\", \\\"DDK/Pas\\\", \\\"DDY/JclSidSeyFrkJ\\\", \\\"DLS/LeJ\\\", \\\"EL/SuzSeyFrkJ\\\",\\n # \\\"FVB/NJ\\\", \\\"HPG/BmJ\\\", \\\"I/LnJ\\\", \\\"IBWSP2\\\", \\\"IBWSR2\\\", \\\"ICOLD2\\\", \\\"IHOT1\\\", \\\"IHOT2\\\", \\\"ILS\\\", \\\"ISS\\\", \\\"JE/LeJ\\\",\\n # \\\"KK/HlJ\\\", \\\"LG/J\\\", \\\"LP/J\\\", \\\"LT/SvEiJ\\\", \\\"MRL/MpJ\\\", \\\"NOD/ShiLtJ\\\", \\\"NON/ShiLtJ\\\", \\\"NONcNZO10/LtJ\\\",\\n # \\\"NONcNZO5/LtJ\\\", \\\"NOR/LtJ\\\", \\\"NU/J\\\", \\\"NZB/BlNJ\\\", \\\"NZL/LtJ\\\", \\\"NZM2410/J\\\", \\\"NZO/HlLtJ\\\", \\\"NZW/LacJ\\\", \\\"P/J\\\",\\n # \\\"PL/J\\\", \\\"PN/nBSwUmabJ\\\", \\\"RF/J\\\", \\\"RHJ/LeJ\\\", \\\"RIIIS/J\\\", \\\"RSV/LeJ\\\", \\\"SB/LeJ\\\", \\\"SEA/GnJ\\\", \\\"SEC/1GnLeJ\\\",\\n # \\\"SEC/1ReJ\\\", \\\"SH1/LeJ\\\", \\\"SI/Col Tyrp1 Dnahc11/J\\\", \\\"SJL/Bm\\\", \\\"SJL/J\\\", \\\"SM/J\\\", \\\"SSL/LeJ\\\", \\\"ST/bJ\\\",\\n \\\"STX/Le\\\", ] # \\\"SWR/J\\\", \\\"TALLYHO/JngJ\\\", \\\"TKDU/DnJ\\\", \\\"TSJ/LeJ\\\", \\\"YBR/EiJ\\\", \\\"ZRDCT Rax<+>ChUmdJ\\\"]\\n if tl.is_available(s)]\\n wild_derived = [s for s in\\n ['22MO',\\n # 'BIK/g', 'BULS', 'BUSNA', 'BZO', 'CALB/RkJ', 'CASA/RkJ', 'CAST/EiJ', 'CIM', 'CKN', 'CKS',\\n 'CZECHI/EiJ', 'CZECHII/EiJ', 'DCA', 'DCP', 'DDO', 'DEB', 'DGA', 'DIK', 'DJO', 'DKN', 'DMZ', 'DOT',\\n # 'IS/CamRkJ', 'JF1/Ms', 'LEWES/EiJ', 'MBK', 'MBS', 'MCZ', 'MDG', 'MDGI', 'MDH', 'MGA', 'MH',\\n # 'MOLD/RkJ', 'MOLF/EiJ', 'MOLG/DnJ', 'MOR/RkJ', 'MPB', 'MSM/Ms', 'PERA/EiJ', 'PERC/EiJ', 'POHN/Deh',\\n # 'PWD/PhJ', 'PWK/PhJ', 'RBA/DnJ', 'RBB/DnJ', 'RBF/DnJ', 'SF/CamEiJ', 'SKIVE/EiJ', 'SOD1/EiJ',\\n # 'STLT', 'STRA', 'STRB', 'STUF', 'STUP', 'STUS', 'TIRANO/EiJ', 'WLA', 'WMP', 'WSB/EiJ',\\n 'ZALENDE/EiJ'] if tl.is_available(s)]\\n tl.contingency_table(classical, wild_derived, '/csbiohome01/sgreens/Projects/intervals/contingency.csv')\\n exit()\\n x = TwoLocus(chrom_sizes=[20e6, 20e6])\\n x.preprocess([\\\"test2.csv\\\"])\\n x.unique_combos(['A', 'B', 'D'], ['C', 'E'])\\n x.sources_at_point_pair('1', 1, '1', 10000000, ['A'])\\n # x.interlocus_dependence([chr(c) for c in xrange(ord('A'), ord('J')+1)])\\n # exit()\\n\\n x = TwoLocus(chrom_sizes=[20 * 10 ** 6, 20 * 10 ** 6])\\n x.preprocess([\\\"test.csv\\\"])\\n rez = x.pairwise_frequencies([\\\"A\\\"])\\n\\n areas = x.calculate_genomic_area(rez[0], rez[1])\\n total = 0.0\\n\\n for combo in subspecies.iter_combos():\\n print \\\"\\\\t{:15s}({:4d}):{:1.5f}\\\".format(subspecies.to_string(combo), combo,\\n areas[str(subspecies.to_string(combo))])\\n total += areas[str(subspecies.to_string(combo))]\\n print \\\"\\\\t{:21s}:{:1.5f}\\\".format(\\\"Total\\\", total)\\n\\n sys.exit(1)\\n # for code, combo in combos.iteritems():\\n # print \\\"\\\\n\\\", rez[1]\\n # print \\\"\\\\t{} ({}):\\\\n{}\\\".format(combo, code, rez[0][code])\",\n \"def get_person_text(self, uid):\\n words = \\\"\\\"\\n\\n query = \\\"\\\"\\\"\\nSELECT ?overview ?researchO ?label\\nWHERE\\n{\\n <%s> <http://vivoweb.org/ontology/core#overview> ?overview .\\n <%s> <http://vivoweb.org/ontology/core#researchOverview> ?researchO .\\n <%s> <http://www.w3.org/2000/01/rdf-schema#label> ?label .\\n}\\n \\\"\\\"\\\" % (uid, uid, uid)\\n self.setQuery(query)\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n words = \\\"%s %s %s\\\" % (g['results']['bindings'][0]['overview']['value'], g['results']['bindings'][0]['researchO']['value'], g['results']['bindings'][0]['label']['value'])\\n except:\\n print \\\"Select failed: %s\\\" % query\\n\\n self.setQuery(\\\"\\\"\\\"\\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\\nSELECT ?name\\nWHERE\\n{\\n ?auth vivo:relates <%s> .\\n ?auth rdf:type vivo:Authorship .\\n ?auth vivo:relates ?art .\\n filter (?art!=<%s>) .\\n ?art <http://vivoweb.org/ontology/core#dateTimeValue> ?date .\\n ?date <http://vivoweb.org/ontology/core#dateTime> ?year .\\n filter (?year>\\\"2009-01-01T00:00:00Z\\\"^^xsd:dateTime) .\\n ?art rdfs:label ?name .\\n}\\nLIMIT 20\\n\\\"\\\"\\\" % (uid, uid))\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n for t in g['results']['bindings']:\\n words = words + \\\" \\\" + t['name']['value']\\n\\n except:\\n print \\\"Select failed\\\"\\n traceback.print_exc(file=sys.stdout)\\n\\n self.setQuery(\\\"\\\"\\\"\\nPREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\\nPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\\nPREFIX vivo: <http://vivoweb.org/ontology/core#>\\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\\n\\nSELECT ?name\\nWHERE\\n{\\n ?grant vivo:relates <%s> .\\n ?grant rdf:type vivo:Grant .\\n ?grant <http://vivoweb.org/ontology/core#dateTimeInterval> ?date .\\n ?date <http://vivoweb.org/ontology/core#end> ?end .\\n ?end <http://vivoweb.org/ontology/core#dateTime> ?year .\\n filter (?year>\\\"2009-01-01T00:00:00Z\\\"^^xsd:dateTime) .\\n ?grant rdfs:label ?name .\\n}\\n\\n \\\"\\\"\\\" % (uid))\\n try:\\n rval = self.query()\\n try:\\n g = rval.convert()\\n except:\\n pass\\n\\n for t in g['results']['bindings']:\\n words = words + \\\" \\\" + t['name']['value']\\n\\n except:\\n print \\\"Select failed\\\"\\n traceback.print_exc(file=sys.stdout)\\n\\n\\n\\n\\n return words\",\n \"def get_legal_synonyms(input_filepath):\\n syn_filepath = TestSystem.get_synonym_solution_filepath(input_filepath)\\n if not os.path.isfile(syn_filepath):\\n return None\\n with io.open(syn_filepath, 'r') as f:\\n result = dict()\\n for l in f:\\n if not l.startswith('#'):\\n [name, val] = l.rstrip().split(\\\"===\\\")\\n if name not in result:\\n result[name] = [val]\\n else:\\n result[name].append(val)\\n\\n return result\",\n \"def nsrGenera(taxonList, synonymList):\\r\\n species = list(filter(None, sorted(taxonList + synonymList)))\\r\\n generaList = [i.split()[0] for i in species]\\r\\n generaList = list(dict.fromkeys(generaList))\\r\\n return generaList\",\n \"def synonyms(self) -> List[str]:\\n return pulumi.get(self, \\\"synonyms\\\")\",\n \"def weed_out_synonyms(word, potential_synonyms):\\n real_synonyms = set()\\n for synonym in potential_synonyms:\\n max_distance = abs(len(word) - len(synonym))\\n abbr_len = min(len(word), len(synonym))\\n forgiveness = round(1/7 * abbr_len)\\n if lev.distance(word, synonym) <= max_distance + forgiveness:\\n # Then it's a synonym!\\n real_synonyms.add(synonym)\\n return real_synonyms\",\n \"def extract_abbreviation_synonyms(self, corpus, use_gold, use_pred):\\n assert not (use_gold and use_pred), \\\"No support for both\\\"\\n entities = corpus.entities() if use_gold else corpus.predicted_entities()\\n\\n for entity in entities:\\n prev2 = entity.prev_tokens(entity.sentence, 2)\\n next1 = entity.next_tokens(entity.sentence, 1)\\n in_parenthesis = len(prev2) == 2 and prev2[-1].word == \\\"(\\\" and len(next1) == 1 and next1[0].word == \\\")\\\"\\n\\n if (in_parenthesis):\\n prev_entity = prev2[0].get_entity(entity.part, use_gold, use_pred)\\n\\n if prev_entity is not None and prev_entity.class_id == entity.class_id:\\n # We could combine features already -- Yet, give more freedom to final clients to use the synonym's features or not\\n # merged_binary_features = {key: (b1 or b2) for ((key, b1), (_, b2)) in zip(prev_entity.features.items(), entity.features.items())}\\n\\n prev_entity.features['synonym'] = entity\\n entity.features['synonym'] = prev_entity\",\n \"def test_synonymizer_with_other(self):\\n resource = OntologyResource(slug=\\\"foo_bar.obo\\\", directory=INPUT_DIR, local=True)\\n oi = SimpleOboImplementation(resource)\\n syn_param = [\\n Synonymizer(\\n the_rule=\\\"Broad match terms with the term 'other' in them.\\\",\\n match=\\\"(?i)^Other \\\", # noqa W605\\n match_scope=\\\"*\\\",\\n replacement=\\\"\\\",\\n qualifier=\\\"broad\\\",\\n ),\\n ]\\n synonymization = LexicalTransformation(TransformationType.Synonymization, params=syn_param)\\n pipelines = [\\n LexicalTransformationPipeline(name=\\\"test_other\\\", transformations=synonymization)\\n ]\\n lexical_index = create_lexical_index(oi, pipelines=pipelines, synonym_rules=syn_param)\\n\\n for _, v in lexical_index.groupings.items():\\n relation = [x for x in v.relationships if x.synonymized is True]\\n self.assertTrue(len(relation), 1)\\n self.assertEqual(relation[0].predicate, \\\"oio:hasBroadSynonym\\\")\",\n \"def wordNet_similarity(sentence1, sentence2):\\r\\n # Tokenize and tag\\r\\n \\r\\n # sentence1 = pos_tag(word_tokenize(sentence1))\\r\\n sentence1=st_tagger.tag(word_tokenize(sentence1))\\r\\n \\r\\n # sentence2 = pos_tag(word_tokenize(sentence2))\\r\\n sentence2=st_tagger.tag(word_tokenize(sentence2))\\r\\n\\r\\n \\r\\n # Get the synsets for the tagged words\\r\\n #################################################\\r\\n\\r\\n # synsets1=[]\\r\\n # synsets2=[]\\r\\n # for tagged_word in sentence1:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n # for tagged_word in sentence2:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # print(tagged_word)\\r\\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n\\r\\n # The code above is the elaboration of code below\\r\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\r\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\r\\n \\r\\n # Filter out the Nones in the synonym set\\r\\n synsets1 = [ss for ss in synsets1 if ss]\\r\\n synsets2 = [ss for ss in synsets2 if ss]\\r\\n \\r\\n score, count = 0.0, 0\\r\\n \\r\\n###########################################################################\\r\\n # for syn1 in synsets1:\\r\\n # arr_simi_score = []\\r\\n # print('=========================================')\\r\\n # print(syn1)\\r\\n # print('----------------')\\r\\n # for syn2 in synsets2:\\r\\n # print(syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n # print(simi_score)\\r\\n # if simi_score is not None:\\r\\n # arr_simi_score.append(simi_score)\\r\\n # print('----------------')\\r\\n # print(arr_simi_score)\\r\\n # if(len(arr_simi_score) > 0):\\r\\n # best = max(arr_simi_score)\\r\\n # print(best)\\r\\n # score += best\\r\\n # count += 1\\r\\n # # Average the values\\r\\n # print('score: ', score)\\r\\n # print('count: ', count)\\r\\n # score /= count\\r\\n\\r\\n###########################################################################\\r\\n\\r\\n for syn1 in synsets1:\\r\\n arr_simi_score = []\\r\\n # print('=========================================')\\r\\n print(\\\"Each word from Synonym se1\\\",syn1)\\r\\n # print('----------------')\\r\\n for syn2 in synsets2:\\r\\n print(\\\"Each word from Synonym se2\\\",syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n simi_score = syn1.wup_similarity(syn2)\\r\\n print(\\\"word to word path_similarity score\\\",simi_score)\\r\\n if simi_score is not None:\\r\\n arr_simi_score.append(simi_score)\\r\\n print('----------------')\\r\\n print(arr_simi_score)\\r\\n if(len(arr_simi_score) > 0):\\r\\n best = max(arr_simi_score)\\r\\n print(\\\"best score so far\\\", best)\\r\\n score += best\\r\\n count += 1\\r\\n # Average the values\\r\\n print('score: ', score)\\r\\n print('count: ', count)\\r\\n if count!=0:\\r\\n score /= count\\r\\n else:\\r\\n score=0.0\\r\\n return score\",\n \"def generate_antonym_pairs(config: SettingConfig) -> dict:\\n print(f\\\"Generating initial antonym pairs from RoWordNet @ {datetime.now()}\\\")\\n wn = rwn.RoWordNet()\\n\\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\\n # the PoS and the value is a set of pairs of words of PoS specified by the key\\n pairs = dict()\\n\\n # Iterate over the selected parts of speech\\n for part_of_speech in config.pos.values():\\n\\n pos_pairs = list()\\n\\n # Return all synsets corresponding to the PoS\\n synset_ids = wn.synsets(pos=part_of_speech)\\n\\n # Iterate all the synsets for the current PoS\\n for synset_id in synset_ids:\\n\\n # Get the synset object specified by synset_id\\n synset = wn.synset(synset_id)\\n\\n # Get the outbound relations of type antonym from\\n outbound_relations = filter(lambda x: x[1] == 'near_antonym', wn.outbound_relations(synset_id))\\n\\n # Iterate outbound relations\\n for relation in outbound_relations:\\n # Get the synset corresponding to the target of the outbound relation\\n target_synset = wn.synset(relation[0])\\n\\n # Get all the pairs, sort them by first word to keep set entries unique\\n current_iteration_pairs = get_cross_synset_pairs(synset, target_synset)\\n\\n # Add the current set of pairs\\n pos_pairs.extend(current_iteration_pairs)\\n\\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\\n for key, value in config.pos.items():\\n if value == part_of_speech:\\n pairs[key] = unique(pos_pairs)\\n\\n # Return the whole dictionary\\n print(f\\\"Successfully generated antonym paris @ {datetime.now()}\\\")\\n return pairs\",\n \"def covid_mention(text, synonyms=covid_list):\\n for term in synonyms:\\n if term in text:\\n return 'Yes'\\n continue\\n return 'No'\",\n \"def cousins(word, level):\\r\\n parents = [get_synset(word)]\\r\\n for _ in range(level):\\r\\n parent_hypernyms = [parent.hypernyms() for parent in parents]\\r\\n parents = list(chain(*parent_hypernyms))\\r\\n\\r\\n children = parents\\r\\n for _ in range(level):\\r\\n children_hyponyms = [child.hyponyms() for child in children]\\r\\n children = list(chain(*children_hyponyms))\\r\\n\\r\\n children = set(children)\\r\\n children -= {get_synset(word)}\\r\\n return set(map(synset_name, children))\",\n \"def load_known_corpora():\\n\\n print (\\\"Loading Corpora\\\")\\n\\n # For debugging purposes, comment out the definition of all but say the first\\n # corpus, to speed the ingest time.\\n shenoute_a22 = Corpus()\\n shenoute_a22.annis_corpus_name = \\\"shenoute.a22\\\"\\n shenoute_a22.title = \\\"Acephalous Work 22\\\"\\n shenoute_a22.slug = \\\"acephalous_work_22\\\"\\n shenoute_a22.urn_code = \\\"shenoute.a22\\\"\\n shenoute_a22.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-a22\\\"\\n\\n patrum = Corpus()\\n patrum.annis_corpus_name = \\\"apophthegmata.patrum\\\"\\n patrum.title = \\\"Apophthegmata Patrum\\\"\\n patrum.slug = \\\"ap\\\"\\n patrum.urn_code = \\\"ap\\\"\\n patrum.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/AP\\\"\\n\\n saof = Corpus()\\n saof.annis_corpus_name = \\\"shenoute.abraham.our.father\\\"\\n saof.title = \\\"Abraham Our Father\\\"\\n saof.slug = \\\"abraham_our_father\\\"\\n saof.urn_code = \\\"shenoute.abraham\\\"\\n saof.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/abraham\\\"\\n\\n besa_ap = Corpus()\\n besa_ap.annis_corpus_name = \\\"besa.letters\\\"\\n besa_ap.title = \\\"Letter to Aphthonia\\\"\\n besa_ap.slug = \\\"to_aphthonia\\\"\\n besa_ap.urn_code = \\\"besa.aphthonia\\\"\\n besa_ap.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\\\"\\n\\n fox = Corpus()\\n fox.annis_corpus_name = \\\"shenoute.fox\\\"\\n fox.title = \\\"Not Because a Fox Barks\\\"\\n fox.slug = \\\"not_because_a_fox_barks\\\"\\n fox.urn_code = \\\"shenoute.fox\\\"\\n fox.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-fox\\\"\\n\\n mark = Corpus()\\n mark.annis_corpus_name = \\\"sahidica.mark\\\"\\n mark.title = \\\"Gospel of Mark\\\"\\n mark.slug = \\\"gospel_of_mark\\\"\\n mark.urn_code = \\\"nt.mark\\\"\\n mark.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n corinth = Corpus()\\n corinth.annis_corpus_name = \\\"sahidica.1corinthians\\\"\\n corinth.title = \\\"1 Corinthians\\\"\\n corinth.slug = \\\"1st_corinthians\\\"\\n corinth.urn_code = \\\"nt.1cor\\\"\\n corinth.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n snt = Corpus()\\n snt.annis_corpus_name = \\\"sahidica.nt\\\"\\n snt.title = \\\"New Testament\\\"\\n snt.slug = \\\"new-testament\\\"\\n snt.urn_code = \\\"nt\\\"\\n snt.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/bible\\\"\\n\\n eager = Corpus()\\n eager.annis_corpus_name = \\\"shenoute.eagerness\\\"\\n eager.title = \\\"I See Your Eagerness\\\"\\n eager.slug = \\\"eagernesss\\\"\\n eager.urn_code = \\\"shenoute.eagerness\\\"\\n eager.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/shenoute-eagerness\\\"\\n\\n besa_nuns = Corpus()\\n besa_nuns.annis_corpus_name = \\\"besa.letters\\\"\\n besa_nuns.title = \\\"Letter to Thieving Nuns\\\"\\n besa_nuns.slug = \\\"to_thieving_nuns\\\"\\n besa_nuns.urn_code = \\\"besa.thieving\\\"\\n besa_nuns.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/besa-letters\\\"\\n\\n doc_pap = Corpus()\\n doc_pap.annis_corpus_name = \\\"doc.papyri\\\"\\n doc_pap.title = \\\"Documentary Papyri\\\"\\n doc_pap.slug = \\\"papyri\\\"\\n doc_pap.urn_code = \\\"copticDoc:papyri_info\\\"\\n doc_pap.github = \\\"https://github.com/CopticScriptorium/corpora/tree/master/doc-papyri\\\"\\n\\n known_corpora = [shenoute_a22, patrum, saof, besa_ap, fox, mark, corinth, snt, eager, besa_nuns, doc_pap]\\n# known_corpora = [shenoute_a22]\\n \\n for one in known_corpora:\\n try:\\n Corpus.objects.get(slug__exact=one.slug)\\n except Corpus.DoesNotExist:\\n one.save()\",\n \"def meet(self, word, sense1=0, sense2=0):\\n s1 = self._synset(self.text, sense1)\\n s2 = self._synset(word, sense2)\\n\\n common = s1.lowest_common_hypernyms(s2)\\n\\n result = list()\\n for c in common:\\n result.append(c.name()[:5])\\n\\n return result if result else []\",\n \"def recommend_cosim():\\n pass\",\n \"def poem_generation(magnet,topic):\\r\\n e = inflect.engine()\\r\\n antonyms = []\\r\\n synonyms = []\\r\\n poem = \\\"\\\"\\r\\n verb = \\\"\\\"\\r\\n # plural\\r\\n if (e.singular_noun(topic) is False):\\r\\n verb = \\\"is\\\"\\r\\n else:\\r\\n verb = \\\"are\\\"\\r\\n \\r\\n for syn in wordnet.synsets(topic):\\r\\n for l in syn.lemmas():\\r\\n synonyms.append(l.name())\\r\\n if l.antonyms():\\r\\n antonyms.append(l.antonyms()[0].name())\\r\\n if (len(set(antonyms)) < 1):\\r\\n for syn in wordnet.synsets(RAND_LIST[random.randint(0,len(RAND_LIST)-1)]):\\r\\n for l in syn.lemmas():\\r\\n synonyms.append(l.name())\\r\\n if l.antonyms():\\r\\n antonyms.append(l.antonyms()[0].name())\\r\\n topic = topic.capitalize()\\r\\n for i in range(0,random.randint(5,15)):\\r\\n verse = random.randint(0,6)\\r\\n question = random.randint(0,6)\\r\\n # structure\\r\\n # antonyms\\r\\n if (verse < 2) and len(antonyms) > 0:\\r\\n ant_magnet = metaphor_magnet(antonyms[random.randint(0,len(antonyms)-1)])\\r\\n choice = random.randint(0,len(ant_magnet)-1)\\r\\n detail = ant_magnet[choice].split(\\\":\\\")\\r\\n if (question < 2):\\r\\n index = random.randint(0,len(QUESTION)-1)\\r\\n if (detail[0][0] in ['a','e','i','o','u']):\\r\\n poem += QUESTION[index] + \\\" \\\" + verb + \\\" \\\" + topic + \\\" not like an \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"?\\\\n\\\" \\r\\n else:\\r\\n poem += QUESTION[index] + \\\" \\\" + verb + \\\" \\\" + topic + \\\" not like a \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"?\\\\n\\\" \\r\\n else:\\r\\n if (detail[0][0] in ['a','e','i','o','u']):\\r\\n poem += topic + \\\" \\\" + verb + \\\" not like an \\\" + detail[0] + \\\" \\\" + detail[1] + \\\".\\\\n\\\" \\r\\n else:\\r\\n poem += topic + \\\" \\\" + verb + \\\" not like a \\\" + detail[0] + \\\" \\\" + detail[1] + \\\".\\\\n\\\" \\r\\n \\r\\n else:\\r\\n choice = random.randint(0,len(magnet)-1)\\r\\n detail = magnet[choice].split(\\\":\\\")\\r\\n if (question < 2):\\r\\n index = random.randint(0,len(QUESTION)-1)\\r\\n if (detail[0][0] in ['a','e','i','o','u']):\\r\\n poem += QUESTION[index] + \\\" \\\" + verb + \\\" \\\" + topic + \\\" like an \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"?\\\\n\\\" \\r\\n else:\\r\\n poem += QUESTION[index] + \\\" \\\" + verb + \\\" \\\" + topic + \\\" like a \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"?\\\\n\\\" \\r\\n else:\\r\\n if (detail[0][0] in ['a','e','i','o','u']):\\r\\n poem += topic + \\\" \\\" + verb + \\\" like an \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"\\\\n\\\" \\r\\n else:\\r\\n poem += topic + \\\" \\\" + verb + \\\" like a \\\" + detail[0] + \\\" \\\" + detail[1] + \\\"\\\\n\\\" \\r\\n \\r\\n return poem\",\n \"def synonyms_pipeline(config: SettingConfig) -> None:\\n raw_synonym_pairs = generate_synonym_pairs(config)\\n for pos in config.pos.keys():\\n processed_synonym_pairs = postprocess_pairs(raw_synonym_pairs[pos], config)\\n write_pairs(processed_synonym_pairs, config.constraints_root_path, pos, \\\"synonyms\\\")\",\n \"def main():\\n long_sequence = input(\\\"Please give ne a DNA sequence to search: \\\")\\n short_sequence = input(\\\"What DNA sequence would you like to match? \\\")\\n\\n # converts characters to uppercase\\n new_long_sequence = long_sequence.upper()\\n new_short_sequence = short_sequence.upper()\\n\\n ans = homology(new_long_sequence, new_short_sequence)\\n print(\\\"The best match is \\\" + ans)\",\n \"def composeWorkplaceOntology():\\n\\n import ossPyFuncs \\n import pandas as pd\\n \\n #mysql query to extract full table from government organizations\\n #certian table columns feature capital letters which cases uproblems\\n postgreSql_selectQuery=\\\"SELECT * FROM us_gov_manual.us_govman_2019 ;\\\"\\n #pass querry and obtain table\\n govTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n\\n #mysql query to obtain academic instutions\\n postgreSql_selectQuery=\\\"SELECT institution FROM hipolabs.universities ;\\\"\\n #pass querry and obtain table\\n univTable=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2018_us1000;\\\"\\n businesses1=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2019_us1000;\\\"\\n businesses2=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n \\n postgreSql_selectQuery=\\\"SELECT company FROM forbes.fortune2020_global2000;\\\"\\n businesses3=ossPyFuncs.queryToPDTable(postgreSql_selectQuery)\\n\\n #combine theinsitutions into a vector\\n combinedSeries=[govTable['AgencyName'],univTable['institution'],businesses1['company'],businesses2['company'],businesses3['company']]\\n #turn the multi item vector into a single series\\n fullWordbank=pd.concat(combinedSeries)\\n #turn that series into a pd dataframe\\n wordbankTable=pd.DataFrame(fullWordbank.unique())\\n\\n return wordbankTable\",\n \"def getSynonyms(self, wordSet):\\n synonyms = {}\\n for w in wordSet:\\n # find synonyms\\n synsets = wn.synsets(w, pos=wn.NOUN)\\n if len(synsets) > 0: \\n # there are noun senses for this word, get synonyms\\n synonyms[w] = set([synset.name for synset in synsets])\\n \\n return synonyms\",\n \"def return_wikipedia_term(res):\\n rst = []\\n if res['spotted']:\\n for s in [s['spot'] for s in res['value']['spots']]:\\n r = TagMeService.retrieve_taggings(s.encode('utf-8'), method='POST')\\n if len(r['annotations']) != 0:\\n for n in r['annotations']:\\n if 'title' in n.keys():\\n title = n['title'].replace(' ', '_') # strip whitespaces from dbpedia tag\\n rst.append(title)\\n else:\\n print \\\"Cannot find title in annotations: \\\" + str(n)\\n return rst\",\n \"def get_hypernyms(word):\\n syn = wn.synsets(word)\\n hnyms = []\\n for h in syn[0].hypernyms():\\n hnyms.append({\\n \\\"lemmas\\\": h.lemma_names(),\\n \\\"d\\\": h.definition(),\\n \\\"pos\\\": h.pos(),\\n \\\"id\\\": h.name()\\n })\\n return hnyms\",\n \"def synonyms(self) -> List[str]:\\n return self._synonyms\",\n \"def substantiate():\",\n \"def generate_synonym_pairs(config: SettingConfig) -> dict:\\n wn = rwn.RoWordNet()\\n\\n # Create the output dictionary that will be of type dict(str : set(pair(str, str)) where the key is\\n # the PoS and the value is a set of pairs of words of PoS specified by the key\\n pairs = dict()\\n\\n # Iterate over the selected parts of speech\\n for part_of_speech in config.pos.values():\\n\\n pos_pairs = list()\\n\\n # Return all synsets corresponding to the PoS\\n synset_ids = wn.synsets(pos=part_of_speech)\\n\\n # Iterate all the synsets for the current PoS\\n for synset_id in synset_ids:\\n # Get the synset object specified by synset_id\\n synset = wn.synset(synset_id)\\n\\n # Get all the pairs, sort them by first word to keep set entries unique\\n current_iteration_pairs = get_synset_pairs(synset)\\n\\n # Append all pairs from the current PoS to the global set\\n pos_pairs.extend(current_iteration_pairs)\\n\\n # Get corresponding key in pos dictionary and add the pair to the resulting dictionary\\n for key, value in config.pos.items():\\n if value == part_of_speech:\\n pairs[key] = unique(pos_pairs)\\n\\n return pairs\",\n \"def boldNSR(species, synonyms, syn_dict, zip_path):\\r\\n # Loop over each genus(file) downloaded from BOLD\\r\\n print('Comparing sequence data to list of species...')\\r\\n # Open genera file from zip\\r\\n with zipfile.ZipFile(zip_path) as z:\\r\\n for file in z.namelist():\\r\\n if not os.path.isdir(file):\\r\\n # Read genera file\\r\\n filename = os.fsdecode(file)\\r\\n if filename.endswith(\\\".tsv\\\"):\\r\\n with z.open(filename, 'r') as zfile:\\r\\n zfile = io.TextIOWrapper(io.BytesIO(zfile.read()), errors='ignore')\\r\\n tsvreader = csv.DictReader(zfile, delimiter=\\\"\\\\t\\\")\\r\\n # Read each record\\r\\n for line in tsvreader:\\r\\n # Filter on Geographical site\\r\\n if (line['country'] == \\\"Netherlands\\\"):\\r\\n bold_identification = re.sub('[()]', '', str(line['identification_reference']))\\r\\n bold_name = line['species_name'] + \\\" \\\" + bold_identification\\r\\n # Compare BOLD with NSR species names\\r\\n if (bold_name in species):\\r\\n boldOutput(args.outfile1, line)\\r\\n # Check for synonyms, apply accepted name\\r\\n elif (bold_name in synonyms):\\r\\n for synonym, taxon in syn_dict.items():\\r\\n synonym = ' '.join(synonym.split()[:2])\\r\\n if synonym == line['species_name']:\\r\\n taxon = ' '.join(taxon.split()[:2])\\r\\n line['species_name'] = taxon\\r\\n boldOutput(args.outfile1, line)\\r\\n # Write missmatches to seperate file\\r\\n else:\\r\\n boldOutput(args.outfile2, line)\\r\\n continue\\r\\n else:\\r\\n continue\",\n \"def known_organisms():\\n return [\\\"rat\\\"]\",\n \"def _solve_double_synonym(parse_tree, solution_format=None):\\n def _get_value(solution_list, word):\\n # Gets the value of a word in a solution list\\n for solution in solution_list:\\n if solution[0] == word:\\n return solution[1]\\n\\n return 0\\n\\n # Get the two synonym parts\\n first_syn, second_syn = _get_parts_ignore_EQU(parse_tree)\\n first_syn = _create_sentence(first_syn)\\n second_syn = _create_sentence(second_syn)\\n\\n # Get top 1000 matching scores for each part of the clue\\n if solution_format is not None:\\n first_solutions = SimilaritySolver.solve(first_syn, length=solution_format.get_total_length(spaces=True))\\n second_solutions = SimilaritySolver.solve(second_syn, length=solution_format.get_total_length(spaces=True))\\n second_words = [word for word, _ in second_solutions if solution_format.check(word)]\\n else:\\n first_solutions = SimilaritySolver.solve(first_syn)\\n second_solutions = SimilaritySolver.solve(second_syn)\\n second_words = [word for word, _ in second_solutions]\\n\\n # Combine both lists, with the value being the product of the value for eac syn part\\n solutions = [(solution[0], _get_value(second_solutions, solution[0]) * solution[1]) for\\n solution in first_solutions if solution[0] in second_words]\\n\\n return solutions\",\n \"def get_speech(self, word):\\n posses = ['verb', 'noun', 'adj', 'adv', 'as in', 'conjunction']\\n speeches = []\\n\\n def get_all_synonyms(word1, speech1):\\n for w in Word(word1).synonyms('all', partOfSpeech=speech1):\\n if not w == []:\\n return w\\n return []\\n\\n def empty_tree(input_list):\\n # print(input_list)\\n if type(input_list) == type([]):\\n for l in input_list:\\n if not empty_tree(l):\\n return False\\n return True\\n else:\\n return False\\n\\n for poss in posses:\\n if not empty_tree(get_all_synonyms(word, poss)):\\n speeches.append(poss)\\n return speeches\",\n \"def synonyms(self):\\n\\n return [synonym[\\\"name\\\"] for synonym in self._get_synonym_json()]\",\n \"def select_syninfo(self, cellname, srctype, syntype):\\n idx = np.char.startswith(self.syntab['dest'], cellname+'/') & \\\\\\n np.char.startswith(self.syntab['source'], srctype) & \\\\\\n np.char.startswith(self.syntab['type'], syntype)\\n return self.syntab[idx]\",\n \"def find_pseudonyms(original_name, gender, topk):\\n firstnames = load_firstnames(gender)\\n model = load_model()\\n whitelist = LetterBag(slugify.slugify(\\n WORD_SPLIT_PATTERN.sub(\\\"\\\", original_name)))\\n for firstname in firstnames:\\n if not whitelist.includes(firstname):\\n continue\\n for lastname, proba in generate_word(model, whitelist.sub(firstname), topk):\\n yield firstname.surface, lastname, proba\",\n \"def get_words_from_sysets(synset):\\n synlist = []\\n for s in synset:\\n syns = s.lemmas()[0].name()\\n synlist.append(syns)\\n return synlist\",\n \"def sample_sonnet(hmm, obs_map, n_words):\\n sonnetLines = []\\n sonnet = ''\\n\\n for numLines in range(14):\\n line = sample_sentence(hmm, obs_map, n_words)\\n sonnetLines.append(''.join(line).capitalize() + '\\\\n')\\n\\n for line in sonnetLines:\\n sonnet += line\\n\\n return sonnet\",\n \"def make_concordance(debug=False):\\n query = \\\"\\\"\\\"\\n SELECT ?uri ?name\\n WHERE {\\n ?uri a skos:Concept .\\n ?uri rdfs:label ?name .\\n }\\\"\\\"\\\"\\n result = vivo_sparql_query(query)\\n\\n if 'results' in result and 'bindings' in result['results']:\\n rows = result[\\\"results\\\"][\\\"bindings\\\"]\\n else:\\n return concordance\\n if debug:\\n print query\\n if len(rows) >= 2:\\n print rows[0],rows[1]\\n elif len(rows) == 1:\\n print rows[0]\\n concordance = shelve.open(\\\"concordance\\\")\\n for row in rows:\\n name = row['name']['value']\\n uri = str(row['uri']['value'])\\n concordance[uri] = name\\n if debug:\\n print concordance.items()[1:3]\\n return concordance\",\n \"def Path_Similarity(word1, word2):\\n\\n # Initial test to confirm unique nouns, otherwise passes back 1\\n\\n if word1 == word2:\\n return 1, word1\\n\\n # Sets up Initial Variables & Dictionaries\\n\\n stepup1 = [word1]\\n stepup2 = [word2]\\n dict1= {}\\n dict2= {}\\n currentstep1 = []\\n currentstep2 = []\\n\\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\\n # for each word to individual dictionaries with the number of iterations\\n # as the key to the dictionary. The two dictionaries are saved perpetually\\n\\n for la in range(50):\\n for i in range(len(stepup1)):\\n currentstep1 += (stepup1[i].hypernyms())\\n for syn in stepup1:\\n dict1[syn] = la\\n for i in range(len(stepup2)):\\n currentstep2 = (stepup2[i].hypernyms())\\n for syn in stepup2:\\n dict2[syn] = la\\n\\n # Variables are reset and converted to continue the next stage of the loop\\n\\n stepup1 = currentstep1\\n stepup2 = currentstep2\\n currentstep1 = []\\n currentstep2 = []\\n\\n\\n # Each loop the dictionaries are checked for matches. I have confirmed that\\n # checking each cycle is faster than checking at the end of an arbitrary\\n # number of cycles.\\n\\n # Removes applied words as Possible Subsumers Per Fridays Clas\\n dict1.pop(word1)\\n dict2.pop(word2)\\n\\n #Gets possible Least Common Subsumers\\n dict1Set = set(dict1)\\n dict2Set = set(dict2)\\n d = {}\\n for name in dict1Set.intersection(dict2Set):\\n d[name] = dict1[name]\\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\\n\\n #Returns Actual LCS\\n key_lcs = []\\n for i in pos_lcs:\\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\\n\\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\\n\\n return 1/(dict1[lcs] + dict2[lcs]), lcs\",\n \"def hypernym(self, sense=None):\\n s = self._synset(self.text)\\n\\n if not s:\\n return []\\n\\n hyper = s.hypernyms()\\n\\n results = list()\\n for h in hyper:\\n results.append(h.lemma_names())\\n\\n if not sense:\\n return results\\n\\n return results[:sense]\",\n \"def find_all_ORFs(dna):\\n \\n # YOUR IMPLEMENTATION HERE\",\n \"def nsrTaxonomy():\\r\\n # Input file\\r\\n taxonomyFile = pd.read_csv(args.indir+\\\"/\\\"+args.infile1, header=2,\\r\\n sep=\\\"\\\\t\\\", encoding=\\\"utf8\\\")\\r\\n\\r\\n # Parse taxonomic names into their elementary components\\r\\n taxonomy = taxonomyFile.loc[taxonomyFile['rank'] == 'soort']\\r\\n taxonList = []\\r\\n for taxon in taxonomy['scientific_name']:\\r\\n parser = taxonParser(taxon)\\r\\n if not parser or parser is False:\\r\\n pass\\r\\n else:\\r\\n taxonList.append(parser)\\r\\n\\r\\n # Write taxonomy to file\\r\\n index = 0\\r\\n with io.open(par_path+\\\"/results/nsr_species.csv\\\", \\\"w\\\", encoding=\\\"utf-8\\\") as outfile:\\r\\n outfile.write('\\\"species_id\\\",\\\"species_name\\\",\\\"identification_reference\\\"\\\\n')\\r\\n for i in taxonList:\\r\\n binomial = ' '.join(str(i).split()[:2])\\r\\n authorship = ' '.join(str(i).split()[2:])\\r\\n outfile.write('%s,%s,\\\"%s\\\"\\\\n' % (index, binomial, authorship))\\r\\n index += 1\\r\\n\\r\\n return taxonList\",\n \"def get(self, request, format=None):\\n user = request.user\\n user.backend = 'django.contrib.auth.backends.ModelBackend'\\n login(request, user)\\n data = {}\\n data['synonyms'] = []\\n tags = request.GET.get('tags', '')\\n for tag in tags.split(','):\\n result = requests.get('https://wordsapiv1.p.mashape.com/words/{0}/synonyms'.format(tag),\\n headers={\\n \\\"X-Mashape-Key\\\": settings.MASHAPE,\\n \\\"Accept\\\": \\\"application/json\\\",\\n })\\n if 'synonyms' in result.json():\\n data['synonyms'] += result.json()['synonyms']\\n return Response(data)\",\n \"def generateWord2(self, parameters=None):\\n\\n\\t\\t##Initial set-up\\n\\t\\t#A syllable consists of an optional onset, a nucleus, and an optional coda\\n\\t\\t#Sources:\\n\\t\\t# http://en.wikipedia.org/wiki/English_phonology#Phonotactics\\n\\t\\t# http://en.wiktionary.org/wiki/Appendix:English_pronunciation\\n\\t\\tonsets = [\\\"ch\\\", \\\"pl\\\", \\\"bl\\\", \\\"cl\\\", \\\"gl\\\", \\\"pr\\\", \\\"br\\\", \\\"tr\\\", \\\"dr\\\", \\\"cr\\\", \\\"gr\\\", \\\"tw\\\", \\\"dw\\\", \\\"qu\\\", \\\"pu\\\",\\n\\t\\t\\t\\t \\\"fl\\\", \\\"sl\\\", \\\"fr\\\", \\\"thr\\\", \\\"shr\\\", \\\"wh\\\", \\\"sw\\\",\\n\\t\\t\\t\\t \\\"sp\\\", \\\"st\\\", \\\"sk\\\", \\\"sm\\\", \\\"sn\\\", \\\"sph\\\", \\\"spl\\\", \\\"spr\\\", \\\"str\\\", \\\"scr\\\", \\\"squ\\\", \\\"sm\\\"] #Plus the normal consonants\\n\\t\\tnuclei = [\\\"ai\\\", \\\"ay\\\", \\\"ea\\\", \\\"ee\\\", \\\"y\\\", \\\"oa\\\", \\\"au\\\", \\\"oi\\\", \\\"oo\\\", \\\"ou\\\"] #Plus the normal vowels\\n\\t\\tcodas = [\\\"ch\\\", \\\"lp\\\", \\\"lb\\\", \\\"lt\\\", \\\"ld\\\", \\\"lch\\\", \\\"lg\\\", \\\"lk\\\", \\\"rp\\\", \\\"rb\\\", \\\"rt\\\", \\\"rd\\\", \\\"rch\\\", \\\"rk\\\", \\\"lf\\\", \\\"lth\\\",\\n\\t\\t\\t\\t \\\"lsh\\\", \\\"rf\\\", \\\"rth\\\", \\\"rs\\\", \\\"rsh\\\", \\\"lm\\\", \\\"ln\\\", \\\"rm\\\", \\\"rn\\\", \\\"rl\\\", \\\"mp\\\", \\\"nt\\\", \\\"nd\\\", \\\"nch\\\", \\\"nk\\\", \\\"mph\\\",\\n\\t\\t\\t\\t \\\"mth\\\", \\\"nth\\\", \\\"ngth\\\", \\\"ft\\\", \\\"sp\\\", \\\"st\\\", \\\"sk\\\", \\\"fth\\\", \\\"pt\\\", \\\"ct\\\", \\\"kt\\\", \\\"pth\\\", \\\"ghth\\\", \\\"tz\\\", \\\"dth\\\",\\n\\t\\t\\t\\t \\\"ks\\\", \\\"lpt\\\", \\\"lfth\\\", \\\"ltz\\\", \\\"lst\\\", \\\"lct\\\", \\\"lx\\\",\\\"rmth\\\", \\\"rpt\\\", \\\"rtz\\\", \\\"rst\\\", \\\"rct\\\",\\\"mpt\\\", \\\"dth\\\",\\n\\t\\t\\t\\t \\\"nct\\\", \\\"nx\\\", \\\"xth\\\", \\\"xt\\\"] #Plus normal consonants\\n\\n\\t\\tsimpleLetterChance = 65 #percent, whether a single letter is chosen instead of an onset/nucleus/coda\\n\\t\\tbasicLetterChance = 75 #percent, whether a simple consonant/vowel is chosen over a more rare one\\n\\n\\t\\t#Prevent unnecessary and ugly code repetition\\n\\n\\t\\t#Start the word\\n\\t\\trepeats = 1\\n\\t\\tif parameters and len(parameters) > 0:\\n\\t\\t\\trepeats = SharedFunctions.parseInt(parameters[0], 1, 1, 25)\\n\\n\\t\\twords = []\\n\\t\\tfor i in xrange(0, repeats):\\n\\t\\t\\tsyllableCount = 2\\n\\t\\t\\tif random.randint(1, 100) <= 50:\\n\\t\\t\\t\\tsyllableCount -= 1\\n\\t\\t\\tif random.randint(1, 100) <= 35:\\n\\t\\t\\t\\tsyllableCount += 1\\n\\n\\t\\t\\tword = u\\\"\\\"\\n\\t\\t\\tfor j in range(0, syllableCount):\\n\\t\\t\\t\\t#In most cases, add an onset\\n\\t\\t\\t\\tif random.randint(1, 100) <= 75:\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"consonant\\\", basicLetterChance)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(onsets)\\n\\n\\t\\t\\t\\t#Nucleus!\\n\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"vowel\\\", basicLetterChance)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tword += random.choice(nuclei)\\n\\n\\t\\t\\t\\t#Add a coda in most cases (Always add it if this is the last syllable of the word and it'd be too short otherwise)\\n\\t\\t\\t\\tif (j == syllableCount - 1 and len(word) < 3) or random.randint(1, 100) <= 75:\\n\\t\\t\\t\\t\\tif random.randint(1, 100) <= simpleLetterChance:\\n\\t\\t\\t\\t\\t\\tword += self.getBasicOrSpecialLetter(\\\"consonant\\\", basicLetterChance)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tword += random.choice(codas)\\n\\n\\t\\t\\tword = word[0].upper() + word[1:]\\n\\t\\t\\twords.append(word)\\n\\n\\t\\treturn u\\\", \\\".join(words)\",\n \"def get_wiki_synonyms_mapping() -> Dict[str, str]:\\n with open(Config.Path.synonym_mapping, \\\"r\\\") as f:\\n return json.load(f)\",\n \"def get_synsets(words):\\n synsets = {}\\n for word in words:\\n for syn in wn.synsets(word):\\n synsets[syn.name] = tuple([lemma.name for lemma in syn.lemmas])\\n return synsets\",\n \"def testOneWord(self):\\n\\n\\t\\t\\t\\tspinner.Synonym.objects.add('directory', 'catalog', 10)\\n\\t\\t\\t\\tspinner.Synonym.objects.add('list', 'directory', 20)\\n\\t\\t\\t\\tspinner.Synonym.objects.add('directory', 'guide', 10)\\n\\n\\t\\t\\t\\tsynonyms = spinner.Synonym.objects.get_synonyms(['directory'])\\n\\t\\t\\t\\tassert len(synonyms) < 3, synonyms\",\n \"def get_synsets_rt(word: str) -> List:\\n return rt.categories(word)\",\n \"def read_syn_data():\\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\\n folder = pjoin(dipy_home, 'syn_test')\\n t1_name = pjoin(folder, 't1.nii.gz')\\n b0_name = pjoin(folder, 'b0.nii.gz')\\n\\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\\n\\n check_md5(t1_name, md5_dict['t1'])\\n check_md5(b0_name, md5_dict['b0'])\\n\\n t1 = nib.load(t1_name)\\n b0 = nib.load(b0_name)\\n return t1, b0\",\n \"def meronym(self, sense=0):\\n s = self._synset(self.text, sense=sense)\\n\\n if not s:\\n return []\\n\\n return s.member_meronyms()\",\n \"def onto(disgenet, edam):\\n disgenet = disgenet.replace(' ', '+').replace(\\\"'\\\", \\\"%27\\\")\\n edam = edam.replace(' ', '+').replace(\\\"'\\\", \\\"%27\\\")\\n disid = subprocess.Popen(\\n [\\\"curl -s -k http://127.0.0.1:3030/ds/query -X POST --data \\\" +\\n \\\"'query=PREFIX+rdf%3A+%3Chttp%3A%2F%2Fwww.w3.org%2F1999%2F02%2F22-rdf-syntax-ns%23%3E%0A\\\" +\\n \\\"PREFIX+dcterms%3A+%3Chttp%3A%2F%2Fpurl.org%2Fdc%2Fterms%2F%3E%0A\\\" +\\n \\\"PREFIX+ncit%3A+%3Chttp%3A%2F%2Fncicb.nci.nih.gov%2Fxml%2Fowl%2FEVS%2FThesaurus.owl%23%3E%0A\\\" +\\n \\\"SELECT+DISTINCT+%0A%09%3Fdisease+%0AFROM+%3Chttp%3A%2F%2Frdf.disgenet.org%3E+%0AWHERE+%7B%0A++\\\" +\\n \\\"SERVICE+%3Chttp%3A%2F%2Frdf.disgenet.org%2Fsparql%2F%3E+%7B%0A++++\\\" +\\n \\\"%3Fdisease+rdf%3Atype+ncit%3AC7057+%3B%0A++++%09dcterms%3Atitle+%22\\\" + disgenet +\\n \\\"%22%40en+.%0A%7D%0A%7D' -H 'Accept: application/sparql-results+json,*/*;q=0.9'\\\"],\\n stdout=subprocess.PIPE, shell=True).communicate()[0]\\n edam_id = subprocess.Popen([\\\"curl -s 'http://www.ebi.ac.uk/ols/api/search?q=\\\" + edam + \\\"&ontology=edam' 'Accept: application/json'\\\"],\\n stdout=subprocess.PIPE, shell=True).communicate()[0]\\n try:\\n jdisease = json.loads(disid)\\n umllist = []\\n umls = jdisease['results']['bindings'][0]['disease']['value']\\n except (IndexError, ValueError):\\n umls = \\\"No disgenet record\\\"\\n try:\\n jedam = json.loads(edam_id)\\n eid = jedam['response']['docs'][0]['iri']\\n except (IndexError, ValueError):\\n eid = \\\"No EDAM record\\\"\\n return umls, eid\",\n \"def create_syn(dataframe, col):\\n\\n hypernym_e = {}\\n hyper = []\\n for i, val in enumerate(dataframe[col]):\\n if wn.synsets(val):\\n syn = wn.synsets(val)[0]\\n s = syn.hypernyms()\\n if s:\\n for val in s:\\n hyper.append(str(val)[8:-3].split('.')[0])\\n\\n hypernym_e[i] = ', '.join(v for v in hyper)\\n hyper = []\\n else:\\n hypernym_e[i] = 'None'\\n else:\\n hypernym_e[i] = 'None'\\n\\n colname = col + '_syn'\\n\\n hypernym_e_dataframe = create_dataframe(hypernym_e, [colname])\\n dataframe[colname] = hypernym_e_dataframe[colname]\\n\\n return dataframe\",\n \"def get_acid_name(seq):\\n term_list = []\\n for i in __kmers(seq,k=3):\\n res = __get_key(i,full_amino_acid_name)\\n term_list.append(res)\\n return ''.join(term_list)\",\n \"def match_taxon(name):\\n taxid = None\\n scientific_name = None\\n automatic_replacement = False\\n iname = name.strip().lower().replace(' ', ' ')\\n\\n if name:\\n # 1. 'name' matches the scientific name of a virus:\\n if name in scientific_names:\\n taxid = scientific_names[name]\\n scientific_name = name\\n # 2. 'name' is a close case-insensitive match for a virus:\\n elif iname in lowercase_names:\\n taxid = lowercase_names[iname]\\n scientific_name = taxid_names[taxid]\\n automatic_replacement = True\\n # 3. 'name' is the exact synonym of some taxon\\n elif name in synonyms:\\n taxid = synonyms[name]\\n scientific_name = taxid_names[taxid]\\n # 4. 'name' is a substring of exactly one scientific name:\\n else:\\n matches = []\\n for scientific_name in scientific_names.keys():\\n if name in scientific_name:\\n matches.append(scientific_name)\\n if len(matches) > 1:\\n break\\n if len(matches) == 1:\\n scientific_name = matches[0]\\n taxid = scientific_names[scientific_name]\\n\\n return (name, taxid, scientific_name, automatic_replacement)\",\n \"def find_related_concepts(text):\\n #\\n # Find wikipedia terms in text\\n # Spot terms in text\\n text = text.encode('ascii', 'replace')\\n response = TagMeService.check_spotting(text)\\n\\n results = return_wikipedia_term(response)\\n\\n #\\n # Lookup terms in taxonomy and fetch relatedConcepts (keywords)\\n # return related terms if they are found in the taxonomy\\n\\n return lookup_in_taxonomy(results)\",\n \"def __synonym_replacement(self, tokenized_sentence: list) -> str:\\n sentence_length = len(tokenized_sentence)\\n # Initialize the return string\\n new_sentence = \\\"\\\"\\n # Some variables to keep track of changes and attempted changes\\n has_changed = False\\n attempts = 0\\n # Keep trying to make a change until either:\\n # 1) You've made a change, OR\\n # 2) You've tried to make a change for half the words in the sentence with no success\\n while has_changed is not True and attempts <= sentence_length/2:\\n # Grab a random word from the tokenized sentence\\n index_to_change = random.randint(0, sentence_length-1)\\n pair_to_change = tokenized_sentence[index_to_change]\\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_change)\\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \\n if len(list_of_syns) < 1: \\n # Failed synonym swap, so bump up the attempts tracker by one\\n attempts += 1\\n continue\\n # Else, the word does have synonyms we can swap the word for\\n else:\\n # Randomly pick a word from the synonym list\\n random_pick = random.randint(0, len(list_of_syns)-1)\\n new_word = list_of_syns[random_pick]\\n new_word_pair = (new_word, \\\"NA\\\") # \\\"NA\\\" is a dummy POS tag\\n # Now update the tokenized sentence with the new word\\n tokenized_sentence[index_to_change] = new_word_pair\\n # Pull the sentence back together\\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\\n # Now let's clean up our brand new sentence really quickly\\n new_sentence = nltk_methods.clean_sentence(new_sentence)\\n # BUT WAIT, what if this is a duplicate? We don't want that!\\n if new_sentence in self.return_augmented_sentences():\\n # Bump up the attempts and skip this sentence\\n attempts += 1\\n continue\\n # Update the flags\\n has_changed = True\\n return new_sentence\",\n \"def generate_wordnet_candidates(self, word):\\n candidates = set()\\n if self.check_if_replacable(word):\\n for synset in wordnet.synsets(word):\\n for lemma in synset.lemmas():\\n converted = convert(lemma.name().lower(), word)\\n if converted != word and converted != None:\\n try:\\n w1 = wordnet.synsets(word)[0]\\n w2 = wordnet.synsets(converted)[0]\\n similarity = w1.wup_similarity(w2)\\n if isinstance(similarity,float) and w1.wup_similarity(w2) >0.6 :\\n candidates.add(converted)\\n except:\\n pass\\n # print(\\\"candidate\\\",word,candidates)\\n return candidates\",\n \"def get_abbreviation_matches(dddb, org_concepts):\\n try:\\n for org in org_concepts:\\n acronym = Acronym(org['canon_name'])\\n\\n for abbrev in acronym.get_possible_acronyms():\\n abbrev = \\\"'\\\" + abbrev + \\\" %'\\\"\\n\\n dddb.execute(SELECT_ORG_ABBREVIATIONS.format(abbrev))\\n\\n abbrev_orgs = dddb.fetchall()\\n\\n for row in abbrev_orgs:\\n dup_org = {'oid': int(row[0]), 'name': row[1], 'is_abbreviation': 1, 'can_delete': 0}\\n dup_org = identify_subchapter_abbreviation(abbrev, dup_org)\\n org['duplicates'].append(dup_org)\\n\\n return org_concepts\\n\\n except MySQLdb.Error:\\n print(traceback.format_exc())\",\n \"def GetSynonymTerm(con, cur, synonym):\\n err, termid = GetSynonymTermId(con, cur, synonym)\\n if err:\\n debug(2, 'ontology term %s is not a synonym' % synonym)\\n return err, str(termid)\\n err, term = dbidval.GetDescriptionFromId(con, cur, 'ontologyTable', termid)\\n if err:\\n debug(3, 'ontology term not found for termid %d (synonym %s)' % (termid, synonym))\\n return err, term\\n return '', term\",\n \"def _generator():\\n filename_1 = 'gene.txt'\\n filename_2 = 'geneSynonym.txt'\\n gene_set_1 = gene_names(filename_1)\\n gene_syn = gene_names(filename_2, complete=False)\\n genes = gene_set_1 | gene_syn\\n return genes\",\n \"def c_synonym_cd(self) -> str:\\n return \\\"N\\\"\",\n \"def main():\\n\\n # Remove the files if existing before creating new ones\\n OUT_VOCAB = \\\"results/vocabs.txt\\\"\\n OUT_SYN = \\\"results/syn.txt\\\"\\n OUT_EXCP = \\\"results/exception.txt\\\"\\n for f in [OUT_SYN, OUT_VOCAB, OUT_EXCP]:\\n if os.path.isfile(f):\\n os.remove(f)\\n\\n \\\"\\\"\\\"\\n Now we do the recursion:\\n Step 1: Find the children link;\\n Step 2: Add to the url_list;\\n Step: Move to next entry of the url_list and Go to Step 1;\\n \\\"\\\"\\\"\\n with open(DATA, \\\"r\\\") as fin:\\n url_list = fin.readlines()\\n\\n # Write down the urls as tuples, 0 as the first level\\n url_list = [((PREFIX_URL + subURL).strip(), 0) for subURL in url_list]\\n\\n with open(OUT_VOCAB, \\\"w\\\") as vocab_file, \\\\\\n open(OUT_SYN, \\\"w\\\") as syn_file, \\\\\\n open(OUT_EXCP, \\\"w\\\") as exp_file:\\n cur_index = 0\\n while cur_index < len(url_list):\\n # Current url of the term, current level number (hierarchy) of the term\\n cur_url, cur_hrc = url_list[cur_index]\\n try:\\n # Get the current sub-url\\n time.sleep(0.1)\\n r = requests.get(cur_url + \\\"?\\\" + API_KEY)\\n source_dict = json.loads(r.text)\\n\\n # Getting the vocabulary and the synonym from this page.\\n vocab, syn = parse_words(source_dict=source_dict)\\n if cur_hrc + 1 < int(level):\\n # Fetch all the children's name and url\\n children_urls = fetch_children_url(source_dict=source_dict, hrc=cur_hrc + 1)\\n # print children_urls\\n url_list = url_list + children_urls # Concatenate the lists\\n\\n if vocab is not None:\\n syn_file.write(json.dumps({vocab: syn}) + \\\"\\\\n\\\")\\n vocab_file.write(vocab + \\\"\\\\n\\\")\\n\\n if cur_index % 100 == 0:\\n print \\\"\\\\tNow at index # {}, {} in total.\\\".format(str(cur_index), str(len(url_list)))\\n except UnicodeEncodeError as unicode_err:\\n exp_file.write(str(unicode_err))\\n except KeyError as key_err:\\n exp_file.write(str(key_err))\\n except:\\n pass\\n cur_index += 1\",\n \"def bioinfo():\\n\\n pass\",\n \"def sample_sonnet_syl_and_rhyme(hmm, obs_map, rhyme_dict, n_syl = 10):\\n sonnetLines = []\\n r_sonnetLines = []\\n sonnet = ''\\n sonnet_length = 14\\n count = 0\\n syl_counts = syllable_dict()\\n # print(syl_counts)\\n \\n while count < sonnet_length:\\n # Pick a random word from the rhyming dictionary that the line has to start with. \\n \\n start_word = np.random.choice(list(rhyme_dict.keys()))\\n rhyme_word = np.random.choice(rhyme_dict[start_word])\\n line1 = sample_sentence_syl(hmm, obs_map, rhyme_dict, start_word, n_syl)\\n line2 = sample_sentence_syl(hmm, obs_map, rhyme_dict, rhyme_word, n_syl)\\n (worked1, nline1) = make_line(line1, n_syl, syl_counts)\\n (worked2, nline2) = make_line(line2, n_syl, syl_counts)\\n if worked1 and worked2:\\n sonnetLines.append(nline1)\\n sonnetLines.append(nline2)\\n count += 2\\n\\n # Now flip the order of each line.\\n for line in sonnetLines:\\n line_reversed = ' '.join(reversed(line.split(' '))).capitalize()\\n r_sonnetLines.append(line_reversed + '\\\\n')\\n\\n # Rearrange 7 couplets into a sonnet.\\n for stanza in range(0, 3):\\n idx = [0, 1, 2, 3]\\n for i in range(len(idx)):\\n idx[i] += stanza * 4\\n sonnet += r_sonnetLines[idx[0]] + r_sonnetLines[idx[2]] + r_sonnetLines[idx[1]] + r_sonnetLines[idx[3]]\\n\\n for line_num in range(12, 14):\\n sonnet += r_sonnetLines[line_num]\\n\\n return sonnet\",\n \"def find_discordant_snps(\\n self, individual1, individual2, individual3=None, save_output=False\\n ):\\n self._remap_snps_to_GRCh37([individual1, individual2, individual3])\\n\\n df = individual1.snps\\n\\n # remove nulls for reference individual\\n df = df.loc[df[\\\"genotype\\\"].notnull()]\\n\\n # add SNPs shared with `individual2`\\n df = df.join(individual2.snps[\\\"genotype\\\"], rsuffix=\\\"2\\\")\\n\\n genotype1 = \\\"genotype_\\\" + individual1.get_var_name()\\n genotype2 = \\\"genotype_\\\" + individual2.get_var_name()\\n\\n if individual3 is None:\\n df = df.rename(columns={\\\"genotype\\\": genotype1, \\\"genotype2\\\": genotype2})\\n\\n # find discordant SNPs between reference and comparison individuals\\n df = df.loc[\\n df[genotype2].notnull()\\n & (\\n (df[genotype1].str.len() == 1)\\n & (df[genotype2].str.len() == 1)\\n & (df[genotype1] != df[genotype2])\\n )\\n | (\\n (df[genotype1].str.len() == 2)\\n & (df[genotype2].str.len() == 2)\\n & (df[genotype1].str[0] != df[genotype2].str[0])\\n & (df[genotype1].str[0] != df[genotype2].str[1])\\n & (df[genotype1].str[1] != df[genotype2].str[0])\\n & (df[genotype1].str[1] != df[genotype2].str[1])\\n )\\n ]\\n if save_output:\\n save_df_as_csv(\\n df,\\n self._output_dir,\\n \\\"discordant_snps_{}_{}_GRCh37.csv\\\".format(\\n individual1.get_var_name(), individual2.get_var_name()\\n ),\\n comment=self._get_csv_header(),\\n prepend_info=False,\\n )\\n else:\\n # add SNPs shared with `individual3`\\n df = df.join(individual3.snps[\\\"genotype\\\"], rsuffix=\\\"3\\\")\\n\\n genotype3 = \\\"genotype_\\\" + individual3.get_var_name()\\n\\n df = df.rename(\\n columns={\\n \\\"genotype\\\": genotype1,\\n \\\"genotype2\\\": genotype2,\\n \\\"genotype3\\\": genotype3,\\n }\\n )\\n\\n # find discordant SNPs between child and two parents\\n df = df.loc[\\n (\\n df[genotype2].notnull()\\n & (\\n (df[genotype1].str.len() == 1)\\n & (df[genotype2].str.len() == 1)\\n & (df[genotype1] != df[genotype2])\\n )\\n | (\\n (df[genotype1].str.len() == 2)\\n & (df[genotype2].str.len() == 2)\\n & (df[genotype1].str[0] != df[genotype2].str[0])\\n & (df[genotype1].str[0] != df[genotype2].str[1])\\n & (df[genotype1].str[1] != df[genotype2].str[0])\\n & (df[genotype1].str[1] != df[genotype2].str[1])\\n )\\n )\\n | (\\n df[genotype3].notnull()\\n & (\\n (df[genotype1].str.len() == 1)\\n & (df[genotype3].str.len() == 1)\\n & (df[genotype1] != df[genotype3])\\n )\\n | (\\n (df[genotype1].str.len() == 2)\\n & (df[genotype3].str.len() == 2)\\n & (df[genotype1].str[0] != df[genotype3].str[0])\\n & (df[genotype1].str[0] != df[genotype3].str[1])\\n & (df[genotype1].str[1] != df[genotype3].str[0])\\n & (df[genotype1].str[1] != df[genotype3].str[1])\\n )\\n )\\n | (\\n df[genotype2].notnull()\\n & df[genotype3].notnull()\\n & (df[genotype2].str.len() == 2)\\n & (df[genotype2].str[0] == df[genotype2].str[1])\\n & (df[genotype2] == df[genotype3])\\n & (df[genotype1] != df[genotype2])\\n )\\n ]\\n\\n if save_output:\\n save_df_as_csv(\\n df,\\n self._output_dir,\\n \\\"discordant_snps_{}_{}_{}_GRCh37.csv\\\".format(\\n individual1.get_var_name(),\\n individual2.get_var_name(),\\n individual3.get_var_name(),\\n ),\\n comment=self._get_csv_header(),\\n prepend_info=False,\\n )\\n\\n return df\",\n \"def query_synapses(self, pre_name, post_name):\\n return self.sql_query(\\n \\\"\\\"\\\" select from Synapse where uname = \\\"{}--{}\\\" \\\"\\\"\\\".format(pre_name, post_name))\",\n \"def antonym(self, sense=0):\\n s = self._synset(self.text, sense=sense)\\n\\n if not s:\\n return []\\n\\n lemmas = s.lemmas()\\n\\n result = list()\\n\\n for lemma in lemmas:\\n if lemma.antonyms():\\n result.append(lemma.antonyms()[0].name())\\n\\n return result if result else []\",\n \"def queryYM( self, geneName, level ):\\n result = [] \\n \\n # Get a new query on the table\\n query = service.new_query(\\\"Gene\\\")\\n query.add_constraint(\\\"interactions.participant2\\\", \\\"Gene\\\") \\n \\n query.add_view( \\\"primaryIdentifier\\\", \\\"symbol\\\", \\\"secondaryIdentifier\\\", \\\"sgdAlias\\\", \\\"name\\\",\\n \\\"organism.shortName\\\", \\\"interactions.details.annotationType\\\",\\n \\\"interactions.details.phenotype\\\", \\\"interactions.details.role1\\\",\\n \\\"interactions.details.experimentType\\\", \\\"interactions.participant2.symbol\\\",\\n \\\"interactions.participant2.secondaryIdentifier\\\",\\n \\\"interactions.details.experiment.name\\\",\\n \\\"interactions.details.relationshipType\\\" )\\n \\n query.add_constraint(\\\"organism.shortName\\\", \\\"=\\\", \\\"S. cerevisiae\\\", code = \\\"B\\\")\\n query.add_constraint(\\\"Gene\\\", \\\"LOOKUP\\\", geneName, code = \\\"A\\\")\\n \\n for row in query.rows():\\n data = level, row[\\\"primaryIdentifier\\\"], row[\\\"symbol\\\"], row[\\\"secondaryIdentifier\\\"], row[\\\"sgdAlias\\\"], \\\\\\n row[\\\"name\\\"], row[\\\"organism.shortName\\\"], row[\\\"interactions.details.annotationType\\\"], \\\\\\n row[\\\"interactions.details.phenotype\\\"], row[\\\"interactions.details.role1\\\"], \\\\\\n row[\\\"interactions.details.experimentType\\\"], row[\\\"interactions.participant2.symbol\\\"], \\\\\\n row[\\\"interactions.participant2.secondaryIdentifier\\\"], \\\\\\n row[\\\"interactions.details.experiment.name\\\"], row[\\\"interactions.details.relationshipType\\\"]\\n item = list(data)\\n result.append(item) \\n \\n return result\",\n \"def get_synopsis(file_data):\\n for individual in file_data:\\n if 'synopsis' in individual:\\n synopsis = individual.split('\\\"')\\n return synopsis[1]\",\n \"def try1():\\n path = '/Users/mayankkejriwal/datasets/eswc2017/disasters/'\\n model = Word2Vec.load_word2vec_format(path+'GoogleNews-vectors-negative300.bin', binary=True)\\n model.init_sims(replace=True)\\n keys = ['charlotte', 'Charlotte', 'yorktown', 'LA']\\n for key in keys:\\n try:\\n # print model.most_similar(positive=['woman', 'king'], negative=['man'])\\n j = model[key]\\n print 'found...',\\n print key\\n except KeyError:\\n print 'not found...',\\n print key\\n continue\\n print model.similarity('charlotte', 'carolina')\\n print model.similarity('LA', 'California')\",\n \"def test_genbank_to_genome_taxonomy(self):\\n result = self.gfu.genbank_to_genome(self.ctx, {\\n 'workspace_name': self.ws_name,\\n 'generate_ids_if_needed': 'true', # why is this a string\\n 'taxon_id': '3702',\\n 'file': {\\n 'path': f\\\"{_DATA_PATH}/wigglesworthia/genome.gb\\\"\\n },\\n 'genome_name': str(uuid4()),\\n })\\n ('result', result)\\n ref = result[0]['genome_ref']\\n self.assertTrue(ref, 'Genome ref exists')\\n info = result[0]['genome_info']\\n typ = info[2]\\n self.assertTrue(typ.startswith('KBaseGenomes.Genome'))\\n info_details = info[-1]\\n self.assertEqual(info_details['Taxonomy'], (\\n \\\"cellular organisms;Eukaryota;Viridiplantae;\\\"\\n \\\"Streptophyta;Streptophytina;Embryophyta;Tracheophyta;\\\"\\n \\\"Euphyllophyta;Spermatophyta;Magnoliopsida;Mesangiospermae;\\\"\\n \\\"eudicotyledons;Gunneridae;Pentapetalae;rosids;malvids;\\\"\\n \\\"Brassicales;Brassicaceae;Camelineae;Arabidopsis\\\"\\n ))\\n self.assertEqual(info_details['Size'], '697724')\\n self.assertEqual(info_details['Source'], 'Genbank')\\n self.assertEqual(info_details['Name'], 'Wigglesworthia glossinidia endosymbiont of Glossina brevipalpis')\\n self.assertEqual(info_details['GC content'], '0.22479')\\n self.assertEqual(info_details['Genetic code'], '11')\\n self.assertEqual(info_details['Number of Genome Level Warnings'], '1')\\n self.assertEqual(info_details['Source ID'], 'BA000021')\\n self.assertEqual(info_details['Number of Protein Encoding Genes'], '20')\\n self.assertEqual(info_details['Domain'], 'Eukaryota')\\n self.assertTrue(info_details['Assembly Object'])\\n self.assertEqual(info_details['Number contigs'], '1')\\n self.assertEqual(info_details['Number of CDS'], '20')\\n self.assertTrue(info_details['MD5'])\",\n \"def parse_obo(obo,\\n output_file=None,\\n id2name_file=None,\\n id2namespace_file=None,\\n alt_id_file=None):\\n\\n ## Keywords that screw up parsing:\\n # import, is_anonymous, intersection_of, union_of\\n\\n ## Relations\\n # 'is_a:'\\n # 'relationship: has_part' # Not in filtered GO\\n # 'relationship: occurs_in' # Not in filtered GO\\n # 'relationship: part_of' \\n # 'relationship: positively_regulates' \\n # 'relationship: negatively_regulates'\\n # 'relationship: regulates'\\n # 'relationship: results_in' # Not in filtered GO\\n\\n stanza, edges = [], []\\n id2name = dict()\\n id2namespace = dict()\\n alt_id = dict()\\n in_term_stanza = False\\n default_namespace_exists = False\\n for line in io.open(obo).read().splitlines():\\n\\n line = line.split('!')[0].strip() # Remove comments\\n\\n if len(line)>0 and line[0]=='[' and line[-1]==']':\\n # Add last stanza if it was a term stanza. Include namespace.\\n if in_term_stanza:\\n edges.extend(x+(namespace, ) for x in stanza)\\n\\n # Start new term stanza\\n stanza = []\\n \\n # Set the default namespace, if it exists\\n if default_namespace_exists:\\n namespace = default_namespace\\n \\n # In a term stanzo or not\\n in_term_stanza = line =='[Term]'\\n\\n name = None\\n \\n #if 'alt_id:' in line: assert False\\n\\n if 'id:' == line[:3]:\\n curr_term = line.split('id:')[1].strip()\\n elif 'alt_id:' in line:\\n alt_term = line.split('alt_id:')[1].strip()\\n if curr_term in alt_id: alt_id[curr_term].append(alt_term)\\n else: alt_id[curr_term] = [alt_term]\\n id2name[alt_term] = name\\n elif 'name:' in line:\\n name = line.split('name:')[1].strip()\\n #assert not curr_term in id2name\\n id2name[curr_term] = name\\n elif 'is_a:' in line:\\n parent = line.split('is_a:')[1].strip()\\n stanza.append((parent, curr_term, 'is_a'))\\n elif 'relationship:' in line:\\n line = line.split('relationship:')[1].strip().split()\\n if len(line)!=2: print(line)\\n assert len(line)==2\\n relation, parent = line\\n stanza.append((parent, curr_term, relation))\\n elif 'namespace:' == line[:10]:\\n namespace = line.split('namespace:')[1].strip()\\n assert not curr_term in id2namespace\\n id2namespace[curr_term] = namespace\\n elif 'default-namespace:' == line[:18]:\\n namespace = line.split('default-namespace:')[1].strip()\\n default_namespace_exists = True\\n default_namespace = namespace\\n\\n pd.DataFrame(edges).to_csv(output_file, header=False, index=False, sep='\\\\t')\\n pd.Series(id2name).to_csv(id2name_file, sep='\\\\t')\\n pd.Series(id2namespace).to_csv(id2namespace_file, sep='\\\\t')\\n pd.Series(dict([(a, c) for a, b in alt_id.items() for c in b])).to_csv(alt_id_file, sep='\\\\t')\",\n \"def test_create_gene_ontology(self):\\n\\n # Here are mappings for just a few yeast genes.\\n\\n mapping = {}\\n mapping['STE7'] = ['GO:0000187']\\n mapping['PBS2'] = ['GO:0000187']\\n mapping['NOP8'] = [\\n 'GO:0003676', 'GO:0003723', 'GO:0042254', 'GO:0005634', 'GO:0005730'\\n ]\\n\\n # Build the ontology, then see if it looks correct.\\n\\n root = dc.models.tensorgraph.models.ontology.create_gene_ontology(\\n mapping, min_node_features=1)\\n assert len(root.feature_ids) == 0\\n\\n def find_features(node, features):\\n features.update(node.feature_ids)\\n for child in node.children:\\n find_features(child, features)\\n\\n all_features = set()\\n find_features(root, all_features)\\n assert len(all_features) == 3\\n for key in mapping:\\n assert key in all_features\",\n \"def TrinityAnnotation(Trinityfa,fileBlast6,GIfa,output):\\n from Bio import SeqIO\\n myTrinity = list(SeqIO.parse(Trinityfa,\\\"fasta\\\"))\\n mygislist = list(SeqIO.parse(GIfa,\\\"fasta\\\"))\\n mygis = {}\\n for giseq in mygislist:\\n mygis[giseq.id.split(\\\"|\\\")[1]] = giseq\\n mylist = open(fileBlast6,\\\"r\\\").readlines()\\n fout = open(output,\\\"w\\\")\\n sqdic = {}\\n queryset = set()\\n for ele in mylist:\\n subject = ele.split()[1] +\\\"|\\\" + ele.split()[3]+\\\" Identity: \\\" + ele.split()[2]\\n query = ele.split()[0]\\n if query not in queryset:\\n sqdic[query]=subject\\n queryset.add(query)\\n for ele in myTrinity:\\n if ele.id not in queryset:\\n fout.write(ele.id +\\\"\\\\t\\\"+\\\"NA\\\\n\\\")\\n else:\\n fout.write(ele.id +\\\"\\\\t\\\"+mygis[sqdic[ele.id].split(\\\"|\\\")[1]].description+\\\" QL:\\\"+\\\\\\n str(len(ele.seq)) +\\\" SL: \\\"+str(len(mygis[sqdic[ele.id].split(\\\"|\\\")[1]].seq)) +\\\\\\n \\\" ML: \\\"+ sqdic[ele.id].split(\\\"|\\\")[-1] +\\\"\\\\n\\\")\\n fout.close()\",\n \"def print_common_hub_words(rem_stop_words):\\n results = {'_removing stop-words':rem_stop_words}\\n\\n print '------ CLASSIFICATION EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/tasa/TASA900_dependencies'\\n texts, labels = data.read_files(descriptions_path)\\n\\n print '> Creating representations..'\\n fd = nltk.probability.FreqDist()\\n for i, text in enumerate(texts):\\n if i%100==0: print ' ',str(i)+'/'+str(len(texts))\\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\\n hubs = graph.get_hubs(g, 10)\\n for h in hubs:\\n fd.inc(h[0])\\n g = None # just to make sure..\\n\\n results['tasa'] = fd.keys()\\n\\n print '------ RETRIEVAL EVALUATION --------'\\n print '> Reading cases..'\\n descriptions_path = '../data/air/problem_descriptions_dependencies'\\n description_texts, labels = data.read_files(descriptions_path)\\n\\n print '> Creating representations..'\\n fd = nltk.probability.FreqDist()\\n for i, text in enumerate(description_texts):\\n if i%100==0: print ' ',str(i)+'/'+str(len(description_texts))\\n g = graph_representation.construct_dependency_network(text, remove_stop_words=rem_stop_words)\\n hubs = graph.get_hubs(g, 10)\\n for h in hubs:\\n fd.inc(h[0])\\n g = None # just to make sure..\\n\\n results['air'] = fd.keys()\\n\\n if rem_stop_words:\\n modifier = 'without'\\n else:\\n modifier = 'with'\\n data.pickle_to_file(results, 'output/dependencies/common_hubs_'+modifier+'stop_words')\\n\\n pp.pprint(results)\\n return results\",\n \"def generate_similar_sentences(sentence,w2v,percentage_to_replace=1,max_syn=10,num_outputs=50):\\n\\n list_of_sentences = []\\n\\n words = pairwise_tokenize(sentence,w2v,remove_stopwords=False) #This has combined any compound words found in word2vec\\n\\n #if word contains underscore don't sub in synonyms\\n dont_sub_idx = []\\n compound_word_idx = []\\n deleted_idx = []\\n for idx,word in enumerate(words):\\n if \\\"_\\\" in word or word in stopwords.words('english'):\\n dont_sub_idx.append(idx)\\n if \\\"_\\\" in word:\\n compound_word_idx.append(idx)\\n deleted_idx.append(idx+1)\\n if not word:\\n dont_sub_idx.append(idx)\\n\\n pattern = re.compile('[\\\\W_]+') \\n sentence = pattern.sub(\\\" \\\",sentence).lower().strip()\\n tagged = pos_tag(sentence.split(\\\" \\\")) #Pos_tag needs to use the original sentence to tag parts of speech, we will now delete indices that correspond to words that no longer exist b/c of compound\\n \\n for idx in reversed(compound_word_idx):\\n tagged.pop(idx+1)\\n \\n for tag in tagged:\\n if tag[1] == 'NNP':\\n dont_sub_idx.append(idx)\\n \\n for i in xrange(num_outputs):\\n new_words = words\\n mask = np.random.random_sample(len(words))\\n for j in xrange(len(words)):\\n if mask[j] < .5 and j not in dont_sub_idx:\\n pos = wordnet_pos_code(tagged[j][1])\\n synonyms = get_synonyms(words[j],w2v,pos,max=max_syn)\\n if len(synonyms) != 0:\\n new_words[j] = synonyms[np.random.randint(0,min(max_syn,len(synonyms)))]\\n list_of_sentences.append(\\\" \\\".join(new_words))\\n\\n list_of_sentences = set(list_of_sentences)\\n return list(list_of_sentences)\",\n \"def parse_words(source_dict):\\n name, syn = None, []\\n if 'synonym' in source_dict:\\n syn = source_dict['synonym']\\n if 'prefLabel' in source_dict:\\n name = source_dict['prefLabel']\\n return name, syn\",\n \"def try2():\\n path = '/Users/mayankkejriwal/datasets/heiko-vectors/'\\n model = Word2Vec.load(path+'DB2Vec_sg_500_5_5_15_4_500')\\n\\n print model['http://purl.org/dc/terms/subject']\\n print model['dbo:birthPlace']\\n print model['http://dbpedia.org/ontology/birthPlace']\\n print len(model)\\n print 'success'\",\n \"def __insert_random_synonym(self, tokenized_sentence: list) -> str:\\n sentence_length = len(tokenized_sentence)\\n # Initialize the return string\\n new_sentence = \\\"\\\"\\n # Some variables to keep track of changes and attempted changes\\n has_changed = False\\n attempts = 0\\n # Keep trying to make a change until either:\\n # 1) You've made a change, OR\\n # 2) You've tried to make a change for half the words in the sentence with no success\\n while has_changed is not True and attempts <= sentence_length/2:\\n # Grab a random word from the tokenized sentence\\n index_to_get_word_from = random.randint(0, sentence_length-1)\\n pair_to_get_word_from = tokenized_sentence[index_to_get_word_from]\\n # Get the list of synonyms based off of that (word, POS) pair from the tokenized sentence\\n list_of_syns = nltk_methods.list_of_syns_from_pos_pair(pair_to_get_word_from)\\n # ...but what if it's a word that doesn't have any synonyms matching the POS tag? \\n if len(list_of_syns) < 1: \\n # Failed synonym swap, so bump up the attempts tracker by one\\n attempts += 1\\n continue\\n # Else, the word does have synonyms we can swap the word for\\n else:\\n # Randomly pick a word from the synonym list\\n random_pick = random.randint(0, len(list_of_syns)-1)\\n new_word = list_of_syns[random_pick]\\n new_word_pair = (new_word, \\\"NA\\\") # \\\"NA\\\" is a dummy POS tag\\n # Now randomly find a spot to put the new word\\n index_to_place_new_word = random.randint(0, sentence_length-1)\\n # Now update the tokenized sentence with the new word\\n tokenized_sentence.insert(index_to_place_new_word, new_word_pair)\\n sentence_length += 1\\n # Pull the sentence back together\\n new_sentence = nltk_methods.put_string_together_from_pos_tagged_list(tokenized_sentence)\\n # Now let's clean up our brand new sentence really quickly\\n new_sentence = nltk_methods.clean_sentence(new_sentence)\\n # BUT WAIT, what if this is a duplicate? We don't want that!\\n if new_sentence in self.return_augmented_sentences():\\n # Bump up the attempts and skip this sentence\\n attempts += 1\\n continue\\n # Update the flags\\n has_changed = True\\n return new_sentence\",\n \"def get_concepts_for_text(f2t, adir, ptext2ptmk, ptmk2sk):\\n print \\\"Getting concepts for texts (returns pointmention pks for a text)\\\"\\n cpco2ptmk = {} # simple hash\\n vbco2ptmk = {} # verbose hash\\n for idx, fn in enumerate(os.listdir(adir)):\\n sfn = fn.replace(\\\"pointmention_nbr_\\\", \\\"\\\")\\n with codecs.open(os.path.join(adir, fn), \\\"r\\\", \\\"utf8\\\") as ifd:\\n jso = js.loads(ifd.read().strip())\\n for co in jso[\\\"concepts\\\"]:\\n txt = f2t[sfn]\\n # only value is a set with the pointmention pks\\n ptmpks = ptext2ptmk[txt].values()\\n assert len(ptmpks) == 1\\n assert isinstance(ptmpks[0], set)\\n ptmpks = ptmpks[0]\\n # smaller hash, all ptmkeys for a concept go in a set\\n cpco2ptmk.setdefault(co[\\\"prefLabel\\\"].strip(),\\n {\\\"uri\\\": co[\\\"uri\\\"].replace(RPREF, \\\"\\\"),\\n \\\"ptmks\\\": set()})\\n cpco2ptmk[co[\\\"prefLabel\\\"].strip()][\\\"ptmks\\\"].update(ptmpks)\\n # verbose hash (with sentence id and score per mention)\\n for ptmpk in ptmpks:\\n curkey = (co[\\\"prefLabel\\\"].strip(),\\n co[\\\"uri\\\"].replace(RPREF, \\\"\\\"))\\n curdict = {\\\"ptmk\\\": ptmpk, \\\"spk\\\": ptmk2sk[ptmpk],\\n \\\"sco\\\": co[\\\"score\\\"] / 100.0}\\n vbco2ptmk.setdefault(curkey, [])\\n if curdict not in vbco2ptmk[curkey]:\\n vbco2ptmk[curkey].append(curdict)\\n if idx and not idx % 10000:\\n print \\\"- Done concepts for {} texts, {}\\\".format(\\n idx, time.strftime(\\\"%H:%M:%S\\\", time.localtime()))\\n return cpco2ptmk, vbco2ptmk\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6278373","0.6064663","0.6054872","0.6007341","0.6002883","0.59069574","0.5802612","0.58015925","0.57863915","0.57196033","0.56676126","0.5618402","0.5598366","0.55523103","0.5539704","0.55314595","0.55285823","0.5485978","0.5470576","0.5457307","0.5448995","0.54257673","0.54072857","0.53738904","0.5354592","0.53531325","0.5349846","0.5303758","0.5300222","0.5287609","0.52718174","0.52675366","0.5245243","0.5243033","0.52310604","0.52265894","0.5225218","0.518193","0.5178737","0.51780015","0.5159622","0.5152411","0.5147551","0.5144985","0.5130259","0.5127397","0.5122522","0.51143855","0.510587","0.5099482","0.5095484","0.50857234","0.50757027","0.5060261","0.505584","0.503325","0.50103384","0.5008733","0.5006176","0.50023776","0.5001866","0.498404","0.497895","0.49739736","0.49595648","0.49587652","0.49570066","0.4954961","0.495419","0.4944407","0.49418512","0.49372888","0.4935868","0.4930735","0.4912883","0.4903028","0.48976886","0.48868424","0.4886778","0.4884284","0.48823723","0.48763996","0.4868318","0.48603743","0.48592243","0.48569736","0.4855782","0.48547676","0.48496","0.48491314","0.48408782","0.4838083","0.48303223","0.48254657","0.48247242","0.48207957","0.48143074","0.4802507","0.4802337","0.47961685","0.4794923"],"string":"[\n \"0.6278373\",\n \"0.6064663\",\n \"0.6054872\",\n \"0.6007341\",\n \"0.6002883\",\n \"0.59069574\",\n \"0.5802612\",\n \"0.58015925\",\n \"0.57863915\",\n \"0.57196033\",\n \"0.56676126\",\n \"0.5618402\",\n \"0.5598366\",\n \"0.55523103\",\n \"0.5539704\",\n \"0.55314595\",\n \"0.55285823\",\n \"0.5485978\",\n \"0.5470576\",\n \"0.5457307\",\n \"0.5448995\",\n \"0.54257673\",\n \"0.54072857\",\n \"0.53738904\",\n \"0.5354592\",\n \"0.53531325\",\n \"0.5349846\",\n \"0.5303758\",\n \"0.5300222\",\n \"0.5287609\",\n \"0.52718174\",\n \"0.52675366\",\n \"0.5245243\",\n \"0.5243033\",\n \"0.52310604\",\n \"0.52265894\",\n \"0.5225218\",\n \"0.518193\",\n \"0.5178737\",\n \"0.51780015\",\n \"0.5159622\",\n \"0.5152411\",\n \"0.5147551\",\n \"0.5144985\",\n \"0.5130259\",\n \"0.5127397\",\n \"0.5122522\",\n \"0.51143855\",\n \"0.510587\",\n \"0.5099482\",\n \"0.5095484\",\n \"0.50857234\",\n \"0.50757027\",\n \"0.5060261\",\n \"0.505584\",\n \"0.503325\",\n \"0.50103384\",\n \"0.5008733\",\n \"0.5006176\",\n \"0.50023776\",\n \"0.5001866\",\n \"0.498404\",\n \"0.497895\",\n \"0.49739736\",\n \"0.49595648\",\n \"0.49587652\",\n \"0.49570066\",\n \"0.4954961\",\n \"0.495419\",\n \"0.4944407\",\n \"0.49418512\",\n \"0.49372888\",\n \"0.4935868\",\n \"0.4930735\",\n \"0.4912883\",\n \"0.4903028\",\n \"0.48976886\",\n \"0.48868424\",\n \"0.4886778\",\n \"0.4884284\",\n \"0.48823723\",\n \"0.48763996\",\n \"0.4868318\",\n \"0.48603743\",\n \"0.48592243\",\n \"0.48569736\",\n \"0.4855782\",\n \"0.48547676\",\n \"0.48496\",\n \"0.48491314\",\n \"0.48408782\",\n \"0.4838083\",\n \"0.48303223\",\n \"0.48254657\",\n \"0.48247242\",\n \"0.48207957\",\n \"0.48143074\",\n \"0.4802507\",\n \"0.4802337\",\n \"0.47961685\",\n \"0.4794923\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17089,"cells":{"query":{"kind":"string","value":"Here we are not picky about having duplicate quantities"},"document":{"kind":"string","value":"def add_quantity(self, quantity):\n if quantity.entity_type != 'quantity':\n raise TypeError('Must be quantity type')\n if quantity.link not in self._qm:\n self._qm.add_quantity(quantity)\n assert quantity.link in self._qm\n return self._canonical_q(quantity)"},"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 add_items_quantity_not_duplicates(request):\n all_items_no_duplicates = []\n\n for loop_index, item in enumerate(all_shopping_items(request)):\n item_dict = {\n 'item': item.item,\n 'quantity': item.quantity,\n 'category': item.category.category,\n 'id': item.id,\n 'user': {\n 'username': item.user.first_name\n }\n }\n\n if loop_index == 0:\n all_items_no_duplicates.append(item_dict)\n else:\n item_is_not_a_copy = True\n for list_item in all_items_no_duplicates:\n if list_item['item'] == item.item:\n item_is_not_a_copy = False\n list_item['quantity'] += item.quantity\n list_item['user']['username'] += ' / ' + item.user.first_name\n if item_is_not_a_copy:\n all_items_no_duplicates.append(item_dict)\n\n return all_items_no_duplicates","def get_q(data):\n des_n = re.findall(r'^([Ss]ize )\\d+( size)', data['item_description'])\n name_n = re.findall(r'\\d+', data['name'])\n # import ipdb; ipdb.set_trace()\n if len(des_n) == 1 and len(name_n) == 1:\n if int(des_n[0]) == int(name_n[0]):\n ret_n = int(des_n[0])\n else:\n ret_n = 1\n return ret_n\n\t# pass\n # return pd.concat(qnty_matches).reset_index().drop_duplicates(\n # subset='index', keep='last').set_index('index')","def quantify(self, instances):\n ...","def test_identify_duplicates_3(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"L5\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 1\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 1)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def test_identify_duplicates_4(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 2\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 1)","def test_identify_duplicates_2(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = \"none\"\n ticket1.type = \"replace\"\n ticket1.phage_id = \"none\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = \"none\"\n ticket2.type = \"replace\"\n ticket2.phage_id = \"none\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def test_identify_duplicates_6(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 1\n ticket2.type = \"replace\"\n ticket2.phage_id = \"Trixie\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n with self.subTest():\n self.assertEqual(len(id_dupes), 1)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 1)","def test_identify_duplicates_1(self):\n\n ticket1 = ticket.ImportTicket()\n ticket1.id = 1\n ticket1.type = \"replace\"\n ticket1.phage_id = \"Trixie\"\n\n ticket2 = ticket.ImportTicket()\n ticket2.id = 2\n ticket2.type = \"replace\"\n ticket2.phage_id = \"L5\"\n\n null_set = set([\"none\"])\n list_of_tickets = [ticket1, ticket2]\n id_dupes, phage_id_dupes = \\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\n\n with self.subTest():\n self.assertEqual(len(id_dupes), 0)\n with self.subTest():\n self.assertEqual(len(phage_id_dupes), 0)","def test_best_hits_unique(self):\n records = [h for _, h in self.result.best_hits_by_query(n=5)][0]\n self.assertEqual(len(records), 3)\n values = {tuple(h.values()) for h in records}\n self.assertEqual(len(values), 3)","def Qmeasurement_union(xs):\n Qset = set()\n for x in xs:\n if x is not None:\n Qset |= set(zip(x.Q, x.dQ))\n Q, dQ = [np.array(v) for v in zip(*sorted(Qset))]\n if abs(Q[1:] - Q[:-1]).any() < 1e-14:\n raise ValueError(\"Q values differ by less than 1e-14\")\n return Q, dQ","def duplicates(self, name='identity'):\n qtype = self._get_type(name)\n if qtype in ['array', 'delimited set', 'float']:\n raise TypeError(\"Can not check duplicates for type '{}'.\".format(qtype))\n vals = self._data[name].value_counts()\n vals = vals.copy().dropna()\n if qtype == 'string':\n vals = vals.drop('__NA__')\n vals = vals[vals >= 2].index.tolist()\n if not qtype == 'string':\n vals = [int(i) for i in vals]\n return vals","def get_value_product_unique(self, pos):\n qs = ProductUnique.objects.filter(\n box__box_structure__zone__storage__in=pos.storage_stock.filter(storage_zones__salable=True),\n product_final=self\n )\n return qs","def usefulquantities(dffin):\n dffin['log_length_box'] = np.log(dffin['length_box_um'])\n dffin['time_min']=dffin['time_sec']/60\n dffin['pred_length_box_um'] = np.exp(dffin['pred_log_length'])\n dffin['unique_id'] = dffin['cell']+dffin['time_sec'].apply(lambda x:str(x))\n dffin['cv_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x:\\\n np.std(x)/np.mean(x))\n dffin['std_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.std(x))\n dffin['mean_gr'] = dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\n dffin['mean_len'] = dffin.groupby('cell')['pred_length_box_um'].transform(lambda x: np.mean(x))\n dffin['norm_pred_growth_rate'] = (dffin['pred_growth_rate']-dffin.groupby('cell')['pred_growth_rate'].transform(lambda\\\n x: np.mean(x)))/dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\n dffin = rl.genalogy(dffin,'parent_cell') #Create genealogy\n dffin = rl.genalogy(dffin,'g_parent_cell')\n dffin = rl.genalogy(dffin,'g_g_parent_cell')\n dffin = dffin.set_index('unique_id')\n qq= dffin.groupby('cell').apply(lambda x: (x['pred_length_box_um']-x['pred_length_box_um'].iloc[0])/(x['pred_length_box_um'].iloc[-1]-x['pred_length_box_um'].iloc[0])).rename('add_len')\n jj= dffin.groupby('cell').apply(lambda x: (x['time_sec']-x['time_sec'].iloc[0])/(x['time_sec'].iloc[-1]-x['time_sec'].iloc[0])).rename('cell_cycle')\n return pd.concat([dffin, qq.reset_index().set_index('unique_id')['add_len'], jj.reset_index().set_index('unique_id')['cell_cycle']], axis=1, join='inner')","def _greedy_packing(items: List[Item], cap: int,\n func: Callable) -> Tuple[Set[int], int]:\n items.sort(key=func)\n included = set()\n total_val, total_weight = 0, 0\n for item in items:\n if total_weight + item.weight > cap:\n continue\n included.add(item.idx)\n total_val += item.val\n total_weight += item.weight\n return included, total_val\n # Running time complexity: O(nlog n)","def unique(combo, out):\n # This lets us find only minimally covering payments (you should never add cards to a payment that already\n # satisfies the charge)\n for el in out:\n if set(el).issubset(combo):\n return False\n return True","def quantities_by_good_id(self) -> GoodHoldings:\n assert self._quantities_by_good_id is not None, \"GoodHoldings not set!\"\n return copy.copy(self._quantities_by_good_id)","def test_duplicate_entries(self):","def dupe(q_1: Q) -> Q:\n\n du = Q(\n [q_1.t, q_1.x, q_1.y, q_1.z],\n q_type=q_1.q_type,\n representation=q_1.representation,\n )\n return du","def test_duplicates():\n\n conn = psycopg2.connect(host=\"sculptor.stat.cmu.edu\", database=c.DB_USER,\n user=c.DB_USER, password=c.DB_PASSWORD)\n cur = conn.cursor()\n cur.execute(\"\"\" SELECT COUNT(CONCAT(song_title, ' ', artist_name)) \n FROM songs \"\"\")\n count1 = cur.fetchone()[0]\n cur.execute(\"\"\" SELECT COUNT(DISTINCT CONCAT(song_title, ' ', artist_name))\n FROM songs \"\"\")\n count2 = cur.fetchone()[0]\n assert count1-count2 == 0","def frequentOneItem(self):\n\n candidate = {}\n # global finalPatterns, minSup, Database\n # self.minSup = self.minSup\n for i in range(len(self.Database)):\n for j in range(len(self.Database[i])):\n if self.Database[i][j] not in candidate:\n candidate[self.Database[i][j]] = [i]\n else:\n candidate[self.Database[i][j]] += [i]\n self.finalPatterns = {keys: value for keys, value in candidate.items() if len(value) >= self.minSup}\n #print(candidate)","def quantities_available(quantities):\n available = []\n for q in quantities:\n available.append(quantity_available(q))\n return available","def _generate_native_quantity_list(self):\n\n return set(self._schema).union(self._native_filter_quantities)","def apriori(TDB,supMin):\n \"\"\" subMin is ......... \"\"\"\n dic = dict()\n keys = set()\n for s in TDB:\n for element in s:\n keys.add(frozenset(element))\n keys = list(keys)\n\n while len(keys)>=1:\n dic.clear()\n for key in keys:\n f = getFreq(TDB,key)\n if f >= supMin:\n dic[key]=f\n printItemSet(dic)\n keys = list(dic.keys())\n newKeys = set()\n for i in range (0,len(keys)-1):\n for j in range(i+1,len(keys)):\n newKey = frozenset.union(keys[i],keys[j])\n newKeys.add(newKey)\n keys = newKeys\n return dic","def test_1qubit(self):\n qc = QuantumCircuit(1)\n qc.measure_all()\n qc2 = QuantumCircuit(1)\n qc2.x(0)\n qc2.measure_all()\n\n sampler = Sampler()\n result = sampler.run([qc, qc2]).result()\n self.assertIsInstance(result, SamplerResult)\n self.assertEqual(len(result.quasi_dists), 2)\n self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1})\n self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1})","def similar_qs(self):\n pass","def determine_quantifier(self, rep):\n \n quant1 = rep[0][0]\n quant2 = rep[1][0]\n \n quant = self.quantity_order[max(self.quantity_order.index(quant1), self.quantity_order.index(quant2))]\n\n pol1 = rep[0][1]\n pol2 = rep[1][1]\n \n if pol1 != pol2:\n pol = \"-\"\n else:\n pol = pol1\n \n ## Replace Few with Most...not\n if quant == \"-\" and pol == \"+\":\n quant = \"+\"\n pol = \"-\"\n \n ## Replace Few...not with Most\n if quant == \"-\" and pol == \"-\":\n quant = \"+\"\n pol = \"+\"\n \n return [quant, pol]","def generate_equivalent_quantity(self, base_product, compared_product ,quantity):\n\n\t\tequivalent_quantity = quantity\n\n\t\tbase_history_set = base_product.history_set.all()\n\t\tcompared_history_set = compared_product.history_set.all()\n\n\t\tif base_history_set.count()>0 and compared_history_set.count()>0:\n\t\t\tbase_unit_price = base_history_set[0].unit_price\n\t\t\tbase_price = base_history_set[0].price\n\t\t\tcompared_unit_price = compared_history_set[0].unit_price\n\t\t\tcompared_price = compared_history_set[0].price\n\t\t\tif base_price is not None and base_unit_price is not None and compared_price is not None and compared_unit_price is not None:\n\t\t\t\tbase_unit_measure = base_price/base_unit_price\n\t\t\t\tcompared_unit_measure = compared_price/compared_unit_price\n\n\t\t\t\tequivalent_quantity = self.compute_closest_quantity(quantity, base_unit_measure, compared_unit_measure)\t\n\n\t\treturn equivalent_quantity","def _compute_quantized_subsamples(self):\n self._down_sample()\n self._quantize()","def duplicate(self):\n return Sample(self.solutes, self.quantities, self.volume, self.endless)","def test_duplicate_equality(self):\r\n def duplicate_and_verify(source_usage_key, parent_usage_key):\r\n usage_key = self._duplicate_item(parent_usage_key, source_usage_key)\r\n self.assertTrue(check_equality(source_usage_key, usage_key), \"Duplicated item differs from original\")\r\n\r\n def check_equality(source_usage_key, duplicate_usage_key):\r\n original_item = self.get_item_from_modulestore(source_usage_key, draft=True)\r\n duplicated_item = self.get_item_from_modulestore(duplicate_usage_key, draft=True)\r\n\r\n self.assertNotEqual(\r\n original_item.location,\r\n duplicated_item.location,\r\n \"Location of duplicate should be different from original\"\r\n )\r\n # Set the location and display name to be the same so we can make sure the rest of the duplicate is equal.\r\n duplicated_item.location = original_item.location\r\n duplicated_item.display_name = original_item.display_name\r\n\r\n # Children will also be duplicated, so for the purposes of testing equality, we will set\r\n # the children to the original after recursively checking the children.\r\n if original_item.has_children:\r\n self.assertEqual(\r\n len(original_item.children),\r\n len(duplicated_item.children),\r\n \"Duplicated item differs in number of children\"\r\n )\r\n for i in xrange(len(original_item.children)):\r\n if not check_equality(original_item.children[i], duplicated_item.children[i]):\r\n return False\r\n duplicated_item.children = original_item.children\r\n\r\n return original_item == duplicated_item\r\n\r\n duplicate_and_verify(self.problem_usage_key, self.seq_usage_key)\r\n duplicate_and_verify(self.html_usage_key, self.seq_usage_key)\r\n duplicate_and_verify(self.seq_usage_key, self.chapter_usage_key)\r\n duplicate_and_verify(self.chapter_usage_key, self.usage_key)","def _validate_qty(values: dict):\n\n if not (quantity := values.get('quantity')):\n raise ValueError(\"Quantity attribute is required.\")\n\n if not (symbol := values.get('symbol')):\n raise ValueError(\"Symbol attribute is required.\")\n\n filter = symbol.filters.lot_size_filter\n # if ONE :=1 and not filter.min_qty <= quantity <= filter.max_qty:\n # ValueError(\"The quantity is not in valid range.\")\n\n if filter.step_size and not is_valid_significant_digits(\n quantity,\n symbol.qty_decimal_precision\n ):\n raise ValueError(\"The quantity precision is not valid.\")\n\n return values","def test_excess_quantity(self):\n excess = self._uncertain_demand.excess_stock\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\n variance = [(item - avg_order) for item in self._data_set.values()]\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\n cal_safety = lambda x, y, z: x * y * (z ** 0.5)\n safety_stock = cal_safety(float(self._z_value), float(stdev), float(self._lead_time))\n cal_reorder_level = lambda x, y, z: ((x ** 0.5) * y) + z\n reorder = cal_reorder_level(float(self._lead_time), avg_order, float(safety_stock))\n cal_excess = lambda x, y, z: round(x - (y + (y - z)), 0) if x > y + (y - z) else 0\n test_excess = cal_excess(self._quantity_on_hand, reorder, safety_stock)\n self.assertEqual(int(excess), int(test_excess))","def equal_number_ver(seq):\r\n num_AB, num_AnotB, num_BnotA = 0, 0, 0\r\n for item in seq:\r\n if np.array_equal(item, Quantifier.AB):\r\n num_AB += 1\r\n elif np.array_equal(item, Quantifier.AnotB):\r\n num_AnotB += 1\r\n elif np.array_equal(item, Quantifier.BnotA):\r\n num_BnotA += 1\r\n return Quantifier.T if num_AnotB == num_BnotA else Quantifier.F","def test_gather_success(self):\n gathered_items = self.Quant._gather(self.apple, self.test_stock_location_01)\n # Check the number of apple quants returned is correct\n self.assertEqual(len(gathered_items), 3)\n # Check that the products are all of expected type\n self.assertEqual(gathered_items.product_id, self.apple)\n\n # Unfold the returned quants\n _q1, second_quant, _q2 = gathered_items\n # Check when quant_ids is set in the context\n gathered_items_subset = self.Quant.with_context(quant_ids=[second_quant.id])._gather(\n self.apple, self.test_stock_location_01\n )\n self.assertEqual(len(gathered_items_subset), 1)\n self.assertEqual(gathered_items_subset.product_id, self.apple)\n self.assertEqual(gathered_items_subset, second_quant)","def contains_duplicate_full_slow_set(self, nums: List[int]) -> bool:\n return len(nums) != len(set(nums))","def normalize_quantities(self):\n return (\n pynini.cdrewrite(self.units_map, \"\", \"\", self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.singularize_map, \"1 \", \"\", self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.thousands_map, \"\", self.triple_digits, self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.hundreds_map, \"\", self.double_digits, self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.tens_map, \"\", self.digits, self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.teens_map, \"\", \"\", self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.ones_map, \"\", \"\", self.sigma_star, direction=\"ltr\") *\n pynini.cdrewrite(self.zero_del, \"\", \"\", self.sigma_star, direction=\"ltr\")\n )","def find_duplicates(lst):\n \"*** YOUR CODE HERE ***\"\n return len( set(lst) ) != len(lst)","def _test_sampdup(t):\n return t.shape[1] != len(set(t.ids(axis='sample')))","def unitset_is_consistent(self, other: \"UnitSet\"):\n return all(getattr(self, q) is getattr(other, q) for q in self._base_quantities)","def returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet):\n _itemSet = set()\n localSet = defaultdict(int)\n for item in itemSet:\n for transaction in transactionList:\n if item.issubset(transaction):\n freqSet[item] += 1\n localSet[item] += 1\n for item, count in localSet.items():\n support = float(count)/len(transactionList)\n if support >= minSupport:\n _itemSet.add(item)\n\n return _itemSet","def _reduce_rep(self):\n for k, v in self.items():\n if not k:\n self[k] = 0\n for per1, per2 in pairwise(k):\n if per1 == per2:\n self[k] = 0\n super()._reduce_rep()","def _check_ensembles_are_same_size(p, q):\n if p.npdf != q.npdf:\n raise ValueError(\"Input ensembles should have the same number of distributions\")","def has_quanta(self, quanta_subset):\n\n return all(x in self.q.items()\n for x in quanta_subset.items())","def test_simtk_list_of_quantities_to_pint():\n list_of_quantities = [val * omm_unit.meter for val in range(10)]\n quantity_list = omm_unit.meter * [val for val in range(10)]\n\n assert list_of_quantities != quantity_list\n assert all(simtk_to_pint(list_of_quantities) == simtk_to_pint(quantity_list))","def test_single_quant_assign_correct_quant(self):\n Quant = self.env[\"stock.quant\"]\n\n # Create a bunch of identical quants in the same location\n quants = Quant.browse()\n for i in range(5):\n quants |= self.create_quant(self.apple.id, self.test_stock_location_01.id, 10)\n self.assertEqual(len(quants), 5)\n\n quant = quants[2]\n pick = quant.create_picking(self.picking_type_pick, confirm=True, assign=True)\n self.assertEqual(pick.state, \"assigned\")\n self.assertEqual(quant.reserved_quantity, 10)","def calc_q1(data: list) -> float:\n py = copy.copy(data)\n py.sort()\n return py[round(len(py) / 4)]","def assert_tracking_unique(self, serial_numbers):\n Lot = self.env[\"stock.production.lot\"]\n self.ensure_one()\n if self.tracking != \"none\":\n lots = Lot.search(\n [(\"product_id\", \"=\", self.id), (\"name\", \"in\", serial_numbers)]\n )\n if lots:\n raise ValidationError(\n _(\"%s numbers %s already in use for product %s\")\n % (self.tracking.capitalize(), \" \".join(lots.mapped(\"name\")), self.name)\n )","def _equality_queries(self, field, dist):\n\n query_dicts = []\n for q in xrange(len(self.__queries)):\n query_dicts = []\n for count in xrange(self.__queries[q]['no_queries']*OVER_GENERATION_RATIO):\n self.__count += 1\n logger.info('EQ: Created %d out of %d queries' % (self.__count, self.__total))\n r_lower_cdf = self.__queries[q]['rss_lower_cdf']\n r_upper_cdf = self.__queries[q]['rss_upper_cdf'] \n value = self.__dists[field].generate_pdf(r_lower_cdf, r_upper_cdf, {})\n qid = qids.query_id()\n (value, where) = aqb.EqualityFishingQueryBatch.format_value_and_where(field, value)\n if qid != qids.full_where_has_been_seen(qid,where):\n continue\n query_dicts.append({qs.QRY_ENUM : qs.CAT.EQ, \n qs.QRY_QID : qid,\n qs.QRY_DBNUMRECORDS : self.__db_size,\n qs.QRY_DBRECORDSIZE : self.__row_width, \n qs.QRY_PERF : self.__perf,\n qs.QRY_CAT : self.__cat,\n qs.QRY_SUBCAT : '', \n qs.QRY_WHERECLAUSE : where,\n qs.QRY_FIELD : sv.sql_info[field][0],\n qs.QRY_NEGATE : False,\n qs.QRY_FIELDTYPE : sv.sql_info[field][1],\n qs.QRY_LRSS : self.__queries[q][qs.QRY_LRSS],\n qs.QRY_URSS : self.__queries[q][qs.QRY_URSS],\n qs.QRY_VALUE : value})\n \n self.__bobs.append(aqb.EqualityQueryBatch(query_dicts,count, \n int((count+1)/OVER_GENERATION_RATIO),\n True))","def _all_products(q_1: Q, q_2: Q) -> Dict:\n\n all_dict = _commuting_products(q_1, q_2)\n all_dict.update(_anti_commuting_products(q_1, q_2))\n\n return all_dict","def sum_unique(l):\n pass","def find_quant(trainy, train_tree_node_ID, pred_tree_node_ID, qntl):\n npred = pred_tree_node_ID.shape[0]\n out = np.zeros((npred, qntl.size))*np.nan\n for i in prange(pred_tree_node_ID.shape[0]):\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\n sample = trainy[idxs]\n out[i, :] = np.quantile(sample, qntl)\n return out","def _is_duplicate (asin, current_list):\n\n dup = False\n for m in current_list:\n try:\n if unicode(asin) == m['sku']:\n dup = True\n break\n except KeyError:\n pass\n return dup","def quantilize(v, n_quantile=5, return_summary=False, fallback_to_unique=True):\n\n v = np.array(v)\n\n if fallback_to_unique:\n x, ix = uniquetol(v, return_inverse=True)\n \n if (not fallback_to_unique) or len(x) > n_quantile:\n n = v.size\n ix = np.int32(np.ceil((stats.rankdata(v, method='ordinal') + 0.) \\\n / n * n_quantile) - 1)\n \n if return_summary:\n x = npg.aggregate(ix, v, func='mean')\n return ix, x\n else: \n return ix","def distr(self,X):\r\n return {x:X.count(x) for x in set(X)}","def test_single_identical_bid(self):\n bids = [Cost(ITEM1, ACTOR1, 1640),\n Cost(ITEM2, ACTOR1, 1540),\n Cost(ITEM3, ACTOR1, 1140),\n Cost(ITEM4, ACTOR1, 1640),\n Cost(ITEM5, ACTOR1, 1740),\n Cost(ITEM1, ACTOR2, 1540),\n Cost(ITEM2, ACTOR2, 1240),\n Cost(ITEM3, ACTOR2, 1340),\n Cost(ITEM4, ACTOR2, 1640),\n Cost(ITEM5, ACTOR2, 1940),\n Cost(ITEM1, ACTOR3, 1740),\n Cost(ITEM2, ACTOR3, 1540),\n Cost(ITEM3, ACTOR3, 1040),\n Cost(ITEM4, ACTOR3, 1640),\n Cost(ITEM5, ACTOR3, 1740),\n Cost(ITEM1, ACTOR4, 1440),\n Cost(ITEM2, ACTOR4, 1640),\n Cost(ITEM3, ACTOR4, 1240),\n Cost(ITEM4, ACTOR4, 1640),\n Cost(ITEM5, ACTOR4, 1740),\n Cost(ITEM1, ACTOR5, 1640),\n Cost(ITEM2, ACTOR5, 1640),\n Cost(ITEM3, ACTOR5, 1140),\n Cost(ITEM4, ACTOR5, 1640),\n Cost(ITEM5, ACTOR5, 1640)]\n result = self.splitter.split(ITEMS[:5], ACTORS[:5], bids)\n expected = [(ITEM1, ACTOR3, None),\n (ITEM2, ACTOR5, None),\n (ITEM3, ACTOR4, None),\n (ITEM4, ACTOR1, None),\n (ITEM5, ACTOR2, None)]\n item_assignments_present(self, result, expected)","def gen_all_holds(hand):\n ans_set = set([()])\n\n for dummy_idx in range(len(hand)):\n temp_set = set([()])\n for seq in ans_set:\n for item in hand:\n new_seq = list(seq)\n if hand.count(item) > new_seq.count(item):\n new_seq.append(item)\n new_seq = sorted(new_seq)\n temp_set.add(tuple(new_seq))\n ans_set = temp_set\n return ans_set","def duplicates(items):\n duplicate_items = set()\n for item in items:\n if items.count(item) > 1:\n duplicate_items.add(item)\n duplicate_list = list(duplicate_items)\n\n\n return sorted(duplicate_list)","def is_real_dupe(dupe_lst):\n if len(dupe_lst) >= 10:\n return True\n first_composer = dupe_lst[0]['composer']\n\n if len(dupe_lst) > 2:\n for d in dupe_lst:\n if d['composer'] != first_composer:\n return True\n return False","def test_multiple_without_IS(self):\n df = self.mdf\n fixed_record_idx = 0\n for renorm in [True, False]:\n with self.subTest(renorm=renorm):\n out = standardise_aggregate(\n df, renorm=renorm, fixed_record_idx=fixed_record_idx\n )\n if not renorm:\n self.assertTrue(\n np.isclose(\n out.values, df.iloc[fixed_record_idx, :].values\n ).any()\n )","def large_order(order):\n distinct_items = {item.product for item in order.cart}\n if len(distinct_items) >= 10:\n return order.total() * .07\n return 0","def pull_out_quantifications_across_negation(formula: Formula) -> \\\r\n Tuple[Formula, Proof]:\r\n assert is_unary(formula.root)\r\n # Task 11.6\r\n\r\n prover = Prover(Prover.AXIOMS.union(ADDITIONAL_QUANTIFICATION_AXIOMS))\r\n\r\n # Basic Case - No quantifier to change\r\n if not is_quantifier(formula.first.root):\r\n ccl = equivalence_of(formula, formula)\r\n prover.add_tautology(ccl)\r\n return formula, prover.qed()\r\n\r\n # The ~ and the predicate without the quantifier to keep changing it\r\n form = Formula(\"~\", formula.first.predicate)\r\n pred, proof = pull_out_quantifications_across_negation(form)\r\n\r\n # Definig the new quantifier\r\n if formula.first.root == \"A\":\r\n my_quantifier = \"E\"\r\n else: # \"E\"\r\n my_quantifier = \"A\"\r\n\r\n # proof for changing quantifier\r\n # because add_proof() is my friend\r\n step1 = prover.add_proof(proof.conclusion, proof)\r\n\r\n\r\n form2 = Formula(\"->\", proof.conclusion, equivalence_of(Formula(my_quantifier, formula.first.variable, form),\r\n Formula(my_quantifier, formula.first.variable, pred)))\r\n my_map2 = {'R': str(form.substitute({formula.first.variable: Term(\"_\")})),\r\n 'Q': str(pred.substitute({formula.first.variable: Term(\"_\")})), \"x\": formula.first.variable, \"y\": formula.first.variable}\r\n\r\n step2 = prover.add_instantiated_assumption(form2,\r\n ADDITIONAL_QUANTIFICATION_AXIOMS[14 if my_quantifier==\"A\" else 15], my_map2)\r\n\r\n step3 = prover.add_mp(equivalence_of(Formula(my_quantifier, formula.first.variable, form),\r\n Formula(my_quantifier, formula.first.variable, pred)), step1, step2)\r\n\r\n\r\n my_map4 = {'R': str(formula.first.predicate.substitute({formula.first.variable: Term(\"_\")})), \"x\": formula.first.variable}\r\n form4 = equivalence_of(formula, Formula(my_quantifier, formula.first.variable, form))\r\n step4 = prover.add_instantiated_assumption(form4,\r\n ADDITIONAL_QUANTIFICATION_AXIOMS[0 if my_quantifier==\"E\" else 1], my_map4)\r\n\r\n prover.add_tautological_implication(equivalence_of(formula, Formula(my_quantifier, formula.first.variable, pred)), [step3, step4])\r\n\r\n return Formula(my_quantifier, formula.first.variable, pred), prover.qed()","def dupable_matches_required(self):\n return 2","def Get_dup_records(ds,key_var):\n temp = ds.groupby([key_var]).agg({key_var:'count'}).rename(columns={key_var:'Freq'}).reset_index()\n temp = temp[temp['Freq']>1]\n print(\"Total Duplicate records:: \" +str(temp.shape[0]))\n\n return temp","def testDuplicate(self,permutations=True):\n # This algorithm is faster than encode,\n # but for nplex=2 enmagic2 would probably still be faster.\n if permutations:\n C = self.copy()\n C.sort(axis=1)\n else:\n C = self\n ind = sortByColumns(C)\n C = C.take(ind,axis=0)\n ok = (C != roll(C,1,axis=0)).any(axis=1)\n if not ok[0]: # all duplicates -> should result in one unique element\n ok[0] = True\n return ind,ok","def Deduplicate(items):\n seen = set()\n for it in items:\n if it not in seen:\n seen.add(it)\n yield it","def test_select_grouping_quantitative_no_grouping(self):\n\n dimension = models.QuantitativeDimension(\n key='shares',\n name='Count of shares',\n description='Count of shares',\n field_name='shared_count',\n )\n\n queryset = mock.Mock()\n\n result, internal_key = dimension.select_grouping_expression(queryset, dimension.field_name)\n\n # It should't need a different internal key in this simple case\n self.assertEquals(internal_key, dimension.field_name)\n self.assertEquals(result, queryset)","def fracSeen(data):\n itemSet = set()\n numSeen = []\n for x in data:\n itemSet.add(x)\n numSeen.append(len(itemSet))\n\n fracSeen = [x/numSeen[-1] for x in numSeen]\n return fracSeen","def no_ver(seq):\r\n for item in seq:\r\n if np.array_equal(item, Quantifier.AB):\r\n return Quantifier.F\r\n return Quantifier.T","def notall_ver(seq):\r\n for item in seq:\r\n if np.array_equal(item, Quantifier.AnotB):\r\n return Quantifier.T\r\n return Quantifier.F","def transform(self):\n\n transactions = self._get_transactions(self._x_transformed)\n self.frequent_items = [set(item) for item in find_frequent_itemsets(\n transactions, minimum_support=self.support_min) if len(item) > 1]\n return self.frequent_items","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def getItemsWithMinSupp(self, transListSet, itemSet, freqSet, minSupp):\n itemSet_ = set()\n localSet_ = defaultdict(int)\n for item in itemSet:\n freqSet[item] += sum([1 for trans in transListSet if item.issubset(trans)])\n localSet_[item] += sum([1 for trans in transListSet if item.issubset(trans)])\n \n # Only conserve frequent item-set \n n = len(transListSet)\n for item, cnt in localSet_.items():\n itemSet_.add(item) if float(cnt)/n >= minSupp else None\n \n return itemSet_","def test_phonebook_with_duplicate_entries_is_inconsostent(self):\n self.phonebook.add(\"Bob\", \"12345\")\n self.phonebook.add(\"Mary\", \"12345\")\n self.assertFalse(self.phonebook.is_consistent())","def similarparts(imagparts):\n dupl = []\n global opt\n l = len(imagparts[0])-1\n \n for i in range(len(imagparts)-1): \n difs = sum(abs(x-y) for x,y in zip(imagparts[i][:l],imagparts[i+1][:l]))\n mean = float(sum(imagparts[i][:l])) / l\n dev = float(sum(abs(mean-val) for val in imagparts[i][:l])) / l\n if dev/mean >= float(opt.blcoldev):\n if difs <= int(opt.blsim):\n if imagparts[i] not in dupl:\n dupl.append(imagparts[i])\n if imagparts[i+1] not in dupl:\n dupl.append(imagparts[i+1])\n\n return dupl","def _search_for_quantity_in_price_level(self, tick_entry, quantity_to_trade, order):\n if tick_entry is None: # Last tick\n return quantity_to_trade, []\n\n if tick_entry.quantity <= Quantity(0):\n return quantity_to_trade, []\n\n # Check if order and tick entry have the same trader id / origin\n if order.order_id.trader_id == tick_entry.order_id.trader_id:\n return quantity_to_trade, []\n\n assert isinstance(tick_entry, TickEntry), type(tick_entry)\n assert isinstance(quantity_to_trade, Quantity), type(quantity_to_trade)\n assert isinstance(order, Order), type(order)\n\n if tick_entry.order_id in order.reserved_ticks: # Tick is already reserved for this order\n return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)\n\n if not tick_entry.is_valid(): # Tick is time out or reserved\n return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)\n\n if quantity_to_trade <= tick_entry.quantity: # All the quantity can be matched in this tick\n quantity_to_trade, proposed_trades = self._search_for_quantity_in_price_level_total(tick_entry,\n quantity_to_trade,\n order)\n else: # Not all the quantity can be matched in this tick\n quantity_to_trade, proposed_trades = self._search_for_quantity_in_price_level_partial(tick_entry,\n quantity_to_trade,\n order)\n\n return quantity_to_trade, proposed_trades","def test_exclusive(self):\n s = djset()\n s.add([1, 2, 3])\n s.add([4, 5, 6])\n self.assertEquals({1, 2, 3}, s.data[1])\n self.assertEquals({4, 5, 6}, s.data[4])","def item_duplicate():\n return {'name':'chair',\n 'value':300}","def returnItemsWithMinSupport(itemSet, transactionList, timestampList, itemTimestampIndexDict, dateStampSet, minSupport, freqSet, tidToGranularityTid, granularityTimestampList):\n _itemSet = set()\n localSet = defaultdict(int)\n\n print \"# Candidates: \" + str(len(itemSet))\n\n for itemIdx, item in enumerate(itemSet):\n # print \"ITEM: \" + str(item)\n # print \"# ELEMENTS: \" + str(len(item))\n tsSet = set()\n for i, element in enumerate(item):\n elementTsSet = itemTimestampIndexDict[element] # Count element in same time\n # print \"hi\" + str(elementTsSet)\n elementTsSet = set([tidToGranularityTid[ts] for ts in elementTsSet]) # Count element in same granularity\n # print \">>\" + str(elementTsSet)\n if i == 0:\n tsSet = elementTsSet\n else:\n tsSet = tsSet & elementTsSet\n\n # print \"# ts: \" + str(len(tsSet))\n \"\"\" Count days occuring item as support value \"\"\"\n timestamp_set = set()\n # print tsSet\n for ts in tsSet:\n # timestamp = timestampList[ts]\n # timestamp = dt.datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d')\n timestamp = granularityTimestampList[ts].strftime('%Y-%m-%d')\n if timestamp not in timestamp_set:\n timestamp_set.add(timestamp)\n freqSet[item] += 1\n localSet[item] += 1\n\n for item, count in localSet.items():\n # support = float(count)/len(transactionList)\n support = float(count) / len(dateStampSet)\n if support >= minSupport:\n # print item\n # print support\n _itemSet.add(item)\n\n return _itemSet","def execQ8():\n frame = pan.DataFrame(data, columns=['Product', 'Price', 'Period'])\n filtered_frame = frame.sort_values(by='Price', ascending=False).drop_duplicates('Product').head(10)\n return filtered_frame","def is_satisfied(self, item: Product) -> bool:\n return item.size == self.size","def adduniq(self, item, issue):\n if self.has_key(item):\n if issue in self[item]:\n return 0\n self.add(item, issue)\n return 1","def find_same_amount(df):\n ids = list(df['id'][df.duplicated(['amount','branch_id','exchange_id'],keep= False)==True].values)\n return ids","def test_group_by_empty(self):\n\n class TestQuantDimension(models.QuantitativeDimension):\n \"\"\"A quant dimension that returns no grouping expression\"\"\"\n def __init__(self, *args, **kwargs):\n super(TestQuantDimension, self).__init__(*args, **kwargs)\n self._get_grouping_expression_calls = 0\n\n def get_grouping_expression(self, queryset, bins=None, bin_size=None, **kwargs):\n self._get_grouping_expression_calls += 1\n return None\n\n dimension = TestQuantDimension(\n key='shares',\n name='Count of shares',\n description='Count of shares',\n field_name='shared_count',\n )\n\n queryset = mock.Mock()\n expected_result = queryset.values.return_value\n\n result = dimension.group_by(queryset)\n\n self.assertEquals(result, expected_result)\n queryset.values.assert_called_once_with()\n self.assertEquals(dimension._get_grouping_expression_calls, 1)","def _anti_commuting_products(q_1: Q, q_2: Q) -> Dict:\n\n s_x, s_y, s_z = q_1.x, q_1.y, q_1.z\n q_2_x, q_2_y, q_2_z = q_2.x, q_2.y, q_2.z\n\n dif_dict = {\n \"yz-zy\": s_y * q_2_z - s_z * q_2_y,\n \"zx-xz\": s_z * q_2_x - s_x * q_2_z,\n \"xy-yx\": s_x * q_2_y - s_y * q_2_x,\n \"zy-yz\": -s_y * q_2_z + s_z * q_2_y,\n \"xz-zx\": -s_z * q_2_x + s_x * q_2_z,\n \"yx-xy\": -s_x * q_2_y + s_y * q_2_x,\n }\n\n return dif_dict","def test_get_similar_objects_weights(self): # pylint: disable=invalid-name\n similar_objects = Assessment.get_similar_objects_query(\n id_=self.assessment.id,\n types=[\"Assessment\"],\n threshold=0, # to include low weights too\n ).all()\n\n # casting to int from Decimal to prettify the assertion method output\n id_weight_map = {obj.id: int(obj.weight) for obj in similar_objects}\n\n self.assertDictEqual(id_weight_map, self.id_weight_map)","def discrepancy(self):\n result = 0\n for focal, value in self.items():\n if focal.cardinal > 0:\n result -= value * math.log(self.betP(focal), 2)\n return round(result, 6)","def get_stocks_tested_by_number_of_replicates(\n self, screen_type, screen_stage, number_of_replicates):\n annotated = (\n self.get_experiments_by_screen(screen_type, screen_stage)\n .order_by('library_stock')\n .values('library_stock')\n .annotate(models.Count('id')))\n\n singles_pks = [x['library_stock'] for x in annotated\n if x['id__count'] == number_of_replicates]\n\n singles = LibraryStock.objects.filter(pk__in=singles_pks)\n\n return set(singles)","def _quant_unimplemented(self, *input: Any) -> None:\n raise NotImplementedError","def sum_n(k, lst):\n seen = set()\n for num in lst:\n if k - num in seen:\n return True\n seen.add(num)\n return False","def req_items_for_store(inventory_store_id, quantity_type):\r\n \r\n req_items = db( ( db.logs_req.inventory_store_id == inventory_store_id ) & \\\r\n ( db.logs_req.id == db.logs_req_item.logs_req_id) & \\\r\n ( db.logs_req_item.item_packet_id == db.logs_req_item.item_packet_id) & \\\r\n ( db.logs_req_item[\"quantity_%s\" % quantity_type] < db.logs_req_item.quantity) & \\\r\n ( db.logs_req_item.deleted == False ) \r\n ).select(db.logs_req_item.id,\r\n db.logs_req_item.logs_req_id,\r\n db.logs_req_item.item_id,\r\n db.logs_req_item.quantity,\r\n db.logs_req_item[\"quantity_%s\" % quantity_type],\r\n db.logs_req_item.item_packet_id,\r\n orderby = db.logs_req.date_required | db.logs_req.date, \r\n #groupby = db.logs_req_item.item_id\r\n ) \r\n \r\n # Because groupby doesn't follow the orderby remove any duplicate req_item \r\n # req_items = req_items.as_dict( key = \"logs_req_item.item_id\") <- doensn't work \r\n # @todo: Rows.as_dict function could be extended to enable this functionality instead \r\n req_item_ids = []\r\n unique_req_items = Storage()\r\n for req_item in req_items:\r\n if req_item.item_id not in req_item_ids:\r\n #This item is not already in the dict \r\n unique_req_items[req_item.item_id] = Storage( req_item.as_dict() )\r\n req_item_ids.append(req_item.item_id) \r\n \r\n return unique_req_items","def is_duplicate(self, **kwargs):\n return len(list(self.c.select(**kwargs))) > 0","def apriori_v3(q, insig, sex_file_dict, countries_list, age):\r\n\r\n q = [[int(num)] for num in q] # queue is formatted as a nested list\r\n insignificant = [[int(num)] for num in insig]\r\n significant = []\r\n\r\n #print(\"\\nInsig\", insignificant)\r\n #print(\"Sig\", significant)\r\n #print(\"Queue\\n\", q)\r\n\r\n while len(q) > 0:\r\n element = q[0]\r\n obs_freqs = []\r\n\r\n for country in countries_list:\r\n icd_freq = 0\r\n for freq in element:\r\n icd_freq += round(float(sex_file_dict[country][age][str(freq)]) * 1000000)\r\n obs_freqs.append(icd_freq)\r\n\r\n chisq, pvalue = chisquare(obs_freqs)\r\n\r\n if pvalue >= 0.01:\r\n significant.append(element)\r\n\r\n for i in range(int(element[-1])+1,36):\r\n if [i] not in insignificant:\r\n tentativeCandidate = sorted(list(element)+[i]) # add the two lists together (element is a list)\r\n if tentativeCandidate not in q and tentativeCandidate not in significant: # then add it to the queue\r\n\r\n q.append(tentativeCandidate)\r\n q.pop(0) #remove it from the queue after we have created/tried all the tentativeCandidates\r\n\r\n else: # when the p-value not significant\r\n q.pop(0)\r\n insignificant.append(element)\r\n return significant # grab the last values before breaking out of the while loop\r","def required_native_quantities(self):\n return set(self._translate_quantities(self.list_all_quantities()))","def _check_duplicates(self):\n # check variables\n counter = Counter(self.variables())\n duplicates = [key for key, value in counter.items() if value > 1]\n if duplicates != []:\n raise DuplicateVariables(duplicates)\n\n # check parameters\n counter = Counter(self.parameters())\n duplicates = [key for key, value in counter.items() if value > 1]\n if duplicates != []:\n raise DuplicateParameters(duplicates)","def test_array_return_type_reduction_group_by(t, df):\n expr = t.group_by(t.key).aggregate(quantiles_col=collect(t.b))\n result = expr.execute()\n\n df = df.compute() # Convert to Pandas\n expected_col = df.groupby(df.key).b.agg(lambda s: s.tolist())\n expected = pd.DataFrame({\"quantiles_col\": expected_col}).reset_index()\n\n tm.assert_frame_equal(\n result.sort_values(\"key\").reset_index(drop=True),\n expected.sort_values(\"key\").reset_index(drop=True),\n )","def M_ver(seq):\r\n num_AB = 0\r\n num_AnotB = 0\r\n num_BnotA = 0\r\n for item in seq:\r\n if np.array_equal(item, Quantifier.AB):\r\n num_AB += 1\r\n if np.array_equal(item, Quantifier.AnotB):\r\n num_AnotB += 1\r\n if np.array_equal(item, Quantifier.BnotA):\r\n num_BnotA += 1\r\n return (Quantifier.T if num_AB + num_AnotB > num_AB + num_BnotA\r\n else Quantifier.F)","def all_ver(seq):\r\n for item in seq:\r\n if np.array_equal(item, Quantifier.AnotB):\r\n return Quantifier.F\r\n return Quantifier.T","def __listsubseteq(self, c1, c2):\n s2 = {}\n for delta in c2:\n s2[delta] = 1\n\n for delta in c1:\n if not s2.has_key(delta):\n return 0\n\n return 1","def large_order_promo(order: Order):\n distinct_items = {item.product for item in order.cart}\n if len(distinct_items) >= 10:\n return order.total() * 0.07\n return 0","def execQ7():\n frame = pan.DataFrame(data, columns=['Product', 'Price', 'Period'])\n filtered_frame = frame.sort_values(by='Price', ascending=True).drop_duplicates(subset='Product').head(10)\n return filtered_frame","def remove_duplicates(data):\n already_used_items = {}\n return_data = []\n\n for item in data:\n # Yes, I know that I can find used items in the return_data,\n # but HW requires this logic.\n if not already_used_items.get(item):\n return_data.append(item)\n already_used_items[item] = True\n\n return return_data"],"string":"[\n \"def add_items_quantity_not_duplicates(request):\\n all_items_no_duplicates = []\\n\\n for loop_index, item in enumerate(all_shopping_items(request)):\\n item_dict = {\\n 'item': item.item,\\n 'quantity': item.quantity,\\n 'category': item.category.category,\\n 'id': item.id,\\n 'user': {\\n 'username': item.user.first_name\\n }\\n }\\n\\n if loop_index == 0:\\n all_items_no_duplicates.append(item_dict)\\n else:\\n item_is_not_a_copy = True\\n for list_item in all_items_no_duplicates:\\n if list_item['item'] == item.item:\\n item_is_not_a_copy = False\\n list_item['quantity'] += item.quantity\\n list_item['user']['username'] += ' / ' + item.user.first_name\\n if item_is_not_a_copy:\\n all_items_no_duplicates.append(item_dict)\\n\\n return all_items_no_duplicates\",\n \"def get_q(data):\\n des_n = re.findall(r'^([Ss]ize )\\\\d+( size)', data['item_description'])\\n name_n = re.findall(r'\\\\d+', data['name'])\\n # import ipdb; ipdb.set_trace()\\n if len(des_n) == 1 and len(name_n) == 1:\\n if int(des_n[0]) == int(name_n[0]):\\n ret_n = int(des_n[0])\\n else:\\n ret_n = 1\\n return ret_n\\n\\t# pass\\n # return pd.concat(qnty_matches).reset_index().drop_duplicates(\\n # subset='index', keep='last').set_index('index')\",\n \"def quantify(self, instances):\\n ...\",\n \"def test_identify_duplicates_3(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"L5\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 1\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 1)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def test_identify_duplicates_4(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 2\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 1)\",\n \"def test_identify_duplicates_2(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = \\\"none\\\"\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"none\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = \\\"none\\\"\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"none\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def test_identify_duplicates_6(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 1\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"Trixie\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 1)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 1)\",\n \"def test_identify_duplicates_1(self):\\n\\n ticket1 = ticket.ImportTicket()\\n ticket1.id = 1\\n ticket1.type = \\\"replace\\\"\\n ticket1.phage_id = \\\"Trixie\\\"\\n\\n ticket2 = ticket.ImportTicket()\\n ticket2.id = 2\\n ticket2.type = \\\"replace\\\"\\n ticket2.phage_id = \\\"L5\\\"\\n\\n null_set = set([\\\"none\\\"])\\n list_of_tickets = [ticket1, ticket2]\\n id_dupes, phage_id_dupes = \\\\\\n tickets.identify_duplicates(list_of_tickets, null_set=null_set)\\n\\n with self.subTest():\\n self.assertEqual(len(id_dupes), 0)\\n with self.subTest():\\n self.assertEqual(len(phage_id_dupes), 0)\",\n \"def test_best_hits_unique(self):\\n records = [h for _, h in self.result.best_hits_by_query(n=5)][0]\\n self.assertEqual(len(records), 3)\\n values = {tuple(h.values()) for h in records}\\n self.assertEqual(len(values), 3)\",\n \"def Qmeasurement_union(xs):\\n Qset = set()\\n for x in xs:\\n if x is not None:\\n Qset |= set(zip(x.Q, x.dQ))\\n Q, dQ = [np.array(v) for v in zip(*sorted(Qset))]\\n if abs(Q[1:] - Q[:-1]).any() < 1e-14:\\n raise ValueError(\\\"Q values differ by less than 1e-14\\\")\\n return Q, dQ\",\n \"def duplicates(self, name='identity'):\\n qtype = self._get_type(name)\\n if qtype in ['array', 'delimited set', 'float']:\\n raise TypeError(\\\"Can not check duplicates for type '{}'.\\\".format(qtype))\\n vals = self._data[name].value_counts()\\n vals = vals.copy().dropna()\\n if qtype == 'string':\\n vals = vals.drop('__NA__')\\n vals = vals[vals >= 2].index.tolist()\\n if not qtype == 'string':\\n vals = [int(i) for i in vals]\\n return vals\",\n \"def get_value_product_unique(self, pos):\\n qs = ProductUnique.objects.filter(\\n box__box_structure__zone__storage__in=pos.storage_stock.filter(storage_zones__salable=True),\\n product_final=self\\n )\\n return qs\",\n \"def usefulquantities(dffin):\\n dffin['log_length_box'] = np.log(dffin['length_box_um'])\\n dffin['time_min']=dffin['time_sec']/60\\n dffin['pred_length_box_um'] = np.exp(dffin['pred_log_length'])\\n dffin['unique_id'] = dffin['cell']+dffin['time_sec'].apply(lambda x:str(x))\\n dffin['cv_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x:\\\\\\n np.std(x)/np.mean(x))\\n dffin['std_gr']= dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.std(x))\\n dffin['mean_gr'] = dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\\n dffin['mean_len'] = dffin.groupby('cell')['pred_length_box_um'].transform(lambda x: np.mean(x))\\n dffin['norm_pred_growth_rate'] = (dffin['pred_growth_rate']-dffin.groupby('cell')['pred_growth_rate'].transform(lambda\\\\\\n x: np.mean(x)))/dffin.groupby('cell')['pred_growth_rate'].transform(lambda x: np.mean(x))\\n dffin = rl.genalogy(dffin,'parent_cell') #Create genealogy\\n dffin = rl.genalogy(dffin,'g_parent_cell')\\n dffin = rl.genalogy(dffin,'g_g_parent_cell')\\n dffin = dffin.set_index('unique_id')\\n qq= dffin.groupby('cell').apply(lambda x: (x['pred_length_box_um']-x['pred_length_box_um'].iloc[0])/(x['pred_length_box_um'].iloc[-1]-x['pred_length_box_um'].iloc[0])).rename('add_len')\\n jj= dffin.groupby('cell').apply(lambda x: (x['time_sec']-x['time_sec'].iloc[0])/(x['time_sec'].iloc[-1]-x['time_sec'].iloc[0])).rename('cell_cycle')\\n return pd.concat([dffin, qq.reset_index().set_index('unique_id')['add_len'], jj.reset_index().set_index('unique_id')['cell_cycle']], axis=1, join='inner')\",\n \"def _greedy_packing(items: List[Item], cap: int,\\n func: Callable) -> Tuple[Set[int], int]:\\n items.sort(key=func)\\n included = set()\\n total_val, total_weight = 0, 0\\n for item in items:\\n if total_weight + item.weight > cap:\\n continue\\n included.add(item.idx)\\n total_val += item.val\\n total_weight += item.weight\\n return included, total_val\\n # Running time complexity: O(nlog n)\",\n \"def unique(combo, out):\\n # This lets us find only minimally covering payments (you should never add cards to a payment that already\\n # satisfies the charge)\\n for el in out:\\n if set(el).issubset(combo):\\n return False\\n return True\",\n \"def quantities_by_good_id(self) -> GoodHoldings:\\n assert self._quantities_by_good_id is not None, \\\"GoodHoldings not set!\\\"\\n return copy.copy(self._quantities_by_good_id)\",\n \"def test_duplicate_entries(self):\",\n \"def dupe(q_1: Q) -> Q:\\n\\n du = Q(\\n [q_1.t, q_1.x, q_1.y, q_1.z],\\n q_type=q_1.q_type,\\n representation=q_1.representation,\\n )\\n return du\",\n \"def test_duplicates():\\n\\n conn = psycopg2.connect(host=\\\"sculptor.stat.cmu.edu\\\", database=c.DB_USER,\\n user=c.DB_USER, password=c.DB_PASSWORD)\\n cur = conn.cursor()\\n cur.execute(\\\"\\\"\\\" SELECT COUNT(CONCAT(song_title, ' ', artist_name)) \\n FROM songs \\\"\\\"\\\")\\n count1 = cur.fetchone()[0]\\n cur.execute(\\\"\\\"\\\" SELECT COUNT(DISTINCT CONCAT(song_title, ' ', artist_name))\\n FROM songs \\\"\\\"\\\")\\n count2 = cur.fetchone()[0]\\n assert count1-count2 == 0\",\n \"def frequentOneItem(self):\\n\\n candidate = {}\\n # global finalPatterns, minSup, Database\\n # self.minSup = self.minSup\\n for i in range(len(self.Database)):\\n for j in range(len(self.Database[i])):\\n if self.Database[i][j] not in candidate:\\n candidate[self.Database[i][j]] = [i]\\n else:\\n candidate[self.Database[i][j]] += [i]\\n self.finalPatterns = {keys: value for keys, value in candidate.items() if len(value) >= self.minSup}\\n #print(candidate)\",\n \"def quantities_available(quantities):\\n available = []\\n for q in quantities:\\n available.append(quantity_available(q))\\n return available\",\n \"def _generate_native_quantity_list(self):\\n\\n return set(self._schema).union(self._native_filter_quantities)\",\n \"def apriori(TDB,supMin):\\n \\\"\\\"\\\" subMin is ......... \\\"\\\"\\\"\\n dic = dict()\\n keys = set()\\n for s in TDB:\\n for element in s:\\n keys.add(frozenset(element))\\n keys = list(keys)\\n\\n while len(keys)>=1:\\n dic.clear()\\n for key in keys:\\n f = getFreq(TDB,key)\\n if f >= supMin:\\n dic[key]=f\\n printItemSet(dic)\\n keys = list(dic.keys())\\n newKeys = set()\\n for i in range (0,len(keys)-1):\\n for j in range(i+1,len(keys)):\\n newKey = frozenset.union(keys[i],keys[j])\\n newKeys.add(newKey)\\n keys = newKeys\\n return dic\",\n \"def test_1qubit(self):\\n qc = QuantumCircuit(1)\\n qc.measure_all()\\n qc2 = QuantumCircuit(1)\\n qc2.x(0)\\n qc2.measure_all()\\n\\n sampler = Sampler()\\n result = sampler.run([qc, qc2]).result()\\n self.assertIsInstance(result, SamplerResult)\\n self.assertEqual(len(result.quasi_dists), 2)\\n self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1})\\n self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1})\",\n \"def similar_qs(self):\\n pass\",\n \"def determine_quantifier(self, rep):\\n \\n quant1 = rep[0][0]\\n quant2 = rep[1][0]\\n \\n quant = self.quantity_order[max(self.quantity_order.index(quant1), self.quantity_order.index(quant2))]\\n\\n pol1 = rep[0][1]\\n pol2 = rep[1][1]\\n \\n if pol1 != pol2:\\n pol = \\\"-\\\"\\n else:\\n pol = pol1\\n \\n ## Replace Few with Most...not\\n if quant == \\\"-\\\" and pol == \\\"+\\\":\\n quant = \\\"+\\\"\\n pol = \\\"-\\\"\\n \\n ## Replace Few...not with Most\\n if quant == \\\"-\\\" and pol == \\\"-\\\":\\n quant = \\\"+\\\"\\n pol = \\\"+\\\"\\n \\n return [quant, pol]\",\n \"def generate_equivalent_quantity(self, base_product, compared_product ,quantity):\\n\\n\\t\\tequivalent_quantity = quantity\\n\\n\\t\\tbase_history_set = base_product.history_set.all()\\n\\t\\tcompared_history_set = compared_product.history_set.all()\\n\\n\\t\\tif base_history_set.count()>0 and compared_history_set.count()>0:\\n\\t\\t\\tbase_unit_price = base_history_set[0].unit_price\\n\\t\\t\\tbase_price = base_history_set[0].price\\n\\t\\t\\tcompared_unit_price = compared_history_set[0].unit_price\\n\\t\\t\\tcompared_price = compared_history_set[0].price\\n\\t\\t\\tif base_price is not None and base_unit_price is not None and compared_price is not None and compared_unit_price is not None:\\n\\t\\t\\t\\tbase_unit_measure = base_price/base_unit_price\\n\\t\\t\\t\\tcompared_unit_measure = compared_price/compared_unit_price\\n\\n\\t\\t\\t\\tequivalent_quantity = self.compute_closest_quantity(quantity, base_unit_measure, compared_unit_measure)\\t\\n\\n\\t\\treturn equivalent_quantity\",\n \"def _compute_quantized_subsamples(self):\\n self._down_sample()\\n self._quantize()\",\n \"def duplicate(self):\\n return Sample(self.solutes, self.quantities, self.volume, self.endless)\",\n \"def test_duplicate_equality(self):\\r\\n def duplicate_and_verify(source_usage_key, parent_usage_key):\\r\\n usage_key = self._duplicate_item(parent_usage_key, source_usage_key)\\r\\n self.assertTrue(check_equality(source_usage_key, usage_key), \\\"Duplicated item differs from original\\\")\\r\\n\\r\\n def check_equality(source_usage_key, duplicate_usage_key):\\r\\n original_item = self.get_item_from_modulestore(source_usage_key, draft=True)\\r\\n duplicated_item = self.get_item_from_modulestore(duplicate_usage_key, draft=True)\\r\\n\\r\\n self.assertNotEqual(\\r\\n original_item.location,\\r\\n duplicated_item.location,\\r\\n \\\"Location of duplicate should be different from original\\\"\\r\\n )\\r\\n # Set the location and display name to be the same so we can make sure the rest of the duplicate is equal.\\r\\n duplicated_item.location = original_item.location\\r\\n duplicated_item.display_name = original_item.display_name\\r\\n\\r\\n # Children will also be duplicated, so for the purposes of testing equality, we will set\\r\\n # the children to the original after recursively checking the children.\\r\\n if original_item.has_children:\\r\\n self.assertEqual(\\r\\n len(original_item.children),\\r\\n len(duplicated_item.children),\\r\\n \\\"Duplicated item differs in number of children\\\"\\r\\n )\\r\\n for i in xrange(len(original_item.children)):\\r\\n if not check_equality(original_item.children[i], duplicated_item.children[i]):\\r\\n return False\\r\\n duplicated_item.children = original_item.children\\r\\n\\r\\n return original_item == duplicated_item\\r\\n\\r\\n duplicate_and_verify(self.problem_usage_key, self.seq_usage_key)\\r\\n duplicate_and_verify(self.html_usage_key, self.seq_usage_key)\\r\\n duplicate_and_verify(self.seq_usage_key, self.chapter_usage_key)\\r\\n duplicate_and_verify(self.chapter_usage_key, self.usage_key)\",\n \"def _validate_qty(values: dict):\\n\\n if not (quantity := values.get('quantity')):\\n raise ValueError(\\\"Quantity attribute is required.\\\")\\n\\n if not (symbol := values.get('symbol')):\\n raise ValueError(\\\"Symbol attribute is required.\\\")\\n\\n filter = symbol.filters.lot_size_filter\\n # if ONE :=1 and not filter.min_qty <= quantity <= filter.max_qty:\\n # ValueError(\\\"The quantity is not in valid range.\\\")\\n\\n if filter.step_size and not is_valid_significant_digits(\\n quantity,\\n symbol.qty_decimal_precision\\n ):\\n raise ValueError(\\\"The quantity precision is not valid.\\\")\\n\\n return values\",\n \"def test_excess_quantity(self):\\n excess = self._uncertain_demand.excess_stock\\n avg_order = sum([int(item) for item in self._data_set.values()]) //len(self._data_set)\\n variance = [(item - avg_order) for item in self._data_set.values()]\\n stdev = pow(sum([pow(j, 2) for j in variance]) / len(self._data_set), 0.5)\\n cal_safety = lambda x, y, z: x * y * (z ** 0.5)\\n safety_stock = cal_safety(float(self._z_value), float(stdev), float(self._lead_time))\\n cal_reorder_level = lambda x, y, z: ((x ** 0.5) * y) + z\\n reorder = cal_reorder_level(float(self._lead_time), avg_order, float(safety_stock))\\n cal_excess = lambda x, y, z: round(x - (y + (y - z)), 0) if x > y + (y - z) else 0\\n test_excess = cal_excess(self._quantity_on_hand, reorder, safety_stock)\\n self.assertEqual(int(excess), int(test_excess))\",\n \"def equal_number_ver(seq):\\r\\n num_AB, num_AnotB, num_BnotA = 0, 0, 0\\r\\n for item in seq:\\r\\n if np.array_equal(item, Quantifier.AB):\\r\\n num_AB += 1\\r\\n elif np.array_equal(item, Quantifier.AnotB):\\r\\n num_AnotB += 1\\r\\n elif np.array_equal(item, Quantifier.BnotA):\\r\\n num_BnotA += 1\\r\\n return Quantifier.T if num_AnotB == num_BnotA else Quantifier.F\",\n \"def test_gather_success(self):\\n gathered_items = self.Quant._gather(self.apple, self.test_stock_location_01)\\n # Check the number of apple quants returned is correct\\n self.assertEqual(len(gathered_items), 3)\\n # Check that the products are all of expected type\\n self.assertEqual(gathered_items.product_id, self.apple)\\n\\n # Unfold the returned quants\\n _q1, second_quant, _q2 = gathered_items\\n # Check when quant_ids is set in the context\\n gathered_items_subset = self.Quant.with_context(quant_ids=[second_quant.id])._gather(\\n self.apple, self.test_stock_location_01\\n )\\n self.assertEqual(len(gathered_items_subset), 1)\\n self.assertEqual(gathered_items_subset.product_id, self.apple)\\n self.assertEqual(gathered_items_subset, second_quant)\",\n \"def contains_duplicate_full_slow_set(self, nums: List[int]) -> bool:\\n return len(nums) != len(set(nums))\",\n \"def normalize_quantities(self):\\n return (\\n pynini.cdrewrite(self.units_map, \\\"\\\", \\\"\\\", self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.singularize_map, \\\"1 \\\", \\\"\\\", self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.thousands_map, \\\"\\\", self.triple_digits, self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.hundreds_map, \\\"\\\", self.double_digits, self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.tens_map, \\\"\\\", self.digits, self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.teens_map, \\\"\\\", \\\"\\\", self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.ones_map, \\\"\\\", \\\"\\\", self.sigma_star, direction=\\\"ltr\\\") *\\n pynini.cdrewrite(self.zero_del, \\\"\\\", \\\"\\\", self.sigma_star, direction=\\\"ltr\\\")\\n )\",\n \"def find_duplicates(lst):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return len( set(lst) ) != len(lst)\",\n \"def _test_sampdup(t):\\n return t.shape[1] != len(set(t.ids(axis='sample')))\",\n \"def unitset_is_consistent(self, other: \\\"UnitSet\\\"):\\n return all(getattr(self, q) is getattr(other, q) for q in self._base_quantities)\",\n \"def returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet):\\n _itemSet = set()\\n localSet = defaultdict(int)\\n for item in itemSet:\\n for transaction in transactionList:\\n if item.issubset(transaction):\\n freqSet[item] += 1\\n localSet[item] += 1\\n for item, count in localSet.items():\\n support = float(count)/len(transactionList)\\n if support >= minSupport:\\n _itemSet.add(item)\\n\\n return _itemSet\",\n \"def _reduce_rep(self):\\n for k, v in self.items():\\n if not k:\\n self[k] = 0\\n for per1, per2 in pairwise(k):\\n if per1 == per2:\\n self[k] = 0\\n super()._reduce_rep()\",\n \"def _check_ensembles_are_same_size(p, q):\\n if p.npdf != q.npdf:\\n raise ValueError(\\\"Input ensembles should have the same number of distributions\\\")\",\n \"def has_quanta(self, quanta_subset):\\n\\n return all(x in self.q.items()\\n for x in quanta_subset.items())\",\n \"def test_simtk_list_of_quantities_to_pint():\\n list_of_quantities = [val * omm_unit.meter for val in range(10)]\\n quantity_list = omm_unit.meter * [val for val in range(10)]\\n\\n assert list_of_quantities != quantity_list\\n assert all(simtk_to_pint(list_of_quantities) == simtk_to_pint(quantity_list))\",\n \"def test_single_quant_assign_correct_quant(self):\\n Quant = self.env[\\\"stock.quant\\\"]\\n\\n # Create a bunch of identical quants in the same location\\n quants = Quant.browse()\\n for i in range(5):\\n quants |= self.create_quant(self.apple.id, self.test_stock_location_01.id, 10)\\n self.assertEqual(len(quants), 5)\\n\\n quant = quants[2]\\n pick = quant.create_picking(self.picking_type_pick, confirm=True, assign=True)\\n self.assertEqual(pick.state, \\\"assigned\\\")\\n self.assertEqual(quant.reserved_quantity, 10)\",\n \"def calc_q1(data: list) -> float:\\n py = copy.copy(data)\\n py.sort()\\n return py[round(len(py) / 4)]\",\n \"def assert_tracking_unique(self, serial_numbers):\\n Lot = self.env[\\\"stock.production.lot\\\"]\\n self.ensure_one()\\n if self.tracking != \\\"none\\\":\\n lots = Lot.search(\\n [(\\\"product_id\\\", \\\"=\\\", self.id), (\\\"name\\\", \\\"in\\\", serial_numbers)]\\n )\\n if lots:\\n raise ValidationError(\\n _(\\\"%s numbers %s already in use for product %s\\\")\\n % (self.tracking.capitalize(), \\\" \\\".join(lots.mapped(\\\"name\\\")), self.name)\\n )\",\n \"def _equality_queries(self, field, dist):\\n\\n query_dicts = []\\n for q in xrange(len(self.__queries)):\\n query_dicts = []\\n for count in xrange(self.__queries[q]['no_queries']*OVER_GENERATION_RATIO):\\n self.__count += 1\\n logger.info('EQ: Created %d out of %d queries' % (self.__count, self.__total))\\n r_lower_cdf = self.__queries[q]['rss_lower_cdf']\\n r_upper_cdf = self.__queries[q]['rss_upper_cdf'] \\n value = self.__dists[field].generate_pdf(r_lower_cdf, r_upper_cdf, {})\\n qid = qids.query_id()\\n (value, where) = aqb.EqualityFishingQueryBatch.format_value_and_where(field, value)\\n if qid != qids.full_where_has_been_seen(qid,where):\\n continue\\n query_dicts.append({qs.QRY_ENUM : qs.CAT.EQ, \\n qs.QRY_QID : qid,\\n qs.QRY_DBNUMRECORDS : self.__db_size,\\n qs.QRY_DBRECORDSIZE : self.__row_width, \\n qs.QRY_PERF : self.__perf,\\n qs.QRY_CAT : self.__cat,\\n qs.QRY_SUBCAT : '', \\n qs.QRY_WHERECLAUSE : where,\\n qs.QRY_FIELD : sv.sql_info[field][0],\\n qs.QRY_NEGATE : False,\\n qs.QRY_FIELDTYPE : sv.sql_info[field][1],\\n qs.QRY_LRSS : self.__queries[q][qs.QRY_LRSS],\\n qs.QRY_URSS : self.__queries[q][qs.QRY_URSS],\\n qs.QRY_VALUE : value})\\n \\n self.__bobs.append(aqb.EqualityQueryBatch(query_dicts,count, \\n int((count+1)/OVER_GENERATION_RATIO),\\n True))\",\n \"def _all_products(q_1: Q, q_2: Q) -> Dict:\\n\\n all_dict = _commuting_products(q_1, q_2)\\n all_dict.update(_anti_commuting_products(q_1, q_2))\\n\\n return all_dict\",\n \"def sum_unique(l):\\n pass\",\n \"def find_quant(trainy, train_tree_node_ID, pred_tree_node_ID, qntl):\\n npred = pred_tree_node_ID.shape[0]\\n out = np.zeros((npred, qntl.size))*np.nan\\n for i in prange(pred_tree_node_ID.shape[0]):\\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\\n sample = trainy[idxs]\\n out[i, :] = np.quantile(sample, qntl)\\n return out\",\n \"def _is_duplicate (asin, current_list):\\n\\n dup = False\\n for m in current_list:\\n try:\\n if unicode(asin) == m['sku']:\\n dup = True\\n break\\n except KeyError:\\n pass\\n return dup\",\n \"def quantilize(v, n_quantile=5, return_summary=False, fallback_to_unique=True):\\n\\n v = np.array(v)\\n\\n if fallback_to_unique:\\n x, ix = uniquetol(v, return_inverse=True)\\n \\n if (not fallback_to_unique) or len(x) > n_quantile:\\n n = v.size\\n ix = np.int32(np.ceil((stats.rankdata(v, method='ordinal') + 0.) \\\\\\n / n * n_quantile) - 1)\\n \\n if return_summary:\\n x = npg.aggregate(ix, v, func='mean')\\n return ix, x\\n else: \\n return ix\",\n \"def distr(self,X):\\r\\n return {x:X.count(x) for x in set(X)}\",\n \"def test_single_identical_bid(self):\\n bids = [Cost(ITEM1, ACTOR1, 1640),\\n Cost(ITEM2, ACTOR1, 1540),\\n Cost(ITEM3, ACTOR1, 1140),\\n Cost(ITEM4, ACTOR1, 1640),\\n Cost(ITEM5, ACTOR1, 1740),\\n Cost(ITEM1, ACTOR2, 1540),\\n Cost(ITEM2, ACTOR2, 1240),\\n Cost(ITEM3, ACTOR2, 1340),\\n Cost(ITEM4, ACTOR2, 1640),\\n Cost(ITEM5, ACTOR2, 1940),\\n Cost(ITEM1, ACTOR3, 1740),\\n Cost(ITEM2, ACTOR3, 1540),\\n Cost(ITEM3, ACTOR3, 1040),\\n Cost(ITEM4, ACTOR3, 1640),\\n Cost(ITEM5, ACTOR3, 1740),\\n Cost(ITEM1, ACTOR4, 1440),\\n Cost(ITEM2, ACTOR4, 1640),\\n Cost(ITEM3, ACTOR4, 1240),\\n Cost(ITEM4, ACTOR4, 1640),\\n Cost(ITEM5, ACTOR4, 1740),\\n Cost(ITEM1, ACTOR5, 1640),\\n Cost(ITEM2, ACTOR5, 1640),\\n Cost(ITEM3, ACTOR5, 1140),\\n Cost(ITEM4, ACTOR5, 1640),\\n Cost(ITEM5, ACTOR5, 1640)]\\n result = self.splitter.split(ITEMS[:5], ACTORS[:5], bids)\\n expected = [(ITEM1, ACTOR3, None),\\n (ITEM2, ACTOR5, None),\\n (ITEM3, ACTOR4, None),\\n (ITEM4, ACTOR1, None),\\n (ITEM5, ACTOR2, None)]\\n item_assignments_present(self, result, expected)\",\n \"def gen_all_holds(hand):\\n ans_set = set([()])\\n\\n for dummy_idx in range(len(hand)):\\n temp_set = set([()])\\n for seq in ans_set:\\n for item in hand:\\n new_seq = list(seq)\\n if hand.count(item) > new_seq.count(item):\\n new_seq.append(item)\\n new_seq = sorted(new_seq)\\n temp_set.add(tuple(new_seq))\\n ans_set = temp_set\\n return ans_set\",\n \"def duplicates(items):\\n duplicate_items = set()\\n for item in items:\\n if items.count(item) > 1:\\n duplicate_items.add(item)\\n duplicate_list = list(duplicate_items)\\n\\n\\n return sorted(duplicate_list)\",\n \"def is_real_dupe(dupe_lst):\\n if len(dupe_lst) >= 10:\\n return True\\n first_composer = dupe_lst[0]['composer']\\n\\n if len(dupe_lst) > 2:\\n for d in dupe_lst:\\n if d['composer'] != first_composer:\\n return True\\n return False\",\n \"def test_multiple_without_IS(self):\\n df = self.mdf\\n fixed_record_idx = 0\\n for renorm in [True, False]:\\n with self.subTest(renorm=renorm):\\n out = standardise_aggregate(\\n df, renorm=renorm, fixed_record_idx=fixed_record_idx\\n )\\n if not renorm:\\n self.assertTrue(\\n np.isclose(\\n out.values, df.iloc[fixed_record_idx, :].values\\n ).any()\\n )\",\n \"def large_order(order):\\n distinct_items = {item.product for item in order.cart}\\n if len(distinct_items) >= 10:\\n return order.total() * .07\\n return 0\",\n \"def pull_out_quantifications_across_negation(formula: Formula) -> \\\\\\r\\n Tuple[Formula, Proof]:\\r\\n assert is_unary(formula.root)\\r\\n # Task 11.6\\r\\n\\r\\n prover = Prover(Prover.AXIOMS.union(ADDITIONAL_QUANTIFICATION_AXIOMS))\\r\\n\\r\\n # Basic Case - No quantifier to change\\r\\n if not is_quantifier(formula.first.root):\\r\\n ccl = equivalence_of(formula, formula)\\r\\n prover.add_tautology(ccl)\\r\\n return formula, prover.qed()\\r\\n\\r\\n # The ~ and the predicate without the quantifier to keep changing it\\r\\n form = Formula(\\\"~\\\", formula.first.predicate)\\r\\n pred, proof = pull_out_quantifications_across_negation(form)\\r\\n\\r\\n # Definig the new quantifier\\r\\n if formula.first.root == \\\"A\\\":\\r\\n my_quantifier = \\\"E\\\"\\r\\n else: # \\\"E\\\"\\r\\n my_quantifier = \\\"A\\\"\\r\\n\\r\\n # proof for changing quantifier\\r\\n # because add_proof() is my friend\\r\\n step1 = prover.add_proof(proof.conclusion, proof)\\r\\n\\r\\n\\r\\n form2 = Formula(\\\"->\\\", proof.conclusion, equivalence_of(Formula(my_quantifier, formula.first.variable, form),\\r\\n Formula(my_quantifier, formula.first.variable, pred)))\\r\\n my_map2 = {'R': str(form.substitute({formula.first.variable: Term(\\\"_\\\")})),\\r\\n 'Q': str(pred.substitute({formula.first.variable: Term(\\\"_\\\")})), \\\"x\\\": formula.first.variable, \\\"y\\\": formula.first.variable}\\r\\n\\r\\n step2 = prover.add_instantiated_assumption(form2,\\r\\n ADDITIONAL_QUANTIFICATION_AXIOMS[14 if my_quantifier==\\\"A\\\" else 15], my_map2)\\r\\n\\r\\n step3 = prover.add_mp(equivalence_of(Formula(my_quantifier, formula.first.variable, form),\\r\\n Formula(my_quantifier, formula.first.variable, pred)), step1, step2)\\r\\n\\r\\n\\r\\n my_map4 = {'R': str(formula.first.predicate.substitute({formula.first.variable: Term(\\\"_\\\")})), \\\"x\\\": formula.first.variable}\\r\\n form4 = equivalence_of(formula, Formula(my_quantifier, formula.first.variable, form))\\r\\n step4 = prover.add_instantiated_assumption(form4,\\r\\n ADDITIONAL_QUANTIFICATION_AXIOMS[0 if my_quantifier==\\\"E\\\" else 1], my_map4)\\r\\n\\r\\n prover.add_tautological_implication(equivalence_of(formula, Formula(my_quantifier, formula.first.variable, pred)), [step3, step4])\\r\\n\\r\\n return Formula(my_quantifier, formula.first.variable, pred), prover.qed()\",\n \"def dupable_matches_required(self):\\n return 2\",\n \"def Get_dup_records(ds,key_var):\\n temp = ds.groupby([key_var]).agg({key_var:'count'}).rename(columns={key_var:'Freq'}).reset_index()\\n temp = temp[temp['Freq']>1]\\n print(\\\"Total Duplicate records:: \\\" +str(temp.shape[0]))\\n\\n return temp\",\n \"def testDuplicate(self,permutations=True):\\n # This algorithm is faster than encode,\\n # but for nplex=2 enmagic2 would probably still be faster.\\n if permutations:\\n C = self.copy()\\n C.sort(axis=1)\\n else:\\n C = self\\n ind = sortByColumns(C)\\n C = C.take(ind,axis=0)\\n ok = (C != roll(C,1,axis=0)).any(axis=1)\\n if not ok[0]: # all duplicates -> should result in one unique element\\n ok[0] = True\\n return ind,ok\",\n \"def Deduplicate(items):\\n seen = set()\\n for it in items:\\n if it not in seen:\\n seen.add(it)\\n yield it\",\n \"def test_select_grouping_quantitative_no_grouping(self):\\n\\n dimension = models.QuantitativeDimension(\\n key='shares',\\n name='Count of shares',\\n description='Count of shares',\\n field_name='shared_count',\\n )\\n\\n queryset = mock.Mock()\\n\\n result, internal_key = dimension.select_grouping_expression(queryset, dimension.field_name)\\n\\n # It should't need a different internal key in this simple case\\n self.assertEquals(internal_key, dimension.field_name)\\n self.assertEquals(result, queryset)\",\n \"def fracSeen(data):\\n itemSet = set()\\n numSeen = []\\n for x in data:\\n itemSet.add(x)\\n numSeen.append(len(itemSet))\\n\\n fracSeen = [x/numSeen[-1] for x in numSeen]\\n return fracSeen\",\n \"def no_ver(seq):\\r\\n for item in seq:\\r\\n if np.array_equal(item, Quantifier.AB):\\r\\n return Quantifier.F\\r\\n return Quantifier.T\",\n \"def notall_ver(seq):\\r\\n for item in seq:\\r\\n if np.array_equal(item, Quantifier.AnotB):\\r\\n return Quantifier.T\\r\\n return Quantifier.F\",\n \"def transform(self):\\n\\n transactions = self._get_transactions(self._x_transformed)\\n self.frequent_items = [set(item) for item in find_frequent_itemsets(\\n transactions, minimum_support=self.support_min) if len(item) > 1]\\n return self.frequent_items\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def getItemsWithMinSupp(self, transListSet, itemSet, freqSet, minSupp):\\n itemSet_ = set()\\n localSet_ = defaultdict(int)\\n for item in itemSet:\\n freqSet[item] += sum([1 for trans in transListSet if item.issubset(trans)])\\n localSet_[item] += sum([1 for trans in transListSet if item.issubset(trans)])\\n \\n # Only conserve frequent item-set \\n n = len(transListSet)\\n for item, cnt in localSet_.items():\\n itemSet_.add(item) if float(cnt)/n >= minSupp else None\\n \\n return itemSet_\",\n \"def test_phonebook_with_duplicate_entries_is_inconsostent(self):\\n self.phonebook.add(\\\"Bob\\\", \\\"12345\\\")\\n self.phonebook.add(\\\"Mary\\\", \\\"12345\\\")\\n self.assertFalse(self.phonebook.is_consistent())\",\n \"def similarparts(imagparts):\\n dupl = []\\n global opt\\n l = len(imagparts[0])-1\\n \\n for i in range(len(imagparts)-1): \\n difs = sum(abs(x-y) for x,y in zip(imagparts[i][:l],imagparts[i+1][:l]))\\n mean = float(sum(imagparts[i][:l])) / l\\n dev = float(sum(abs(mean-val) for val in imagparts[i][:l])) / l\\n if dev/mean >= float(opt.blcoldev):\\n if difs <= int(opt.blsim):\\n if imagparts[i] not in dupl:\\n dupl.append(imagparts[i])\\n if imagparts[i+1] not in dupl:\\n dupl.append(imagparts[i+1])\\n\\n return dupl\",\n \"def _search_for_quantity_in_price_level(self, tick_entry, quantity_to_trade, order):\\n if tick_entry is None: # Last tick\\n return quantity_to_trade, []\\n\\n if tick_entry.quantity <= Quantity(0):\\n return quantity_to_trade, []\\n\\n # Check if order and tick entry have the same trader id / origin\\n if order.order_id.trader_id == tick_entry.order_id.trader_id:\\n return quantity_to_trade, []\\n\\n assert isinstance(tick_entry, TickEntry), type(tick_entry)\\n assert isinstance(quantity_to_trade, Quantity), type(quantity_to_trade)\\n assert isinstance(order, Order), type(order)\\n\\n if tick_entry.order_id in order.reserved_ticks: # Tick is already reserved for this order\\n return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)\\n\\n if not tick_entry.is_valid(): # Tick is time out or reserved\\n return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)\\n\\n if quantity_to_trade <= tick_entry.quantity: # All the quantity can be matched in this tick\\n quantity_to_trade, proposed_trades = self._search_for_quantity_in_price_level_total(tick_entry,\\n quantity_to_trade,\\n order)\\n else: # Not all the quantity can be matched in this tick\\n quantity_to_trade, proposed_trades = self._search_for_quantity_in_price_level_partial(tick_entry,\\n quantity_to_trade,\\n order)\\n\\n return quantity_to_trade, proposed_trades\",\n \"def test_exclusive(self):\\n s = djset()\\n s.add([1, 2, 3])\\n s.add([4, 5, 6])\\n self.assertEquals({1, 2, 3}, s.data[1])\\n self.assertEquals({4, 5, 6}, s.data[4])\",\n \"def item_duplicate():\\n return {'name':'chair',\\n 'value':300}\",\n \"def returnItemsWithMinSupport(itemSet, transactionList, timestampList, itemTimestampIndexDict, dateStampSet, minSupport, freqSet, tidToGranularityTid, granularityTimestampList):\\n _itemSet = set()\\n localSet = defaultdict(int)\\n\\n print \\\"# Candidates: \\\" + str(len(itemSet))\\n\\n for itemIdx, item in enumerate(itemSet):\\n # print \\\"ITEM: \\\" + str(item)\\n # print \\\"# ELEMENTS: \\\" + str(len(item))\\n tsSet = set()\\n for i, element in enumerate(item):\\n elementTsSet = itemTimestampIndexDict[element] # Count element in same time\\n # print \\\"hi\\\" + str(elementTsSet)\\n elementTsSet = set([tidToGranularityTid[ts] for ts in elementTsSet]) # Count element in same granularity\\n # print \\\">>\\\" + str(elementTsSet)\\n if i == 0:\\n tsSet = elementTsSet\\n else:\\n tsSet = tsSet & elementTsSet\\n\\n # print \\\"# ts: \\\" + str(len(tsSet))\\n \\\"\\\"\\\" Count days occuring item as support value \\\"\\\"\\\"\\n timestamp_set = set()\\n # print tsSet\\n for ts in tsSet:\\n # timestamp = timestampList[ts]\\n # timestamp = dt.datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d')\\n timestamp = granularityTimestampList[ts].strftime('%Y-%m-%d')\\n if timestamp not in timestamp_set:\\n timestamp_set.add(timestamp)\\n freqSet[item] += 1\\n localSet[item] += 1\\n\\n for item, count in localSet.items():\\n # support = float(count)/len(transactionList)\\n support = float(count) / len(dateStampSet)\\n if support >= minSupport:\\n # print item\\n # print support\\n _itemSet.add(item)\\n\\n return _itemSet\",\n \"def execQ8():\\n frame = pan.DataFrame(data, columns=['Product', 'Price', 'Period'])\\n filtered_frame = frame.sort_values(by='Price', ascending=False).drop_duplicates('Product').head(10)\\n return filtered_frame\",\n \"def is_satisfied(self, item: Product) -> bool:\\n return item.size == self.size\",\n \"def adduniq(self, item, issue):\\n if self.has_key(item):\\n if issue in self[item]:\\n return 0\\n self.add(item, issue)\\n return 1\",\n \"def find_same_amount(df):\\n ids = list(df['id'][df.duplicated(['amount','branch_id','exchange_id'],keep= False)==True].values)\\n return ids\",\n \"def test_group_by_empty(self):\\n\\n class TestQuantDimension(models.QuantitativeDimension):\\n \\\"\\\"\\\"A quant dimension that returns no grouping expression\\\"\\\"\\\"\\n def __init__(self, *args, **kwargs):\\n super(TestQuantDimension, self).__init__(*args, **kwargs)\\n self._get_grouping_expression_calls = 0\\n\\n def get_grouping_expression(self, queryset, bins=None, bin_size=None, **kwargs):\\n self._get_grouping_expression_calls += 1\\n return None\\n\\n dimension = TestQuantDimension(\\n key='shares',\\n name='Count of shares',\\n description='Count of shares',\\n field_name='shared_count',\\n )\\n\\n queryset = mock.Mock()\\n expected_result = queryset.values.return_value\\n\\n result = dimension.group_by(queryset)\\n\\n self.assertEquals(result, expected_result)\\n queryset.values.assert_called_once_with()\\n self.assertEquals(dimension._get_grouping_expression_calls, 1)\",\n \"def _anti_commuting_products(q_1: Q, q_2: Q) -> Dict:\\n\\n s_x, s_y, s_z = q_1.x, q_1.y, q_1.z\\n q_2_x, q_2_y, q_2_z = q_2.x, q_2.y, q_2.z\\n\\n dif_dict = {\\n \\\"yz-zy\\\": s_y * q_2_z - s_z * q_2_y,\\n \\\"zx-xz\\\": s_z * q_2_x - s_x * q_2_z,\\n \\\"xy-yx\\\": s_x * q_2_y - s_y * q_2_x,\\n \\\"zy-yz\\\": -s_y * q_2_z + s_z * q_2_y,\\n \\\"xz-zx\\\": -s_z * q_2_x + s_x * q_2_z,\\n \\\"yx-xy\\\": -s_x * q_2_y + s_y * q_2_x,\\n }\\n\\n return dif_dict\",\n \"def test_get_similar_objects_weights(self): # pylint: disable=invalid-name\\n similar_objects = Assessment.get_similar_objects_query(\\n id_=self.assessment.id,\\n types=[\\\"Assessment\\\"],\\n threshold=0, # to include low weights too\\n ).all()\\n\\n # casting to int from Decimal to prettify the assertion method output\\n id_weight_map = {obj.id: int(obj.weight) for obj in similar_objects}\\n\\n self.assertDictEqual(id_weight_map, self.id_weight_map)\",\n \"def discrepancy(self):\\n result = 0\\n for focal, value in self.items():\\n if focal.cardinal > 0:\\n result -= value * math.log(self.betP(focal), 2)\\n return round(result, 6)\",\n \"def get_stocks_tested_by_number_of_replicates(\\n self, screen_type, screen_stage, number_of_replicates):\\n annotated = (\\n self.get_experiments_by_screen(screen_type, screen_stage)\\n .order_by('library_stock')\\n .values('library_stock')\\n .annotate(models.Count('id')))\\n\\n singles_pks = [x['library_stock'] for x in annotated\\n if x['id__count'] == number_of_replicates]\\n\\n singles = LibraryStock.objects.filter(pk__in=singles_pks)\\n\\n return set(singles)\",\n \"def _quant_unimplemented(self, *input: Any) -> None:\\n raise NotImplementedError\",\n \"def sum_n(k, lst):\\n seen = set()\\n for num in lst:\\n if k - num in seen:\\n return True\\n seen.add(num)\\n return False\",\n \"def req_items_for_store(inventory_store_id, quantity_type):\\r\\n \\r\\n req_items = db( ( db.logs_req.inventory_store_id == inventory_store_id ) & \\\\\\r\\n ( db.logs_req.id == db.logs_req_item.logs_req_id) & \\\\\\r\\n ( db.logs_req_item.item_packet_id == db.logs_req_item.item_packet_id) & \\\\\\r\\n ( db.logs_req_item[\\\"quantity_%s\\\" % quantity_type] < db.logs_req_item.quantity) & \\\\\\r\\n ( db.logs_req_item.deleted == False ) \\r\\n ).select(db.logs_req_item.id,\\r\\n db.logs_req_item.logs_req_id,\\r\\n db.logs_req_item.item_id,\\r\\n db.logs_req_item.quantity,\\r\\n db.logs_req_item[\\\"quantity_%s\\\" % quantity_type],\\r\\n db.logs_req_item.item_packet_id,\\r\\n orderby = db.logs_req.date_required | db.logs_req.date, \\r\\n #groupby = db.logs_req_item.item_id\\r\\n ) \\r\\n \\r\\n # Because groupby doesn't follow the orderby remove any duplicate req_item \\r\\n # req_items = req_items.as_dict( key = \\\"logs_req_item.item_id\\\") <- doensn't work \\r\\n # @todo: Rows.as_dict function could be extended to enable this functionality instead \\r\\n req_item_ids = []\\r\\n unique_req_items = Storage()\\r\\n for req_item in req_items:\\r\\n if req_item.item_id not in req_item_ids:\\r\\n #This item is not already in the dict \\r\\n unique_req_items[req_item.item_id] = Storage( req_item.as_dict() )\\r\\n req_item_ids.append(req_item.item_id) \\r\\n \\r\\n return unique_req_items\",\n \"def is_duplicate(self, **kwargs):\\n return len(list(self.c.select(**kwargs))) > 0\",\n \"def apriori_v3(q, insig, sex_file_dict, countries_list, age):\\r\\n\\r\\n q = [[int(num)] for num in q] # queue is formatted as a nested list\\r\\n insignificant = [[int(num)] for num in insig]\\r\\n significant = []\\r\\n\\r\\n #print(\\\"\\\\nInsig\\\", insignificant)\\r\\n #print(\\\"Sig\\\", significant)\\r\\n #print(\\\"Queue\\\\n\\\", q)\\r\\n\\r\\n while len(q) > 0:\\r\\n element = q[0]\\r\\n obs_freqs = []\\r\\n\\r\\n for country in countries_list:\\r\\n icd_freq = 0\\r\\n for freq in element:\\r\\n icd_freq += round(float(sex_file_dict[country][age][str(freq)]) * 1000000)\\r\\n obs_freqs.append(icd_freq)\\r\\n\\r\\n chisq, pvalue = chisquare(obs_freqs)\\r\\n\\r\\n if pvalue >= 0.01:\\r\\n significant.append(element)\\r\\n\\r\\n for i in range(int(element[-1])+1,36):\\r\\n if [i] not in insignificant:\\r\\n tentativeCandidate = sorted(list(element)+[i]) # add the two lists together (element is a list)\\r\\n if tentativeCandidate not in q and tentativeCandidate not in significant: # then add it to the queue\\r\\n\\r\\n q.append(tentativeCandidate)\\r\\n q.pop(0) #remove it from the queue after we have created/tried all the tentativeCandidates\\r\\n\\r\\n else: # when the p-value not significant\\r\\n q.pop(0)\\r\\n insignificant.append(element)\\r\\n return significant # grab the last values before breaking out of the while loop\\r\",\n \"def required_native_quantities(self):\\n return set(self._translate_quantities(self.list_all_quantities()))\",\n \"def _check_duplicates(self):\\n # check variables\\n counter = Counter(self.variables())\\n duplicates = [key for key, value in counter.items() if value > 1]\\n if duplicates != []:\\n raise DuplicateVariables(duplicates)\\n\\n # check parameters\\n counter = Counter(self.parameters())\\n duplicates = [key for key, value in counter.items() if value > 1]\\n if duplicates != []:\\n raise DuplicateParameters(duplicates)\",\n \"def test_array_return_type_reduction_group_by(t, df):\\n expr = t.group_by(t.key).aggregate(quantiles_col=collect(t.b))\\n result = expr.execute()\\n\\n df = df.compute() # Convert to Pandas\\n expected_col = df.groupby(df.key).b.agg(lambda s: s.tolist())\\n expected = pd.DataFrame({\\\"quantiles_col\\\": expected_col}).reset_index()\\n\\n tm.assert_frame_equal(\\n result.sort_values(\\\"key\\\").reset_index(drop=True),\\n expected.sort_values(\\\"key\\\").reset_index(drop=True),\\n )\",\n \"def M_ver(seq):\\r\\n num_AB = 0\\r\\n num_AnotB = 0\\r\\n num_BnotA = 0\\r\\n for item in seq:\\r\\n if np.array_equal(item, Quantifier.AB):\\r\\n num_AB += 1\\r\\n if np.array_equal(item, Quantifier.AnotB):\\r\\n num_AnotB += 1\\r\\n if np.array_equal(item, Quantifier.BnotA):\\r\\n num_BnotA += 1\\r\\n return (Quantifier.T if num_AB + num_AnotB > num_AB + num_BnotA\\r\\n else Quantifier.F)\",\n \"def all_ver(seq):\\r\\n for item in seq:\\r\\n if np.array_equal(item, Quantifier.AnotB):\\r\\n return Quantifier.F\\r\\n return Quantifier.T\",\n \"def __listsubseteq(self, c1, c2):\\n s2 = {}\\n for delta in c2:\\n s2[delta] = 1\\n\\n for delta in c1:\\n if not s2.has_key(delta):\\n return 0\\n\\n return 1\",\n \"def large_order_promo(order: Order):\\n distinct_items = {item.product for item in order.cart}\\n if len(distinct_items) >= 10:\\n return order.total() * 0.07\\n return 0\",\n \"def execQ7():\\n frame = pan.DataFrame(data, columns=['Product', 'Price', 'Period'])\\n filtered_frame = frame.sort_values(by='Price', ascending=True).drop_duplicates(subset='Product').head(10)\\n return filtered_frame\",\n \"def remove_duplicates(data):\\n already_used_items = {}\\n return_data = []\\n\\n for item in data:\\n # Yes, I know that I can find used items in the return_data,\\n # but HW requires this logic.\\n if not already_used_items.get(item):\\n return_data.append(item)\\n already_used_items[item] = True\\n\\n return return_data\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5703828","0.57010126","0.5693255","0.55881643","0.5587493","0.5551469","0.5545252","0.55120176","0.54732245","0.54649097","0.5460169","0.5428315","0.5425589","0.5398626","0.53612894","0.5330958","0.5326141","0.5314214","0.5252058","0.52479565","0.5233332","0.52310485","0.5210173","0.5184603","0.51814634","0.5154892","0.5136826","0.5131157","0.51281166","0.5117438","0.5106973","0.5087931","0.5081336","0.5068649","0.504886","0.5033995","0.5032936","0.5022281","0.5020336","0.5020048","0.50118464","0.5011217","0.5007777","0.5003297","0.50028276","0.5000323","0.49901617","0.49894986","0.49677297","0.49626237","0.4956253","0.49551585","0.49542361","0.49529633","0.49497676","0.49463883","0.4942748","0.4941785","0.49400756","0.49388307","0.493094","0.49303412","0.49290383","0.49237582","0.49125245","0.490937","0.490046","0.48995033","0.48984832","0.4896111","0.48951504","0.48898444","0.48825702","0.48787415","0.48757377","0.48691198","0.48665747","0.48639935","0.4862827","0.48565677","0.48517117","0.4848688","0.48467925","0.48376188","0.48358306","0.48354837","0.4834568","0.48333928","0.48331898","0.48308837","0.4829393","0.48289958","0.48280773","0.48267183","0.4825333","0.48245406","0.48203164","0.4820285","0.48113555","0.4810841","0.48096687"],"string":"[\n \"0.5703828\",\n \"0.57010126\",\n \"0.5693255\",\n \"0.55881643\",\n \"0.5587493\",\n \"0.5551469\",\n \"0.5545252\",\n \"0.55120176\",\n \"0.54732245\",\n \"0.54649097\",\n \"0.5460169\",\n \"0.5428315\",\n \"0.5425589\",\n \"0.5398626\",\n \"0.53612894\",\n \"0.5330958\",\n \"0.5326141\",\n \"0.5314214\",\n \"0.5252058\",\n \"0.52479565\",\n \"0.5233332\",\n \"0.52310485\",\n \"0.5210173\",\n \"0.5184603\",\n \"0.51814634\",\n \"0.5154892\",\n \"0.5136826\",\n \"0.5131157\",\n \"0.51281166\",\n \"0.5117438\",\n \"0.5106973\",\n \"0.5087931\",\n \"0.5081336\",\n \"0.5068649\",\n \"0.504886\",\n \"0.5033995\",\n \"0.5032936\",\n \"0.5022281\",\n \"0.5020336\",\n \"0.5020048\",\n \"0.50118464\",\n \"0.5011217\",\n \"0.5007777\",\n \"0.5003297\",\n \"0.50028276\",\n \"0.5000323\",\n \"0.49901617\",\n \"0.49894986\",\n \"0.49677297\",\n \"0.49626237\",\n \"0.4956253\",\n \"0.49551585\",\n \"0.49542361\",\n \"0.49529633\",\n \"0.49497676\",\n \"0.49463883\",\n \"0.4942748\",\n \"0.4941785\",\n \"0.49400756\",\n \"0.49388307\",\n \"0.493094\",\n \"0.49303412\",\n \"0.49290383\",\n \"0.49237582\",\n \"0.49125245\",\n \"0.490937\",\n \"0.490046\",\n \"0.48995033\",\n \"0.48984832\",\n \"0.4896111\",\n \"0.48951504\",\n \"0.48898444\",\n \"0.48825702\",\n \"0.48787415\",\n \"0.48757377\",\n \"0.48691198\",\n \"0.48665747\",\n \"0.48639935\",\n \"0.4862827\",\n \"0.48565677\",\n \"0.48517117\",\n \"0.4848688\",\n \"0.48467925\",\n \"0.48376188\",\n \"0.48358306\",\n \"0.48354837\",\n \"0.4834568\",\n \"0.48333928\",\n \"0.48331898\",\n \"0.48308837\",\n \"0.4829393\",\n \"0.48289958\",\n \"0.48280773\",\n \"0.48267183\",\n \"0.4825333\",\n \"0.48245406\",\n \"0.48203164\",\n \"0.4820285\",\n \"0.48113555\",\n \"0.4810841\",\n \"0.48096687\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17090,"cells":{"query":{"kind":"string","value":"Absorb second into child of first. Currently does not support remapping entries, so import_cfs(second) needs to be run again. Old factors will be left in so _fq_map still works."},"document":{"kind":"string","value":"def merge_quantities(self, first, second):\n dom = self.get_canonical(first)\n add = self.get_canonical(second)\n self._qm.merge(dom, add)\n self.import_cfs(second)"},"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 map2(self, f, pt):\n logger.debug('[START] PID[%s] map2 skeleton', PID)\n assert self.__distribution == pt.distribution\n content = SList([None] * self.__content.length())\n for i in range(len(self.__global_index[self.__start_index: self.__start_index +\n self.__nb_segs])):\n (start, offset) = self.__global_index[self.__start_index: self.__start_index +\n self.__nb_segs][i]\n logger.debug('[START] PID[%s] map2_local from %s to %s', PID, start, start + offset)\n content[start:start + offset] = Segment(self.__content[start:start + offset]). \\\n map2(f, Segment(pt.content[start:start + offset]))\n logger.debug('[END] PID[%s] map2_local from %s to %s', PID, start, start + offset)\n res = PTree.init(self, content)\n logger.debug('[END] PID[%s] map2 skeleton', PID)\n return res","def update(self, other):\n b = self.hallucinate_merge(other)\n self.l_child = b.l_child\n self.r_child = b.r_child","def merge_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.merge_from(other.parent)\n self.isolated_names.update(other.isolated_names)\n self.read.update(other.read)\n self.modified.update(other.modified)\n self.bound.update(other.bound)\n self.deleted.update(other.deleted)\n self.annotations.update(other.annotations)\n self.params.update(other.params)","def _redirect(self, node1, node2):\n if node1.parent.right is node1:\n node1.parent.right = node2\n else:\n node1.parent.left = node2","def expand_second_partition(device):\n\n print('Deleting the original boot partition from the thumb drive')\n _delete_partition(device, 1)\n\n print('Expanding the partition. Resizing isn\\'t worth it. Or obvious to do.')\n resize_command = ['sudo', 'parted', device.path, 'resizepart', '2', '\"-1s\"']\n interactive_console(resize_command)\n\n print('Fixing the nibbly bits for the partition itself')\n target_partition = device.partitions(full_paths=True)[0]\n interactive_console(['sudo', 'e2fsck', '-f', target_partition])\n\n print('Fixing ext4 so it goes all the way to the end')\n target_end = device.partition_specs(2)['End']\n interactive_console(['sudo', 'resize2fs', target_partition, target_end])\n\n print('Success!')","def __remap(self, tree1: int, tree2: int) -> None:\n # if the branch was deleted in the same iteration skip\n if self.__trees.get(tree1) is None:\n return\n\n # re map all mazes to tree2\n self.__mappings[tree1] = tree2\n for key, value in self.__mappings.items():\n if value == tree1:\n self.__mappings[key] = tree2\n self.__trees[tree2] += self.__trees[tree1]\n del self.__trees[tree1]","def merge(self, first, second):\n return second if self.failed(first) else first","def _fix_other_tree(self, this_tree, other_tree):\n parent_dir, name = osutils.split(self._target_subdir)\n parent_id = this_tree.path2id(parent_dir)\n\n root_ie = other_tree.inventory.root\n root_ie.parent_id = parent_id\n root_ie.name = name\n\n new_file_id = generate_ids.gen_file_id(name)\n trace.mutter('munging root_ie.file_id: %s => %s', root_ie.file_id,\n new_file_id)\n del other_tree.inventory._byid[root_ie.file_id]\n root_ie.file_id = new_file_id\n other_tree.inventory._byid[new_file_id] = root_ie\n # We need to fake a new id for root_ie\n for child_ie in root_ie.children.itervalues():\n child_ie.parent_id = new_file_id","def add_child(self, child):\n if isinstance(child, ET.ElementBase):\n for f in child.findall('.//form'):\n f.replace(f.getchildren()[1:])\n\n if isinstance(child, Form):\n child = child.getchildren()[1:]\n\n super(Form, self).add_child(child)","def inherit_species_module_mapping(self, generation, other, acc, da_scheme=None, inherit_module_mapping=True):\n if acc > self.max_accuracy:\n if inherit_module_mapping:\n other.update_module_refs(generation)\n self.species_module_ref_map = other.species_module_ref_map\n\n self.max_accuracy = acc\n\n if da_scheme is not None:\n self.da_scheme = da_scheme","def merge(self, other):\n\n for child in other.children:\n self.add_deep_copy_of(child, merged=True)","def test_field_resolution_multiple_inheritance_without_child_field_defined(self):\n parent_b_field = ParentBM()._get_fields()[\"name\"]\n child_field = ChildWithMultipleParents()._get_fields()[\"name\"]\n self.assertEqual(parent_b_field.default, \"B\")\n self.assertEqual(child_field.default, \"A\")\n\n child_field = ChildWithMultipleParentsWithDifferntOrder()._get_fields()[\"name\"]\n self.assertEqual(child_field.default, \"B\")","def cu_for_merge(self, best1, best2, undo=True):\n\t\t#TODO - Might want to consider adding the instance to the merged node.\n\t\tfirst = best1\n\t\tsecond = best2\n\n\t\tif second < first:\n\t\t\ttemp = first \n\t\t\tfirst = second \n\t\t\tsecond = temp\n\n\t\tfirst_c = self.tree.children[first]\n\t\tsecond_c = self.tree.children[second]\n\n\t\tnew_c = self.tree.makeTree(self.tree.root, self.tree)\n\t\tnew_c.utility.update_counts_from_node(first_c)\n\t\tnew_c.utility.update_counts_from_node(second_c)\n\n\t\tself.tree.children.pop(second)\n\t\tself.tree.children.pop(first)\n\t\tself.tree.children.append(new_c)\n\n\t\tcu = self.utility.category_utility()\n\n\t\tif undo:\n\t\t\tself.tree.children.pop()\n\t\t\tself.tree.children.insert(first,first_c)\n\t\t\tself.tree.children.insert(second,second_c)\n\t\telse:\n\t\t\t# If we aren't undoing the merge then we have to add the leaves\n\t\t\tnew_c.children.append(first_c)\n\t\t\tfirst_c.parent = new_c\n\t\t\tnew_c.children.append(second_c)\n\t\t\tsecond_c.parent = new_c\n\t\t\tself.tree.mergedNodes.append([first_c, second_c])\n\t\t\tself.tree.splitMergeOrder.append(\"m\")\n\t\t\tfor m in self.tree.mergedNodes:\n\t\t\t\tif len(m) > 2 and first_c in m and second_c in m:\n\t\t\t\t\tm.remove(first_c)\n\t\t\t\t\tm.remove(second_c)\n\t\t\t\t\tm.append(new_c)\n\t\t\tfor s in self.tree.splitNodes:\n\t\t\t\tif len(s) > 2 and first_c in s and second_c in s:\n\t\t\t\t\ts.remove(first_c)\n\t\t\t\t\ts.remove(second_c)\n\t\t\t\t\ts.append(new_c)\n\t\treturn cu","def add_spoof_child(self, child):\n if child.tags is None:\n raise Exception(\"Component {0} tried to add_child \"\n \"component: {1} to its children. \"\n \"But tags \"\n \"was not set.\".format(str(self), str(child)))\n if child.component_type is None:\n raise Exception(\"Component {0} tried to add_child \"\n \"component: {1} to its children. \"\n \"But component_type \"\n \"was not set.\".format(str(self), str(child)))\n if not child._parent is None and child.parent != self:\n raise Exception(\"Component {0} tried to add_child \"\n \"component: {1} to its children. \"\n \"But it already \"\n \"had parent: {2}.\".format(str(self), str(child), str(child.parent)))\n if not child.component_type in self._spoofed_children:\n self._spoofed_children[child.component_type] = []\n self._spoofed_children[child.component_type].append(child)\n self._add_child_to_tag_table(child)\n child.parent = self","def _chain_to_another_future(self, base_future):\n\n if base_future in self._chained_futures_log:\n raise CircularFuturesChainException(\n 'Circular Futures chain detected. Future {} is already in the resolved chain {}'.format(\n base_future, set(self._chained_futures_log)\n )\n )\n else:\n self._chained_futures_log.add(base_future)\n\n def _done_handler(base_future):\n \"\"\"\n Converts results of underlying future into results of new future\n\n :param ThenableFuture base_future: Original Future instance, but now guaranteed to be resolved\n due to cancellation or completion.\n \"\"\"\n if not base_future.done():\n # this should never ever be true.\n # having this code here just to avoid infinite timeout\n self.cancel()\n return\n\n if base_future.cancelled():\n self.cancel()\n return\n\n try:\n result = base_future.result()\n if isinstance(result, Future):\n self._chain_to_another_future(result)\n else:\n self.set_result(result)\n return\n except BaseException:\n # note, that exception may come from self.result()\n # and from on_fulfilled(result) calls.\n ex, trace_back = sys.exc_info()[1:]\n self.set_exception_info(ex, trace_back)\n return\n\n base_future.add_done_callback(_done_handler)","def secondary_clustering(sff_file, mapping, bestscores, log_fh,\r\n threshold=4.5, verbose=False):\r\n if(len(bestscores) == 0):\r\n # Either all sequence are already clustered or\r\n # we had no seq exceeding the bail out limit\r\n return\r\n\r\n (flowgrams, header) = lazy_parse_sff_handle(open(sff_file))\r\n\r\n counter = 0\r\n for f in flowgrams:\r\n (id, score) = bestscores[f.Name]\r\n if (score < threshold):\r\n counter += 1\r\n # update the mapping information\r\n mapping[id].extend(mapping[f.Name])\r\n mapping[id].append(f.Name)\r\n del(mapping[f.Name])\r\n if verbose:\r\n log_fh.write(\"Secondary clustering removed %d flowgrams\\n\" % counter)","def merge_fs(fs1,fs2):\n # This function merges fs2 into fs1, changing fs1 in-place\n # It's a cheaper and faster alternative of unify(), which will check\n # all the similarities and differences between fs1 and fs2. But this one\n # just assumes that fs2 and fs1 does not have any entries in common\n # NOTICE: In Templates.lex we cannot guarantee there is no overlap\n # so only use this function when it IS clear.\n for k in fs2.keys():\n if fs1.has_key(k):\n merge_fs(fs1[k],fs2[k])\n else:\n fs1[k] = fs2[k]\n return","def divide(self, secondary_spectrum, copy_header='first', force=True,\n copy_flux_err = 'No', method='interpolate'):\n\n self.check_units(secondary_spectrum)\n\n s_one = self.copy()\n s_two = secondary_spectrum.copy()\n\n if not np.array_equal(self.dispersion, s_two.dispersion):\n print (\"Warning: Dispersion does not match.\")\n print (\"Warning: Flux will be interpolated.\")\n\n s_one.match_dispersions(s_two, force=force,\n match_secondary=False, method=method)\n\n new_flux = s_one.flux / s_two.flux\n print(copy_flux_err)\n if copy_flux_err == 'No' and isinstance(s_one.flux_err,\n np.ndarray) and \\\n isinstance(s_two.flux_err, np.ndarray):\n new_flux_err = np.sqrt( (s_one.flux_err/ s_two.flux)**2 + (new_flux/s_two.flux*s_two.flux_err)**2 )\n elif copy_flux_err == 'first':\n new_flux_err = s_one.flux_err\n elif copy_flux_err == 'second':\n new_flux_err = s_two.flux_err\n else:\n new_flux_err = None\n\n print(new_flux_err, s_one.flux_err)\n\n if copy_header == 'first':\n new_header = s_one.header\n elif copy_header == 'last':\n new_header = s_two.header\n\n return SpecOneD(dispersion=s_one.dispersion,\n flux=new_flux,\n flux_err=new_flux_err,\n header=new_header,\n unit=s_one.unit,\n mask=s_one.mask)","def _merge(self, drifting_t, another_t):\n # drifting_t and another_t must exist in graph\n\n # add a (t --> another_t) edge for each (t --> drifting_t) edge\n for t, _, key, data in self.in_edges_iter(\n nbunch=[drifting_t], data=True, keys=True\n ):\n self.add_edge(t, another_t, key=key, attr_dict=data)\n\n # add a (another_t --> t) edge for each (drifting_t --> t) edge\n for _, t, key, data in self.edges_iter(\n nbunch=[drifting_t], data=True, keys=True\n ):\n self.add_edge(another_t, t, key=key, attr_dict=data)\n\n # remove drifting_t node (as it was replaced by another_t)\n self.remove_node(drifting_t)","def fl_add_child(ptr_flobject1, ptr_flobject2):\n _fl_add_child = library.cfuncproto(\n library.load_so_libforms(), \"fl_add_child\",\\\n None, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(xfdata.FL_OBJECT)],\n \"\"\"void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2)\"\"\")\n library.check_if_flinitialized()\n library.verify_flobjectptr_type(ptr_flobject1)\n library.verify_flobjectptr_type(ptr_flobject2)\n library.keep_elem_refs(ptr_flobject1, ptr_flobject2)\n _fl_add_child(ptr_flobject1, ptr_flobject2)","def recoverTree(self, root: TreeNode) -> None:\n self.inorder(root)\n self.first.val, self.second.val = self.second.val, self.first.val","def merge_nodes(self, parent, child):\n parent.key += child.key\n parent.real = child.real\n parent.value = child.value\n parent.children = child.children","def level_two(self):\n #swaps a random ingredient by choosing a random place\n swap_spot = randint(0,len(self.current_recipe.toppings)-1)\n #chooses which food type to choose from\n extra_ingredient_type = choice(food_type_databases) \n new_ingredient = choice(extra_ingredient_type)\n self.current_recipe.toppings[swap_spot] = new_ingredient\n self.new_ingredients = self.current_recipe.toppings","def to_other(self, c2, cut=False):\n\n p = self.c.p\n\n p_v = p.v # p may be invalid by the time we want to use it\n\n c2, nd = self.unl_to_pos(c2, p)\n\n if c2 is None:\n return\n\n # in case nd was created in this outline, invalidating p\n p = self.c.vnode2position(p_v)\n\n self.copy_recursively(p, nd)\n\n p = self.c.vnode2position(p_v)\n\n nxt = p.copy().visNext(self.c).v\n\n if cut:\n self.c.selectPosition(p)\n self.c.deleteOutline()\n self.c.setChanged()\n\n if nxt:\n self.c.selectPosition(self.c.vnode2position(nxt))\n\n c2.setChanged()\n c2.redraw()\n self.c.bringToFront(c2=self.c)\n self.c.redraw() # must come second to keep focus","def put_forks(self):\r\n\r\n if self.has_forks:\r\n print '%s drops both forks.'% self.name\r\n self.left_fork.release()\r\n self.right_fork.release()\r\n self.has_forks = False\r\n else:\r\n raise ValueError('%s tried to drop forks it didn\\'t have.'% self.name)","def recoverTree(self, root: Optional[TreeNode]) -> None:\n self.inorder(root)\n self.first.val,self.second.val=self.second.val,self.first.val","def fusion(first_fh, fused_fh, compare_file):\r\n # initialize\r\n ha_seq = \"\"\r\n ha_header = \"\"\r\n # parse through file\r\n for line in first_fh:\r\n # if a > is found assume it is header\r\n if line[0] == \">\":\r\n # ha_header = line\r\n # if the header is found (length > 0)\r\n if len(ha_header) > 0:\r\n # pull needed information from header to make new one\r\n matches = re.findall(\"(Strain Name:[AB]\\/[\\/A-Za-z 0-9()\\\\-_'.]+)\", ha_header)\r\n subtype_match = re.findall(\"(Subtype:[A-Za-z0-9]+)\", ha_header)\r\n organ = re.findall(\"(Organism:[\\/A-Za-z 0-9()\\\\-_'.]+)\", ha_header)\r\n ha_header = \">\" + organ[0] + \"|\" + matches[0] + \"|\" + subtype_match[0]\r\n # print(ha_header)\r\n # Call find_match function, input the file to search and the new header created.\r\n na_header, na_seq = find_match(compare_file, ha_header)\r\n # if return is equal then write to new file with two sequences fused\r\n if na_header == ha_header:\r\n write_data_2(fused_fh, ha_header, ha_seq.strip() + \"\\n\" + na_seq.strip())\r\n # reset variables\r\n ha_header = line\r\n ha_seq = \"\"\r\n\r\n else:\r\n # if it is part of the sequence\r\n ha_seq = ha_seq + line\r\n\r\n # To return/write the last entries in the files, won't get written in loop\r\n matches = re.findall(\"(Strain Name:[AB]\\/[\\/A-Za-z 0-9()\\\\-_'.]+)\", ha_header)\r\n subtype_match = re.findall(\"(Subtype:[A-Za-z0-9]+)\", ha_header)\r\n organ = re.findall(\"(Organism:[\\/A-Za-z 0-9()\\\\-_'.]+)\", ha_header)\r\n ha_header = \">\" + organ[0] + \"|\" + matches[0] + \"|\" + subtype_match[0]\r\n na_header, na_seq = find_match(compare_file, ha_header)\r\n if na_header == ha_header:\r\n # print(\"matches2\")\r\n # print(ha_header)\r\n write_data_2(fused_fh, ha_header, ha_seq.strip() + \"\\n\" + na_seq.strip())\r\n\r\n # Close Files\r\n first_fh.close()\r\n fused_fh.close()","def copy_from_other(self, other):\n super(RabjDict, self).copy_from_other(other)\n self.rabjcallable = other.rabjcallable","def replace(self, other_cache):\n # This is used in avant-idle to replace the content of the cache\n # in a process (where no storage normally takes place) by\n # that of another where the actual caching of the source is done.\n self.cache.clear()\n for key in other_cache:\n self.add(key, other_cache[key])","def normalize(self):\n queue = {self.entry_point}\n visited = set()\n while queue:\n root = queue.pop()\n visited.add(root)\n for child in root.children:\n if child not in visited:\n queue.add(child)\n unreachable = self.blocks - visited\n for block in unreachable:\n block.detach()\n visited.remove(self.entry_point)\n for block in visited:\n if block.empty():\n for parent in block.parents: # Re-parent\n for child in block.children:\n parent.add_child(child)\n block.detach()\n unreachable.add(block)\n self.blocks -= unreachable","def set_second_incident_node(self, second_incident_node):\n # overwrite the existing second incident node with the input second incident Node object\n self.second_incident_node = second_incident_node","def modify_d2(d1, d2):\n val_list = [i for i in d2.keys()]\n \n for key in val_list:\n for i in range(len(d2[key])):\n try:\n val = d1[d2[key][i][2]]\n d2[key][i][2] = val\n if None in d2[key][i]:\n d2[key][i].remove(None)\n except:\n pass\n return d2","def detect_cut(self, second_iteration=False):\r\n if self.dfg:\r\n # print(\"\\n\\n\")\r\n par_cut = self.detect_parallel_cut()\r\n conc_cut = self.detect_concurrent_cut()\r\n seq_cut = self.detect_sequential_cut()\r\n loop_cut = self.detect_loop_cut()\r\n\r\n if par_cut[0]:\r\n union_acti_comp = set()\r\n for comp in par_cut[1]:\r\n union_acti_comp = union_acti_comp.union(comp)\r\n diff_acti_comp = set(self.activities).difference(union_acti_comp)\r\n\r\n for act in diff_acti_comp:\r\n par_cut[1] = add_to_most_probable_component(par_cut[1], act, self.ingoing, self.outgoing)\r\n\r\n for comp in par_cut[1]:\r\n new_dfg = filter_dfg_on_act(self.dfg, comp)\r\n self.detected_cut = \"parallel\"\r\n self.children.append(Subtree(new_dfg, self.initial_dfg, comp, self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n else:\r\n if conc_cut[0]:\r\n for comp in conc_cut[1]:\r\n new_dfg = filter_dfg_on_act(self.dfg, comp)\r\n self.detected_cut = \"concurrent\"\r\n self.children.append(Subtree(new_dfg, self.initial_dfg, comp, self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n else:\r\n if seq_cut[0]:\r\n dfg1 = filter_dfg_on_act(self.dfg, seq_cut[1])\r\n dfg2 = filter_dfg_on_act(self.dfg, seq_cut[2])\r\n self.detected_cut = \"sequential\"\r\n self.children.append(\r\n Subtree(dfg1, self.initial_dfg, seq_cut[1], self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n self.children.append(\r\n Subtree(dfg2, self.initial_dfg, seq_cut[2], self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n else:\r\n if loop_cut[0]:\r\n dfg1 = filter_dfg_on_act(self.dfg, loop_cut[1])\r\n dfg2 = filter_dfg_on_act(self.dfg, loop_cut[2])\r\n self.detected_cut = \"loopCut\"\r\n self.children.append(\r\n Subtree(dfg1, self.initial_dfg, loop_cut[1], self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n self.children.append(\r\n Subtree(dfg2, self.initial_dfg, loop_cut[2], self.counts, self.rec_depth + 1,\r\n noise_threshold=self.noise_threshold))\r\n else:\r\n if self.noise_threshold > 0:\r\n if not second_iteration:\r\n self.initialize_tree(self.dfg, self.initial_dfg, None, second_iteration=True)\r\n else:\r\n pass\r\n self.detected_cut = \"flower\"\r\n else:\r\n self.detected_cut = \"base_concurrent\"","def _process_last(self, first, second):\n if not self.can_combine(first, second):\n # no combining\n self.combined.append(first)\n self.combined.append(second)\n else:\n # combine and terminate\n self.move_cursors_to_end(second)\n self.combine_and_select_block(first)","def _fixupChildren(self, ph, alogger):\n name = alogger.name\n namelen = len(name)\n for c in ph.loggerMap.keys():\n #The if means ... if not c.parent.name.startswith(nm)\n if c.parent.name[:namelen] != name:\n alogger.parent = c.parent\n c.parent = alogger","def merge_two_calls(self) -> None:","def breadth_first(self, xy1, xy2):\n tile_col1, tile_row1 = self.the_map.xy_to_cr(xy1[0], xy1[1])\n tile_col2, tile_row2 = self.the_map.xy_to_cr(xy2[0], xy2[1])\n \n successor_to_parent_map = {}\n start_state = (tile_col1, tile_row1)\n successor_to_parent_map[(start_state, None)] = None # (Successor, Action) -> (Parent, Action)\n \n open_list = PriorityQueue()\n open_list.update((start_state, None), 0)\n closed = []\n \n while not open_list.isEmpty():\n current_state, action_to_current_state = open_list.pop()\n \n if current_state == (tile_col2, tile_row2):\n return self.__get_action_path((current_state, action_to_current_state), successor_to_parent_map)\n \n if current_state not in closed:\n for successor_state, action, step_cost in self.__get_successors(current_state):\n open_list.update((successor_state, action), 0)\n \n if successor_state not in closed:\n successor_to_parent_map[(successor_state, action)] = (current_state, action_to_current_state)\n \n closed.append(current_state)\n \n return []","def _transform_sub_mapping(self, cr, uid, external_session, convertion_type, resource, vals, sub_mapping_list,\n mapping, mapping_id, mapping_line_filter_ids=None, defaults=None, context=None):\n if not defaults:\n defaults={}\n ir_model_field_obj = self.pool.get('ir.model.fields')\n for sub_mapping in sub_mapping_list:\n sub_object_name = sub_mapping['child_mapping_id'][1]\n sub_mapping_id = sub_mapping['child_mapping_id'][0]\n if convertion_type == 'from_external_to_openerp':\n from_field = sub_mapping['external_field']\n if not from_field:\n from_field = \"%s_%s\" %(sub_object_name, sub_mapping_id)\n to_field = sub_mapping['internal_field']\n\n elif convertion_type == 'from_openerp_to_external':\n from_field = sub_mapping['internal_field']\n to_field = sub_mapping['external_field'] or 'hidden_field_to_split_%s'%from_field # if the field doesn't have any name we assume at that we will split it\n\n field_value = resource[from_field]\n sub_mapping_obj = self.pool.get(sub_object_name)\n sub_mapping_defaults = sub_mapping_obj._get_default_import_values(cr, uid, external_session, sub_mapping_id, defaults.get(to_field), context=context)\n\n if field_value:\n transform_args = [cr, uid, external_session, convertion_type, field_value]\n transform_kwargs = {\n 'defaults': sub_mapping_defaults,\n 'mapping': mapping,\n 'mapping_id': sub_mapping_id,\n 'mapping_line_filter_ids': mapping_line_filter_ids,\n 'parent_data': vals,\n 'context': context,\n }\n\n if sub_mapping['internal_type'] in ['one2many', 'many2many']:\n if not isinstance(field_value, list):\n transform_args[4] = [field_value]\n if not to_field in vals:\n vals[to_field] = []\n if convertion_type == 'from_external_to_openerp':\n lines = sub_mapping_obj._transform_resources(*transform_args, **transform_kwargs)\n else:\n mapping, sub_mapping_id = self._init_mapping(cr, uid, external_session.referential_id.id, \\\n convertion_type=convertion_type,\n mapping=mapping,\n mapping_id=sub_mapping_id,\n context=context)\n field_to_read = [x['internal_field'] for x in mapping[sub_mapping_id]['mapping_lines']]\n sub_resources = sub_mapping_obj.read(cr, uid, field_value, field_to_read, context=context)\n transform_args[4] = sub_resources\n lines = sub_mapping_obj._transform_resources(*transform_args, **transform_kwargs)\n for line in lines:\n if 'external_id' in line:\n del line['external_id']\n if convertion_type == 'from_external_to_openerp':\n if sub_mapping['internal_type'] == 'one2many':\n #TODO refactor to search the id and alternative keys before the update\n external_id = vals.get('external_id')\n alternative_keys = mapping[mapping_id]['alternative_keys']\n #search id of the parent\n existing_ir_model_data_id, existing_rec_id = \\\n self._get_oeid_from_extid_or_alternative_keys(\n cr, uid, vals, external_id,\n external_session.referential_id.id,\n alternative_keys, context=context)\n vals_to_append = (0, 0, line)\n if existing_rec_id:\n sub_external_id = line.get('external_id')\n if mapping[sub_mapping_id].get('alternative_keys'):\n sub_alternative_keys = list(mapping[sub_mapping_id]['alternative_keys'])\n if self._columns.get(to_field):\n related_field = self._columns[to_field]._fields_id\n elif self._inherit_fields.get(to_field):\n related_field = self._inherit_fields[to_field][2]._fields_id\n sub_alternative_keys.append(related_field)\n line[related_field] = existing_rec_id\n #search id of the sub_mapping related to the id of the parent\n sub_existing_ir_model_data_id, sub_existing_rec_id = \\\n sub_mapping_obj._get_oeid_from_extid_or_alternative_keys(\n cr, uid, line, sub_external_id,\n external_session.referential_id.id,\n sub_alternative_keys, context=context)\n del line[related_field]\n if sub_existing_rec_id:\n vals_to_append = (1, sub_existing_rec_id, line)\n vals[to_field].append(vals_to_append)\n else:\n vals[to_field].append(line)\n\n elif sub_mapping['internal_type'] == 'many2one':\n if convertion_type == 'from_external_to_openerp':\n res = sub_mapping_obj._record_one_external_resource(cr, uid, external_session, field_value,\n defaults=sub_mapping_defaults, mapping=mapping, mapping_id=sub_mapping_id, context=context)\n vals[to_field] = res.get('write_id') or res.get('create_id')\n else:\n sub_resource = sub_mapping_obj.read(cr, uid, field_value[0], context=context)\n transform_args[4] = sub_resource\n vals[to_field] = sub_mapping_obj._transform_one_resource(*transform_args, **transform_kwargs)\n else:\n raise except_osv(_('User Error'),\n _('Error with mapping : %s. Sub mapping can be only apply on one2many, many2one or many2many fields') % (sub_mapping['name'],))\n return vals","def update_inplace_from(self, other):\n self.__dict__ = other.__dict__.copy()","def process_changeroot(self):\n self.__changeroot()","def fuse(self):\n # TODO: Don't fuse unless they have None as the end slants?\n i = 0\n while i < len(self.segments) - 1:\n left = self.segments[i]\n right = self.segments[i + 1]\n if (\n isinstance(left, LineSegment)\n and isinstance(right, LineSegment)\n and left.width == right.width\n and left.color == right.color\n and collinear(left.a, left.b, right.b)\n ):\n fused_segment = left.fused_with(right)\n self.segments[i:i+2] = [fused_segment]\n # Leave i unchanged so fused_segment will be the\n # \"left\" segment next iteration.\n else:\n # Cannot fuse, try the next pair.\n i += 1","def _replace(self, x, y):\n y.parent = x.parent\n if x is self.root:\n self.root = y\n return\n elif x is x.parent.left:\n x.parent.left = y\n else:\n x.parent.right = y\n\n self.update(y, -1)","def copy_structure(self, other_directory):\n pass","def bundle_data_old(\n bundle_data, second_sample_vcf, second_family_vcf, old_timestamp, other_case\n) -> dict:\n _bundle = deepcopy(bundle_data)\n _bundle[\"name\"] = other_case\n _bundle[\"created_at\"] = old_timestamp\n _bundle[\"files\"][0][\"path\"] = str(second_sample_vcf)\n _bundle[\"files\"][1][\"path\"] = str(second_family_vcf)\n return _bundle","def osl_fill_from(self, other):\n #TODO: What about inherited properties?\n for p in self._osl.properties:\n conditional_copy(other, self, p[0])\n return self","def test_field_resolution_single_inheritance_with_child_field_defined(self):\n child_field = ChildWithTheSameField()._get_fields()[\"name\"]\n self.assertEqual(child_field.default, \"C\")","def _shrink_secondary(self, amt):\n self._resize_secondary(-amt)","def detect_cut(self, second_iteration=False):\n if pkgutil.find_loader(\"networkx\"):\n import networkx as nx\n else:\n msg = \"networkx is not available. inductive miner cannot be used!\"\n logging.error(msg)\n raise Exception(msg)\n\n if self.dfg:\n\n this_nx_graph = transform_dfg_to_directed_nx_graph(self.dfg, activities=self.activities)\n conn_components = detection_utils.get_connected_components(self.ingoing, self.outgoing, self.activities)\n strongly_connected_components = [list(x) for x in nx.strongly_connected_components(this_nx_graph)]\n\n xor_cut = self.detect_xor_cut(conn_components, this_nx_graph, strongly_connected_components)\n\n if xor_cut[0]:\n for comp in xor_cut[1]:\n new_dfg = filter_dfg_on_act(self.dfg, comp)\n self.detected_cut = \"xor\"\n self.children.append(\n SubtreeDFGBased(new_dfg, self.master_dfg, self.initial_dfg, comp, self.counts,\n self.rec_depth + 1,\n noise_threshold=self.noise_threshold,\n initial_start_activities=self.initial_start_activities,\n initial_end_activities=self.initial_end_activities))\n else:\n seq_cut = self.detect_sequential_cut(conn_components, this_nx_graph, strongly_connected_components)\n if seq_cut[0]:\n self.detected_cut = \"sequential\"\n for child in seq_cut[1]:\n dfg_child = filter_dfg_on_act(self.dfg, child)\n self.children.append(\n SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child, self.counts,\n self.rec_depth + 1,\n noise_threshold=self.noise_threshold,\n initial_start_activities=self.initial_start_activities,\n initial_end_activities=self.initial_end_activities))\n self.put_skips_in_seq_cut()\n else:\n par_cut = self.detect_parallel_cut(conn_components, this_nx_graph, strongly_connected_components)\n if par_cut[0]:\n self.detected_cut = \"parallel\"\n for comp in par_cut[1]:\n new_dfg = filter_dfg_on_act(self.dfg, comp)\n self.children.append(\n SubtreeDFGBased(new_dfg, self.master_dfg, new_dfg, comp, self.counts,\n self.rec_depth + 1,\n noise_threshold=self.noise_threshold,\n initial_start_activities=self.initial_start_activities,\n initial_end_activities=self.initial_end_activities))\n else:\n loop_cut = self.detect_loop_cut(conn_components, this_nx_graph, strongly_connected_components)\n if loop_cut[0]:\n if loop_cut[2]:\n self.detected_cut = \"loopCut\"\n for index_enum, child in enumerate(loop_cut[1]):\n dfg_child = filter_dfg_on_act(self.dfg, child)\n next_subtree = SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child,\n self.counts, self.rec_depth + 1,\n noise_threshold=self.noise_threshold,\n initial_start_activities=self.initial_start_activities,\n initial_end_activities=self.initial_end_activities)\n if loop_cut[3]:\n next_subtree.must_insert_skip = True\n self.children.append(next_subtree)\n else:\n self.detected_cut = \"sequential\"\n self.need_loop_on_subtree = True\n for index_enum, child in enumerate(loop_cut[1]):\n dfg_child = filter_dfg_on_act(self.dfg, child)\n next_subtree = SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child,\n self.counts, self.rec_depth + 1,\n noise_threshold=self.noise_threshold,\n initial_start_activities=self.initial_start_activities,\n initial_end_activities=self.initial_end_activities)\n self.children.append(next_subtree)\n next_subtree.must_insert_skip = True\n else:\n if self.noise_threshold > 0:\n if not second_iteration:\n self.initialize_tree(self.dfg, self.initial_dfg, None, second_iteration=True)\n else:\n self.detected_cut = \"flower\"\n else:\n self.detected_cut = \"flower\"\n\n else:\n self.detected_cut = \"base_xor\"","def __isub__(self, other):\n\t\t#print(\"isub\")\n\t\t# merge other branch\n\t\tself.graph.update(other.graph)\n\t\tself.bottoms.update(other.bottoms)\n\t\tself.output_shape.update(other.output_shape)\n\t\tlayer_name = \"sub_{}\".format(len(self.graph))\n\t\tself.graph[layer_name] = layer_name\n\t\tself.bottoms[layer_name] = [self.cur_id, other.cur_id]\n\t\tself.output_shape[layer_name] = self.cur_tensor.size()\n\t\tself.cur_id = layer_name\n\t\t# save memory\n\t\tdel other\n\t\treturn self","def project(self, other, normalized=...):\n ...","def breadth_first_update(self, extra_roots=[], extra_updated=set()):\n queue = []\n updated = extra_updated\n for k in self.__node_dict.keys():\n if len(self.__node_dict[k].inputs) == 0:\n queue.append(self.__node_dict[k])\n queue.extend(extra_roots)\n while (len(queue) != 0):\n node_to_update = queue.pop(0)\n # print('update {}'.format(node_to_update.uid))\n if node_to_update not in updated:\n node_to_update.update()\n updated.add(node_to_update)\n for element in node_to_update.outputs:\n child = element['to_node']\n if all([i['from_node'] in updated for i in child.inputs]):\n queue.append(child)\n # print('----done----')","def pick_second(self, x, y):\n\n return self.cast(y, x.type.combine(y.type))","def ancestor(self, fc2):\n\n acache = {}\n\n # prime the ancestor cache for the working directory\n for c in (self, fc2):\n if c._filerev == None:\n pl = [(n.path(), n.filenode()) for n in c.parents()]\n acache[(c._path, None)] = pl\n\n flcache = {self._repopath:self._filelog, fc2._repopath:fc2._filelog}\n def parents(vertex):\n if vertex in acache:\n return acache[vertex]\n f, n = vertex\n if f not in flcache:\n flcache[f] = self._repo.file(f)\n fl = flcache[f]\n pl = [(f, p) for p in fl.parents(n) if p != nullid]\n re = fl.renamed(n)\n if re:\n pl.append(re)\n acache[vertex] = pl\n return pl\n\n a, b = (self._path, self._filenode), (fc2._path, fc2._filenode)\n v = ancestor.ancestor(a, b, parents)\n if v:\n f, n = v\n return filectx(self._repo, f, fileid=n, filelog=flcache[f])\n\n return None","def replace_values(dfg1, dfg2):\r\n for edge in dfg1:\r\n if edge in dfg2:\r\n dfg1[edge] = dfg2[edge]\r\n return dfg1","def decimate_to_fs2(st, fs2):\n if fs2 is not None:\n for tr in st:\n fs = tr.stats.sampling_rate\n factor = int(round(fs/fs2))\n tr.decimate(factor=factor)\n return st","def fixture_second_bundle_data(\n bundle_data, second_sample_vcf, second_family_vcf, second_timestamp\n) -> dict:\n second_bundle = deepcopy(bundle_data)\n second_bundle[\"created_at\"] = second_timestamp\n second_bundle[\"files\"][0][\"path\"] = str(second_sample_vcf)\n second_bundle[\"files\"][1][\"path\"] = str(second_family_vcf)\n return second_bundle","def merge_contextual(self, other):\n # TODO: This is currently dependent on our data model? Make more robust to schema changes\n # Currently we assume all lists at Compound level, with 1 further potential nested level of lists\n for k in self.keys():\n # print('key: %s' % k)\n for item in self[k]:\n # print('item: %s' % item)\n for other_item in other.get(k, []):\n # Skip text properties (don't merge names, labels, roles)\n if isinstance(other_item, six.text_type):\n continue\n for otherk in other_item.keys():\n if isinstance(other_item[otherk], list):\n if len(other_item[otherk]) > 0 and len(item[otherk]) > 0:\n other_nested_item = other_item[otherk][0]\n for othernestedk in other_nested_item.keys():\n for nested_item in item[otherk]:\n if not nested_item[othernestedk]:\n nested_item[othernestedk] = other_nested_item[othernestedk]\n elif not item[otherk]:\n item[otherk] = other_item[otherk]\n log.debug('Result: %s' % self.serialize())\n return self","def copy_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.copy_from(other.parent)\n self.isolated_names = copy.copy(other.isolated_names)\n self.modified = copy.copy(other.modified)\n self.read = copy.copy(other.read)\n self.deleted = copy.copy(other.deleted)\n self.bound = copy.copy(other.bound)\n self.annotations = copy.copy(other.annotations)\n self.params = copy.copy(other.params)","def merge_forest(self, forest):\n\t\tif len(forest) == 1:\n\t\t\treturn forest[0]\n\n\t\tfinal_tree = forest.pop()\n\t\ttrees_to_process = forest\n\t\twhile not len(trees_to_process) == 0:\n\t\t\ttree_in_question = trees_to_process.pop(0)\n\t\t\tif final_tree.contains(tree_in_question.value):\n\t\t\t\tnodes_to_process = [final_tree]\n\t\t\t\twhile not len(nodes_to_process) == 0:\n\t\t\t\t\tnode_in_question = nodes_to_process.pop()\n\t\t\t\t\tif node_in_question.value == tree_in_question.value:\n\t\t\t\t\t\tnode_in_question.children += [tree_in_question]\n\t\t\t\t\t\tbreak\n\t\t\t\t\telse:\n\t\t\t\t\t\tif not len(node_in_question.children) == 0:\n\t\t\t\t\t\t\tnodes_to_process += node_in_question.children\n\t\t\telse:\n\t\t\t\ttrees_to_process += [final_tree]\n\t\t\t\tfinal_tree = tree_in_question\n\t\treturn final_tree","def test_field_resolution_multiple_inheritance_with_child_field_defined(self):\n child_field = ChildWithMultipleParentsAndTheSameField()._get_fields()[\"name\"]\n self.assertEqual(child_field.default, \"C\")","def _grow_secondary(self, amt):\n self._resize_secondary(amt)","def process_other_feature_line(self, line):\n kwargs = self.extract_other_feature_args(line)\n if not kwargs:\n return\n parent_id = kwargs['parent_id']\n if parent_id not in self.mrnas:\n self.orphans.append(line)\n return\n parent_mrna = self.mrnas[parent_id]\n parent_mrna.other_features.append(GenePart(**kwargs))","def _merge_inplace(self, other):\n if other is None:\n yield\n else:\n # don't include indexes in priority_vars, because we didn't align\n # first\n priority_vars = OrderedDict(\n (k, v) for k, v in self.variables.items() if k not in self.dims)\n variables = merge_coords_without_align(\n [self.variables, other.variables], priority_vars=priority_vars)\n yield\n self._update_coords(variables)","def _deduplicate(self):\n if self._clean:\n return\n\n sorted_entries = sorted(\n self._entries, key=lambda entry: (entry.depth, -len(entry.tail))\n )\n\n self._entries = []\n for entry in sorted_entries:\n if any(entry.startswith(p) for p in self._entries):\n continue\n self._entries.append(entry)\n self._clean = True","def _check_other_folding(self, other):\n if isinstance(other, self.__class__)\\\n and (other.folded != self.folded):\n raise ValueError('Cannot operate with a folded Spectrum and an '\n 'unfolded one.')","def fixupSecondaryFileNames(process):\n if not hasattr(process.source, \"secondaryFileNames\"):\n process.source.secondaryFileNames = cms.untracked.vstring()\n return","def resolve(self, vcf_field_key, first_vcf_field_value,\n second_vcf_field_value):\n # type: (str, Union[str, int], Union[str, int]) -> Union[str, int]\n if vcf_field_key == VcfParserConstants.TYPE:\n return self._resolve_type(first_vcf_field_value, second_vcf_field_value)\n elif vcf_field_key == VcfParserConstants.NUM:\n return self._resolve_number(first_vcf_field_value, second_vcf_field_value)\n else:\n # We only care about conflicts in 'num' and 'type' fields.\n return first_vcf_field_value","def _init_child(self,child,path):\n pass","def _resolve_dependency(self, chunks):\n chunks = self._concatenate_inner(chunks, True)\n chunks = self._concatenate_inner(chunks, False)\n return chunks","def handleLFNForMerge(self, mergefile, step):\n\n # First get the output module\n # Do this by finding the name in the step report\n # And then finding that module in the WMStep Helper\n\n outputName = getattr(mergefile, 'module_label', None)\n if not outputName:\n logging.error(\"Attempt to merge directly failed due to \" \\\n + \"No module_label in file.\")\n if outputName.lower() == \"merged\":\n # Don't skip merge for merged files!\n return mergefile\n stepHelper = self.task.getStep(stepName=step)\n outputMod = stepHelper.getOutputModule(moduleName=outputName)\n\n if not outputMod:\n # Then we couldn't get the output module\n logging.error(\"Attempt to directly merge failed \" \\\n + \"due to no output module %s in WMStep\" \\\n % (outputName))\n return mergefile\n\n # Okay, now we should have the output Module\n # Now we just need a second LFN\n\n newBase = getattr(outputMod, 'mergedLFNBase', None)\n oldBase = getattr(outputMod, 'lfnBase', None)\n\n if not newBase:\n # Then we don't have a base to change it to\n logging.error(\"Direct to Merge failed due to no mergedLFNBase in %s\", outputName)\n return mergefile\n\n # Replace the actual LFN base\n oldLFN = getattr(mergefile, 'lfn')\n newLFN = oldLFN.replace(oldBase, newBase)\n\n # Set the file attributes\n setattr(mergefile, 'lfn', newLFN)\n setattr(mergefile, 'merged', True)\n\n # Return the file\n return mergefile","def normalize(self):\n blocks = set(self.blocks)\n queue = set([self.entry_point])\n visited = set()\n while queue:\n root = queue.pop()\n visited.add(root)\n for child in root.children:\n if child not in visited:\n queue.add(child)\n unreachable = blocks - visited\n for block in unreachable:\n block.detach()\n visited.remove(self.entry_point)\n for block in visited:\n if block.empty():\n for parent in block.parents: # Re-parent\n for child in block.children:\n parent.add_child(child)\n block.detach()\n unreachable.add(block)\n blocks -= unreachable\n self.blocks = [block for block in self.blocks if block in blocks]","def first_scf(self):\n\n files, input_dict, structure_with_tags = cp2k_utils.get_dft_inputs(\n self.inputs.dft_params.get_dict(),\n self.inputs.structure,\n \"scf_ot_protocol.yml\",\n self.inputs.protocol.value,\n )\n\n builder = Cp2kCalculation.get_builder()\n builder.structure = orm.StructureData(ase=structure_with_tags)\n builder.code = self.inputs.code\n builder.file = files\n builder.metadata.options = self.ctx.scf_options\n builder.metadata.label = \"scf\"\n builder.metadata.options.parser_name = \"cp2k_advanced_parser\"\n input_dict[\"GLOBAL\"][\"WALLTIME\"] = 86000\n builder.parameters = orm.Dict(input_dict)\n\n future = self.submit(builder)\n self.report(f\"Submitted scf of the initial geometry: {future.pk}\")\n self.to_context(initial_scf=future)","def flip_two(lnk):\n if lnk is not Link.empty and lnk.rest is not Link.empty:\n lnk.first, lnk.rest.first = lnk.rest.first, lnk.first\n flip_two(lnk.rest.rest)","def __ror__(self, other):\n return self._dunder_concat(\n other=other,\n base_class=BaseForecaster,\n composite_class=MultiplexForecaster,\n attr_name=\"forecasters\",\n concat_order=\"right\",\n )","def recombine(parent_1, parent_2, adaptive_mutation):\n\tchild_genotype = blend_crossover(parent_1, parent_2)\n\tif adaptive_mutation:\n\t\tchild_sigma = child_sigma_v4(parent_1, parent_2)\n\telse:\n\t\t# child sigma will be ignored in this case\n\t\tchild_sigma = parent_1.sigma\n\n\t# return new child object\n\treturn Individual(child_genotype, child_sigma)","def pass_combine(firstgroup, secondgroup, xCar, buffer='30'):\n #import ast\n import pandas as pd #\n import geopandas as gpd\n from shapely.geometry import Point\n buffer = float(buffer)\n\n if not \"prev_read\" in secondgroup.columns:\n sgrp = secondgroup.copy()\n secondgroup['prev_read'] = sgrp.loc[:, 'min_read']\n\n ### MAKE GEOPANDAS FRAME OF THE FIRST GROUP PEAKS\n first_geo = [Point(lon, lat) for lon, lat in zip(firstgroup['pk_LON'], firstgroup['pk_LAT'])]\n # crs = {'init': 'epsg:4326'}\n #crs = {'init': 'epsg:32610'}\n crs = 'EPSG:32610'\n\n #if 'geometry' in firstgroup.columns:\n # firstgrp = gpd.GeoDataFrame(firstgroup.drop(columns=['geometry', 'pkGEO']), crs=crs, geometry=first_geo)\n #else:\n # firstgrp = gpd.GeoDataFrame(firstgroup.drop(columns=['pkGEO']), crs=crs, geometry=first_geo)\n firstgrp = gpd.GeoDataFrame(firstgroup[firstgroup.columns.difference(['geometry','pkGEO'])].reset_index(drop=True),crs = crs,geometry=first_geo)\n\n first_buffg = firstgrp.copy()\n first_buff = first_buffg.copy().drop(columns=['geometry'])\n first_buff['geometry'] = first_buffg.apply(lambda x: x.geometry.buffer(0.00001 * buffer), axis=1)\n firstgrp = first_buff.copy()\n\n sec_geo = [Point(lon, lat) for lon, lat in zip(secondgroup['pk_LON'], secondgroup['pk_LAT'])]\n secgrp = gpd.GeoDataFrame(secondgroup.drop(columns=['geometry', 'pkGEO']), crs=crs, geometry=sec_geo)\n\n sec_buffg = secgrp.copy()\n sec_buff = sec_buffg.copy().drop(columns=['geometry'])\n sec_buff['geometry'] = sec_buffg.apply(lambda x: x.geometry.buffer(0.00001 * buffer), axis=1)\n secgrp = sec_buff.copy()\n\n ## choosing the unique OPs from each group\n first_pks = firstgrp.loc[:, ['OP_NUM', 'min_read', 'pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB']].drop_duplicates()\n sec_pks = secgrp.loc[:, ['OP_NUM', 'min_read', 'pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB']].drop_duplicates()\n\n # combining to make one large dataframe of unique OPs\n tot_pks = pd.concat([first_pks, sec_pks])\n\n ### COMBINE EACH GROUP (GEOMETRICALLY) BY THEIR OVERALL NAME (COULD BE VERIFIED)\n first_dis = firstgrp.dissolve(by='min_read', as_index=False)[\n ['min_read', 'geometry', 'recombine', 'verified', 'pass']].copy()\n sec_dis = secgrp.dissolve(by='min_read', as_index=False)[\n ['min_read', 'geometry', 'recombine', 'verified', 'pass']].copy()\n\n gdf_bind_pks = pd.concat([first_dis, sec_dis]).loc[:, ['min_read', 'geometry', 'recombine']]\n gdf_tog = pd.concat([firstgroup.drop(['pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB'], axis=1),\n secondgroup.drop(['pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB'], axis=1)]).copy()\n gdf_tog2 = pd.concat([firstgroup, secondgroup]).copy()\n\n gdf_bind_pks['prev_read'] = gdf_bind_pks.loc[:, 'min_read']\n gdf_tog['prev_read'] = gdf_tog.loc[:, 'min_read']\n if gdf_bind_pks.shape[0] > 1:\n data_overlap = gpd.GeoDataFrame(crs=gdf_bind_pks.crs).copy()\n data_temp = gdf_bind_pks.copy()\n data_temp = data_temp.to_crs(epsg=32610)\n\n for index, row in data_temp.iterrows():\n data_temp1 = data_temp.loc[data_temp.min_read != row.min_read,]\n data_temp1 = data_temp1.to_crs(epsg=32610)\n # check if intersection occured\n overlaps = data_temp1[data_temp1.geometry.overlaps(row.geometry)]['min_read'].tolist()\n if len(overlaps) > 0:\n # compare the area with threshold\n for y in overlaps:\n temp_area = gpd.overlay(data_temp.loc[data_temp.min_read == y,],\n data_temp.loc[data_temp.min_read == row.min_read,], how='intersection')\n temp_area = temp_area.to_crs(epsg=32610)\n temp_area = temp_area.loc[temp_area.geometry.area >= 0]\n # temp_union = gpd.overlay(data_temp.loc[data_temp.PEAK_NUM==y,],data_temp.loc[data_temp.PEAK_NUM==row.PEAK_NUM,],how='union')\n if temp_area.shape[0] > 0:\n temp_union = gpd.overlay(data_temp.loc[data_temp.min_read == y,],\n data_temp.loc[data_temp.min_read == row.min_read,], how='union')\n data_overlap = gpd.GeoDataFrame(pd.concat([temp_union, data_overlap], ignore_index=True),\n crs=data_temp.crs)\n\n if data_overlap.size != 0:\n firstnull = data_overlap[data_overlap.min_read_1.isnull()].copy()\n firstnull.loc[:, 'min_read_1'] = firstnull.loc[:, 'min_read_2']\n\n secnull = data_overlap[data_overlap.min_read_2.isnull()].copy()\n secnull['min_read_2'] = secnull['min_read_1'].copy()\n\n withoutNA = data_overlap.dropna().copy()\n allTog = pd.concat([firstnull, secnull, withoutNA]).reset_index().copy()\n\n over = allTog.copy().drop(columns=['index'])\n over['sorted'] = over.apply(lambda y: sorted([y['min_read_1'], y['min_read_2']]), axis=1).copy()\n over['sorted'] = over.sorted.apply(lambda y: ','.join(y)).copy()\n\n over['same'] = over.apply(lambda x: x.min_read_1 != x.min_read_2, axis=1)\n over = over.loc[over.same == True, :].drop(columns=['same'])\n over = over.copy().drop_duplicates('sorted').reset_index(drop=True)\n\n\n\n over['bothcombine'] = over.apply(lambda x: sorted(check_lst(x.recombine_1) + check_lst(x.recombine_2)),\n axis=1)\n\n over['combined'] = [list(x) for x in list(over.loc[:, ['min_read_1', 'min_read_2']].to_numpy())].copy()\n over['VER_NUM'] = over.apply(lambda y: y.combined, axis=1).copy()\n over['min_val'] = over.apply(lambda y: min(y.combined), axis=1).copy()\n over = over.reset_index().loc[:,\n ['min_read_1', 'min_read_2', 'geometry', 'combined', 'min_val', 'bothcombine']]\n\n new_1 = over.copy().drop(columns=['min_read_2']).rename(columns={'min_read_1': 'min_read'})\n new_2 = over.copy().drop(columns=['min_read_1']).rename(columns={'min_read_2': 'min_read'})\n newtog = pd.concat([new_1, new_2])\n minreads = newtog.min_read.unique().tolist()\n\n if 'prev_read' in gdf_tog2.columns:\n toChange = gdf_tog2[gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry', 'prev_read'])\n elif 'prev_read' not in gdf_tog2.columns:\n toChange = gdf_tog2[gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry'])\n\n toChangecombined = pd.merge(toChange, newtog, on=['min_read']).drop(\n columns=['geometry', 'numtimes', 'verified', 'recombine'])\n toChangecombined = toChangecombined.rename(columns={'min_read': 'prev_read', 'bothcombine': 'recombine'})\n toChangecombined['numtimes'] = toChangecombined.apply(lambda x: count_times(x.recombine, xCar), axis=1)\n\n toChangecombined['verified'] = toChangecombined.apply(lambda x: x.numtimes > 1, axis=1)\n toChangecombined = toChangecombined.rename(columns={'min_val': 'min_read'}).drop(columns=['combined'])\n\n toNotChange = gdf_tog2[~gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry'])\n\n if 'prev_read' in toNotChange.columns:\n toNotChange = toNotChange.drop(columns=['prev_read'])\n toNotChange['prev_read'] = toNotChange.min_read\n elif 'prev_read' not in toNotChange.columns:\n toNotChange.loc[:, 'prev_read'] = gdf_tog2[~gdf_tog2['min_read'].isin(minreads)].min_read\n\n newCombined = pd.concat([toChangecombined, toNotChange])\n elif data_overlap.size == 0:\n newCombined = gdf_tog2.copy()\n if 'prev_read' not in newCombined.columns:\n newCombined.loc[:, 'prev_read'] = gdf_tog2.loc[:, 'min_read']\n elif gdf_bind_pks.shape[0] == 1:\n newCombined = gdf_tog2.copy()\n if 'prev_read' not in newCombined.columns:\n newCombined.loc[:, 'prev_read'] = gdf_tog2.loc[:, 'min_read']\n opCount = newCombined.groupby('OB_EPOCH').count()\n samesies = list(opCount.loc[opCount.numtimes > 1, :].index)\n if len(samesies) == 0:\n smallCombined = newCombined.copy()\n elif len(samesies) != 0:\n smallCombined = newCombined.loc[~newCombined.OB_EPOCH.isin(samesies), :]\n for index, op in enumerate(samesies):\n smalldf = newCombined.loc[newCombined.OB_EPOCH == op, :]\n recombined2 = (list(set([a for b in smalldf.recombine.tolist() for a in b])))\n newminread = min(recombined2)\n smalldf = smalldf.drop(columns=['min_read', 'recombine'])\n smalldf['min_read'] = smalldf.apply(lambda x: newminread, axis=1)\n smalldf = smalldf.drop_duplicates().reset_index(drop=True)\n smalldf['recombine'] = smalldf.apply(lambda x: recombined2, axis=1)\n smallCombined = pd.concat([smallCombined, smalldf]).reset_index(drop=True)\n return (smallCombined)","def merge_bom(self, other_bom):\n for bom_entry in other_bom.entries():\n self.create_and_add_entry(**bom_entry.attrs)","def regrid_cfsv2(input_forcings, config_options, wrf_hydro_geo_meta, mpi_config):\n # If the expected file is missing, this means we are allowing missing files, simply\n # exit out of this routine as the regridded fields have already been set to NDV.\n if not os.path.isfile(input_forcings.file_in2):\n return\n\n # Check to see if the regrid complete flag for this\n # output time step is true. This entails the necessary\n # inputs have already been regridded and we can move on.\n if input_forcings.regridComplete:\n # Check to see if we are running NWM-custom interpolation/bias\n # correction on incoming CFSv2 data. Because of the nature, we\n # need to regrid bias-corrected data every hour.\n if mpi_config.rank == 0:\n config_options.statusMsg = \"No need to read in new CFSv2 data at this time.\"\n err_handler.log_msg(config_options, mpi_config)\n return\n\n # Create a path for a temporary NetCDF file\n input_forcings.tmpFile = config_options.scratch_dir + \"/\" + \"CFSv2_TMP-{}.nc\".format(mkfilename())\n err_handler.check_program_status(config_options, mpi_config)\n\n if input_forcings.fileType != NETCDF:\n\n # This file shouldn't exist.... but if it does (previously failed\n # execution of the program), remove it.....\n if mpi_config.rank == 0:\n if os.path.isfile(input_forcings.tmpFile):\n config_options.statusMsg = \"Found old temporary file: \" + \\\n input_forcings.tmpFile + \" - Removing.....\"\n err_handler.log_warning(config_options, mpi_config)\n try:\n os.remove(input_forcings.tmpFile)\n except OSError as err:\n config_options.errMsg = \"Unable to remove previous temporary file: \" \\\n + input_forcings.tmpFile + str(err)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n fields = []\n for force_count, grib_var in enumerate(input_forcings.grib_vars):\n if mpi_config.rank == 0:\n config_options.statusMsg = \"Converting CFSv2 Variable: \" + grib_var\n err_handler.log_msg(config_options, mpi_config)\n fields.append(':' + grib_var + ':' +\n input_forcings.grib_levels[force_count] + ':'\n + str(input_forcings.fcst_hour2) + \" hour fcst:\")\n fields.append(\":(HGT):(surface):\")\n\n # Create a temporary NetCDF file from the GRIB2 file.\n cmd = '$WGRIB2 -match \"(' + '|'.join(fields) + ')\" ' + input_forcings.file_in2 + \\\n \" -netcdf \" + input_forcings.tmpFile\n id_tmp = ioMod.open_grib2(input_forcings.file_in2, input_forcings.tmpFile, cmd,\n config_options, mpi_config, inputVar=None)\n err_handler.check_program_status(config_options, mpi_config)\n else:\n create_link(\"CFSv2\", input_forcings.file_in2, input_forcings.tmpFile, config_options, mpi_config)\n id_tmp = ioMod.open_netcdf_forcing(input_forcings.tmpFile, config_options, mpi_config)\n\n for force_count, grib_var in enumerate(input_forcings.grib_vars):\n if mpi_config.rank == 0:\n config_options.statusMsg = \"Processing CFSv2 Variable: \" + grib_var\n err_handler.log_msg(config_options, mpi_config)\n\n calc_regrid_flag = check_regrid_status(id_tmp, force_count, input_forcings,\n config_options, wrf_hydro_geo_meta, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n if calc_regrid_flag:\n if mpi_config.rank == 0:\n config_options.statusMsg = \"Calculate CFSv2 regridding weights.\"\n err_handler.log_msg(config_options, mpi_config)\n\n calculate_weights(id_tmp, force_count, input_forcings, config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Read in the RAP height field, which is used for downscaling purposes.\n # if mpi_config.rank == 0:\n # config_options.statusMsg = \"Reading in CFSv2 elevation data.\"\n # err_handler.log_msg(config_options, mpi_config)\n #\n # cmd = \"$WGRIB2 \" + input_forcings.file_in2 + \" -match \" + \\\n # \"\\\":(HGT):(surface):\\\" \" + \\\n # \" -netcdf \" + input_forcings.tmpFileHeight\n # id_tmp_height = ioMod.open_grib2(input_forcings.file_in2, input_forcings.tmpFileHeight,\n # cmd, config_options, mpi_config, 'HGT_surface')\n # err_handler.check_program_status(config_options, mpi_config)\n\n # Regrid the height variable.\n var_tmp = None\n if mpi_config.rank == 0:\n try:\n var_tmp = id_tmp.variables['HGT_surface'][0, :, :]\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to extract HGT_surface from file: \" \\\n + input_forcings.file_in2 + \" (\" + str(err) + \")\"\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n var_sub_tmp = mpi_config.scatter_array(input_forcings, var_tmp, config_options)\n err_handler.check_program_status(config_options, mpi_config)\n\n try:\n input_forcings.esmf_field_in.data[:, :] = var_sub_tmp\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to place CFSv2 elevation data into the ESMF field object: \" + str(err)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n if mpi_config.rank == 0:\n config_options.statusMsg = \"Regridding CFSv2 elevation data to the WRF-Hydro domain.\"\n err_handler.log_msg(config_options, mpi_config)\n\n try:\n input_forcings.esmf_field_out = input_forcings.regridObj(input_forcings.esmf_field_in,\n input_forcings.esmf_field_out)\n except ValueError as ve:\n config_options.errMsg = \"Unable to regrid CFSv2 elevation data to the WRF-Hydro domain: \" + str(ve)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Set any pixel cells outside the input domain to the global missing value.\n try:\n input_forcings.esmf_field_out.data[np.where(input_forcings.regridded_mask == 0)] = \\\n config_options.globalNdv\n except (ValueError, ArithmeticError) as npe:\n config_options.errMsg = \"Unable to run mask calculation on CFSv2 elevation data: \" + str(npe)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n try:\n input_forcings.height[:, :] = input_forcings.esmf_field_out.data\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to extract CFSv2 regridded elevation data from ESMF field: \" + str(err)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Close the temporary NetCDF file and remove it.\n # if mpi_config.rank == 0:\n # try:\n # id_tmp_height.close()\n # except OSError:\n # config_options.errMsg = \"Unable to close temporary file: \" + input_forcings.tmpFileHeight\n # err_handler.log_critical(config_options, mpi_config)\n # err_handler.check_program_status(config_options, mpi_config)\n #\n # if mpi_config.rank == 0:\n # try:\n # os.remove(input_forcings.tmpFileHeight)\n # except OSError:\n # config_options.errMsg = \"Unable to remove temporary file: \" + input_forcings.tmpFileHeight\n # err_handler.log_critical(config_options, mpi_config)\n # err_handler.check_program_status(config_options, mpi_config)\n\n # Regrid the input variables.\n var_tmp = None\n if mpi_config.rank == 0:\n if not config_options.runCfsNldasBiasCorrect:\n config_options.statusMsg = \"Regridding CFSv2 variable: \" + \\\n input_forcings.netcdf_var_names[force_count]\n err_handler.log_msg(config_options, mpi_config)\n try:\n var_tmp = id_tmp.variables[input_forcings.netcdf_var_names[force_count]][0, :, :]\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to extract: \" + input_forcings.netcdf_var_names[force_count] + \\\n \" from file: \" + input_forcings.tmpFile + \" (\" + str(err) + \")\"\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Scatter the global CFSv2 data to the local processors.\n var_sub_tmp = mpi_config.scatter_array(input_forcings, var_tmp, config_options)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Assign local CFSv2 data to the input forcing object.. IF..... we are running the\n # bias correction. These grids are interpolated in a separate routine, AFTER bias\n # correction has taken place.\n if config_options.runCfsNldasBiasCorrect:\n if input_forcings.coarse_input_forcings1 is None: # and config_options.current_output_step == 1:\n # if not np.any(input_forcings.coarse_input_forcings1) and not \\\n # np.any(input_forcings.coarse_input_forcings2) and \\\n # ConfigOptions.current_output_step == 1:\n # We need to create NumPy arrays to hold the CFSv2 global data.\n input_forcings.coarse_input_forcings1 = np.empty([8, var_sub_tmp.shape[0], var_sub_tmp.shape[1]],\n np.float64)\n\n if input_forcings.coarse_input_forcings2 is None: # and config_options.current_output_step == 1:\n # if not np.any(input_forcings.coarse_input_forcings1) and not \\\n # np.any(input_forcings.coarse_input_forcings2) and \\\n # ConfigOptions.current_output_step == 1:\n # We need to create NumPy arrays to hold the CFSv2 global data.\n input_forcings.coarse_input_forcings2 = np.empty([8, var_sub_tmp.shape[0], var_sub_tmp.shape[1]],\n np.float64)\n\n try:\n input_forcings.coarse_input_forcings2[input_forcings.input_map_output[force_count], :, :] = var_sub_tmp\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to place local CFSv2 input variable: \" + \\\n input_forcings.netcdf_var_names[force_count] + \\\n \" into local numpy array. (\" + str(err) + \")\"\n # except TypeError:\n # print(\"DEBUG: \", input_forcings.coarse_input_forcings2, input_forcings.input_map_output, force_count)\n\n if config_options.current_output_step == 1:\n input_forcings.coarse_input_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\n input_forcings.coarse_input_forcings2[input_forcings.input_map_output[force_count], :, :]\n else:\n input_forcings.coarse_input_forcings2 = None\n input_forcings.coarse_input_forcings1 = None\n err_handler.check_program_status(config_options, mpi_config)\n\n # Only regrid the current files if we did not specify the NLDAS2 NWM bias correction, which needs to take place\n # first before any regridding can take place. That takes place in the bias-correction routine.\n if not config_options.runCfsNldasBiasCorrect:\n try:\n input_forcings.esmf_field_in.data[:, :] = var_sub_tmp\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to place CFSv2 forcing data into temporary ESMF field: \" + str(err)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n try:\n input_forcings.esmf_field_out = input_forcings.regridObj(input_forcings.esmf_field_in,\n input_forcings.esmf_field_out)\n except ValueError as ve:\n config_options.errMsg = \"Unable to regrid CFSv2 variable: \" + \\\n input_forcings.netcdf_var_names[force_count] + \" (\" + str(ve) + \")\"\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # Set any pixel cells outside the input domain to the global missing value.\n try:\n input_forcings.esmf_field_out.data[np.where(input_forcings.regridded_mask == 0)] = \\\n config_options.globalNdv\n except (ValueError, ArithmeticError) as npe:\n config_options.errMsg = \"Unable to run mask calculation on CFSv2 variable: \" + \\\n input_forcings.netcdf_var_names[force_count] + \" (\" + str(npe) + \")\"\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n try:\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :] = \\\n input_forcings.esmf_field_out.data\n except (ValueError, KeyError, AttributeError) as err:\n config_options.errMsg = \"Unable to extract ESMF field data for CFSv2: \" + str(err)\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n # If we are on the first timestep, set the previous regridded field to be\n # the latest as there are no states for time 0.\n if config_options.current_output_step == 1:\n input_forcings.regridded_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :]\n err_handler.check_program_status(config_options, mpi_config)\n else:\n # Set regridded arrays to dummy values as they are regridded later in the bias correction routine.\n input_forcings.regridded_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\n config_options.globalNdv\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :] = \\\n config_options.globalNdv\n\n # Close the temporary NetCDF file and remove it.\n if mpi_config.rank == 0:\n try:\n id_tmp.close()\n except OSError:\n config_options.errMsg = \"Unable to close NetCDF file: \" + input_forcings.tmpFile\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)\n\n if mpi_config.rank == 0:\n try:\n os.remove(input_forcings.tmpFile)\n except OSError:\n config_options.errMsg = \"Unable to remove NetCDF file: \" + input_forcings.tmpFile\n err_handler.log_critical(config_options, mpi_config)\n err_handler.check_program_status(config_options, mpi_config)","def _finish_init(self):\n\n # This is usually done in set_other(), but we already set it as part of\n # the constructor.\n self.this_branch.fetch(self.other_branch,\n last_revision=self.other_basis)","def merge_new_domain (cls, base, nffg, log=logging.getLogger(\"MERGE\")):\n # Get new domain name\n domain = cls.detect_domains(nffg=nffg)\n if len(domain) == 0:\n log.error(\"No domain detected in new %s!\" % nffg)\n return\n if len(domain) > 1:\n log.warning(\"Multiple domain name detected in new %s!\" % nffg)\n return\n # Copy infras\n log.debug(\"Merge domain: %s resource info into %s...\" % (domain.pop(),\n base.id))\n # Check if the infra with given id is already exist in the base NFFG\n for infra in nffg.infras:\n if infra.id not in base:\n c_infra = base.add_infra(infra=deepcopy(infra))\n log.debug(\"Copy infra node: %s\" % c_infra)\n else:\n log.warning(\"Infra node: %s does already exist in %s. Skip adding...\" %\n (infra, base))\n # Copy NFs\n for nf in nffg.nfs:\n if nf.id not in base:\n c_nf = base.add_nf(nf=deepcopy(nf))\n log.debug(\"Copy NF node: %s\" % c_nf)\n else:\n log.warning(\"NF node: %s does already exist in %s. Skip adding...\" %\n (nf, base))\n # Copy SAPs\n for sap_id in [s.id for s in nffg.saps]:\n if sap_id in [s.id for s in base.saps]:\n # Found inter-domain SAP\n log.debug(\"Found Inter-domain SAP: %s\" % sap_id)\n # Search outgoing links from SAP, should be only one\n b_links = [l for u, v, l in base.real_out_edges_iter(sap_id)]\n if len(b_links) < 1:\n log.warning(\n \"SAP is not connected to any node! Maybe you forgot to call \"\n \"duplicate_static_links?\")\n return\n elif 1 < len(b_links):\n log.warning(\n \"Inter-domain SAP should have one and only one connection to the \"\n \"domain! Using only the first connection.\")\n continue\n # Get inter-domain port in base NFFG\n domain_port_dov = b_links[0].dst\n sap_port_dov = b_links[0].src\n log.debug(\"Found inter-domain port: %s\" % domain_port_dov)\n # Search outgoing links from SAP, should be only one\n n_links = [l for u, v, l in nffg.real_out_edges_iter(sap_id)]\n if len(n_links) < 1:\n log.warning(\n \"SAP is not connected to any node! Maybe you forgot to call \"\n \"duplicate_static_links?\")\n return\n elif 1 < len(n_links):\n log.warning(\n \"Inter-domain SAP should have one and only one connection to the \"\n \"domain! Using only the first connection.\")\n continue\n # Get port and Infra id's in nffg NFFG\n p_id = n_links[0].dst.id\n n_id = n_links[0].dst.node.id\n # Get the inter-domain port from already copied Infra\n domain_port_nffg = base.network.node[n_id].ports[p_id]\n sap_port_nffg = n_links[0].src\n log.debug(\"Found inter-domain port: %s\" % domain_port_nffg)\n\n # # If the two resource value does not match\n # if sap_port_dov.delay != sap_port_nffg.delay:\n # if sap_port_dov.delay is None:\n # # If first is None the other can not be None\n # s_delay = sap_port_nffg.delay\n # elif sap_port_nffg.delay is None:\n # # If second is None the other can not be None\n # s_delay = sap_port_dov.delay\n # else:\n # # Both values are valid, but different\n # s_delay = max(sap_port_dov.delay, sap_port_nffg.delay)\n # log.warning(\n # \"Inter-domain delay values (%s, %s) are set but do not match!\"\n # \" Use max: %s\" % (sap_port_dov.delay, sap_port_nffg.delay,\n # s_delay))\n # else:\n # # Both value match: ether valid values or Nones --> choose first\n # value\n # s_delay = sap_port_dov.delay\n #\n # # If the two resource value does not match\n # if sap_port_dov.bandwidth != sap_port_nffg.bandwidth:\n # if sap_port_dov.bandwidth is None:\n # # If first is None the other can not be None\n # s_bandwidth = sap_port_nffg.bandwidth\n # elif sap_port_nffg.bandwidth is None:\n # # If second is None the other can not be None\n # s_bandwidth = sap_port_dov.bandwidth\n # else:\n # # Both values are valid, but different\n # s_bandwidth = min(sap_port_dov.bandwidth,\n # sap_port_nffg.bandwidth)\n # log.warning(\n # \"Inter-domain bandwidth values (%s, %s) are set but do not\n # match!\"\n # \" Use min: %s\" % (sap_port_dov.bandwidth,\n # sap_port_nffg.bandwidth, s_bandwidth))\n # else:\n # # Both value match: ether valid values or Nones --> choose first\n # value\n # s_bandwidth = sap_port_dov.bandwidth\n #\n # log.debug(\"Detected inter-domain resource values: delay: %s, \"\n # \"bandwidth: %s\" % (s_delay, s_bandwidth))\n\n # Copy inter-domain port properties/values for redundant storing\n if len(domain_port_nffg.properties) > 0:\n domain_port_dov.properties.update(domain_port_nffg.properties)\n log.debug(\"Copy inter-domain port properties: %s\" %\n domain_port_dov.properties)\n elif len(domain_port_dov.properties) > 0:\n domain_port_nffg.properties.update(domain_port_dov.properties)\n log.debug(\"Copy inter-domain port properties: %s\" %\n domain_port_nffg.properties)\n # Ensure to add sap tag to inter domain ports\n if 'sap' not in domain_port_dov.properties:\n domain_port_dov.add_property(\"sap\", sap_id)\n if 'sap' not in domain_port_nffg.properties:\n domain_port_nffg.add_property(\"sap\", sap_id)\n # Signal Inter-domain port type\n domain_port_dov.add_property(\"type\", \"inter-domain\")\n domain_port_nffg.add_property(\"type\", \"inter-domain\")\n\n # Copy SAP port values into the infra ports\n domain_port_dov.name = sap_port_dov.name\n domain_port_dov.sap = sap_port_dov.sap\n domain_port_dov.capability = sap_port_dov.capability\n domain_port_dov.technology = sap_port_dov.technology\n domain_port_dov.delay = sap_port_dov.delay\n domain_port_dov.bandwidth = sap_port_dov.bandwidth\n domain_port_dov.cost = sap_port_dov.cost\n domain_port_dov.controller = sap_port_dov.controller\n domain_port_dov.orchestrator = sap_port_dov.orchestrator\n domain_port_dov.l2 = sap_port_dov.l2\n domain_port_dov.l4 = sap_port_dov.l4\n for l3 in sap_port_dov.l3:\n domain_port_dov.l3.append(l3.copy())\n domain_port_dov.metadata.update(sap_port_dov.metadata)\n\n domain_port_nffg.name = sap_port_nffg.name\n domain_port_nffg.sap = sap_port_nffg.sap\n domain_port_nffg.capability = sap_port_nffg.capability\n domain_port_nffg.technology = sap_port_nffg.technology\n domain_port_nffg.delay = sap_port_nffg.delay\n domain_port_nffg.bandwidth = sap_port_nffg.bandwidth\n domain_port_nffg.cost = sap_port_nffg.cost\n domain_port_nffg.controller = sap_port_nffg.controller\n domain_port_nffg.orchestrator = sap_port_nffg.orchestrator\n domain_port_nffg.l2 = sap_port_nffg.l2\n domain_port_nffg.l4 = sap_port_nffg.l4\n for l3 in sap_port_nffg.l3:\n domain_port_nffg.l3.append(l3.copy())\n domain_port_nffg.metadata.update(sap_port_nffg.metadata)\n\n # Delete both inter-domain SAP and links connected to them\n base.del_node(sap_id)\n nffg.del_node(sap_id)\n\n # Add the inter-domain links for both ways\n l1, l2 = base.add_undirected_link(\n p1p2id=\"inter-domain-link-%s\" % sap_id,\n p2p1id=\"inter-domain-link-%s-back\" % sap_id,\n port1=domain_port_dov,\n port2=domain_port_nffg)\n # Set delay/bandwidth values for outgoing link port1 -> port2\n l1.delay = domain_port_dov.delay\n l1.bandwidth = domain_port_dov.bandwidth\n # Set delay/bandwidth values for outgoing link port2 -> port2\n l2.delay = domain_port_nffg.delay\n l2.bandwidth = domain_port_nffg.bandwidth\n\n else:\n # Normal SAP --> copy SAP\n c_sap = base.add_sap(sap_obj=deepcopy(nffg.network.node[sap_id]))\n log.debug(\"Copy SAP: %s\" % c_sap)\n # Copy remaining links which should be valid\n for u, v, link in nffg.network.edges_iter(data=True):\n src_port = base.network.node[u].ports[link.src.id]\n dst_port = base.network.node[v].ports[link.dst.id]\n c_link = deepcopy(link)\n c_link.src = src_port\n c_link.dst = dst_port\n base.add_link(src_port=src_port, dst_port=dst_port, link=c_link)\n log.debug(\"Copy Link: %s\" % c_link)\n log.debug(\"Domain merging has been finished!\")\n # Return the updated NFFG\n return base","def kspace_project_out(self, other):\n\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\n self_k = transform(self, np.fft.fftn, n_points = n_points)\n other_k = transform(other, np.fft.fftn, n_points = n_points)\n\n for i in np.arange(len(self_k.blocks)-1):\n self_k.blocks[i] -= other_k.blocks[i]","def merge(path_to_mf_lf_1, path_to_mf_lf_2, path_to_mf_hf_1, path_to_mf_hf_2, path_to_sf,\n path_to_mf_lf, path_to_mf_hf, path_to_sf_copy):\n mf_lf = merge_one_case(pd.read_csv(path_to_mf_lf_1, index_col=0), pd.read_csv(path_to_mf_lf_2, index_col=0))\n mf_hf = merge_one_case(pd.read_csv(path_to_mf_hf_1, index_col=0), pd.read_csv(path_to_mf_hf_2, index_col=0))\n sf = pd.read_csv(path_to_sf, index_col=0) # only bypassed\n mf_lf.to_csv(path_to_mf_lf, index=True, header=True)\n mf_hf.to_csv(path_to_mf_hf, index=True, header=True)\n sf.to_csv(path_to_sf_copy, index=True, header=True)","def mySecondTree (ns):\n\n # Make a list of the child nodes specified by TDLOptions:\n cc = []\n if copt_MeqFreq:\n cc.append(ns.MeqFreq << Meq.Freq())\n if copt_MeqTime:\n cc.append(ns.MeqTime << Meq.Time())\n if copt_complex:\n cc.append(ns.complex << Meq.ToComplex(ns << Meq.Freq(), ns << Meq.Time()))\n if copt_MeqGaussNoise>0:\n cc.append(ns.MeqGaussNoise << Meq.GaussNoise(stddev=copt_MeqGaussNoise))\n\n # Make sure that there is at least one child, and add them all:\n if len(cc)==0:\n cc.append(ns.zero << 0.0)\n rootnode = ns.sum << Meq.Add(*cc)\n\n # Finishing touches:\n BM.bookpage_nodes (cc+[rootnode], help=None,\n name='mySecondTree nodes')\n rootnode = BM.bookpage_function_result (rootnode, func=mySecondTree, ns=ns, other=[])\n return rootnode","def _rewrite_concat(self, node: saldag.Concat):\n\n assert (not node.is_lower_boundary())\n\n out_stored_with = node.out_rel.stored_with\n ordered_pars = node.get_sorted_parents()\n for parent in ordered_pars:\n par_stored_with = parent.out_rel.stored_with\n if par_stored_with != out_stored_with:\n out_rel = copy.deepcopy(parent.out_rel)\n out_rel.rename(out_rel.name + \"_close\")\n out_rel.stored_with = copy.copy(out_stored_with)\n # create and insert close node\n store_op = saldag.Close(out_rel, None)\n store_op.is_mpc = True\n saldag.insert_between(parent, node, store_op)","def merge_two_keyword_chunks(data_first, data_second):\n common_keyword = data_first.columns.intersection(data_second.columns)[0]\n scaling_factor = np.nanmedian(\n data_first[common_keyword] / data_second[common_keyword])\n data_second = data_second.apply(lambda x: x * scaling_factor)\n data = pd.merge(data_first, data_second.drop(\n common_keyword, axis=1), left_index=True, right_index=True)\n return data","def double(self):\r\n for i in range(len(self.links)):\r\n s = self.links[i]\r\n second_copy = self.link(s.a, s.b)\r\n if s.value == 'RUNG':\r\n second_copy.value = 'SCAFFOLD_RUNG'\r\n else:\r\n second_copy.value = 'SCAFFOLD'\r\n second_copy.index = None","def _sync_children(self, source_parent, destination_parent, new_child):\r\n destination_reordered = []\r\n destination_children = destination_parent['fields']['children']\r\n source_children = source_parent['fields']['children']\r\n orphans = set()\r\n for child in destination_children:\r\n try:\r\n source_children.index(child)\r\n except ValueError:\r\n orphans.add(child)\r\n for child in source_children:\r\n if child == new_child or child in destination_children:\r\n destination_reordered.append(child)\r\n destination_parent['fields']['children'] = destination_reordered\r\n return orphans","def add_dependent_lookup_field(self, displayName, primaryLookupField, lookupField):\n return_field = Field(self.context)\n self.add_child(return_field)\n parameters = {\n \"displayName\": displayName,\n \"primaryLookupField\": primaryLookupField,\n \"lookupField\": lookupField\n }\n qry = ServiceOperationQuery(self, \"AddDependentLookupField\", None, parameters, None, return_field)\n self.context.add_query(qry)\n return return_field","def second_category_axis(self, second_category_axis):\n\n self.container['second_category_axis'] = second_category_axis","def post_process(fasta_fp, mapping_fp, denoised_seqs_fp,\r\n otu_picker_otu_map_fp, out_dir):\r\n\r\n combine_mappings(open(fasta_fp), open(mapping_fp),\r\n open(denoised_seqs_fp),\r\n open(otu_picker_otu_map_fp), out_dir)","def _splitBucket(self, bucket):\n idx = self.buckets.index(bucket)\n self.buckets.pop(idx)\n middle = int(bucket.low + (bucket.high - bucket.low)/2)\n \n bucketLow = Bucket(bucket.low, middle, bucket.refreshed)\n bucketHigh = Bucket(middle+1, bucket.high, refreshed.refreshed)\n \n self.buckets.append(bucketLow)\n self.buckets.append(bucketHigh)\n \n for bucket in bucket.nodes:\n if bucketLow.inRange(bucket):\n bucketLow.addNode(bucket)\n else:\n bucketHigh.addNode(bucket)\n \n return (bucketLow, bucketHigh)","def merge(self, other_btree):\n pass","def mconcat(a, b):\r\n if a is None:\r\n return b\r\n if b is None:\r\n return a\r\n for key in b.keyset:\r\n value=get(b,key)\r\n put(a,key,value)\r\n return a","def __finalize__(self, other, method=None, **kwargs):\r\n # merge operation: using metadata of the left object\r\n if method == 'merge':\r\n for name in self._metadata:\r\n object.__setattr__(self, name, getattr(other.left, name, None))\r\n # concat operation: using metadata of the first object\r\n elif method == 'concat':\r\n for name in self._metadata:\r\n object.__setattr__(self, name, getattr(other.objs[0], name, None))\r\n else:\r\n for name in self._metadata:\r\n object.__setattr__(self, name, getattr(other, name, None))\r\n return self","def multi_dc_replace_with_rf1_test(self):\n cluster = self.cluster\n cluster.populate([1, 1])\n cluster.start()\n node1, node2 = cluster.nodelist()\n\n node1 = cluster.nodes['node1']\n yaml_config = \"\"\"\n # Create the keyspace and table\n keyspace: keyspace1\n keyspace_definition: |\n CREATE KEYSPACE keyspace1 WITH replication = {'class': 'NetworkTopologyStrategy', 'dc1': 1, 'dc2': 1};\n table: users\n table_definition:\n CREATE TABLE users (\n username text,\n first_name text,\n last_name text,\n email text,\n PRIMARY KEY(username)\n ) WITH compaction = {'class':'SizeTieredCompactionStrategy'};\n insert:\n partitions: fixed(1)\n batchtype: UNLOGGED\n queries:\n read:\n cql: select * from users where username = ?\n fields: samerow\n \"\"\"\n with tempfile.NamedTemporaryFile(mode='w+') as stress_config:\n stress_config.write(yaml_config)\n stress_config.flush()\n node1.stress(['user', 'profile=' + stress_config.name, 'n=10k', 'no-warmup',\n 'ops(insert=1)', '-rate', 'threads=50'])\n\n session = self.patient_cql_connection(node1)\n\n # change system_auth keyspace to 2 (default is 1) to avoid\n # \"Unable to find sufficient sources for streaming\" warning\n if cluster.cassandra_version() >= '2.2.0':\n session.execute(\"\"\"\n ALTER KEYSPACE system_auth\n WITH replication = {'class':'SimpleStrategy', 'replication_factor':2};\n \"\"\")\n\n # Save initial data\n stress_table = 'keyspace1.users'\n query = SimpleStatement('select * from %s LIMIT 1' % stress_table, consistency_level=ConsistencyLevel.TWO)\n initial_data = rows_to_list(session.execute(query))\n\n # stop node to replace\n debug(\"Stopping node to replace.\")\n node2.stop(wait_other_notice=True)\n\n node3 = new_node(cluster, data_center='dc2')\n node3.start(replace_address='127.0.0.2', wait_for_binary_proto=True)\n\n assert_bootstrap_state(self, node3, 'COMPLETED')\n\n # Check that keyspace was replicated from dc1 to dc2\n self.assertFalse(node3.grep_log(\"Unable to find sufficient sources for streaming range\"))\n\n # query should work again with node1 stopped\n node1.stop(wait_other_notice=True)\n debug(\"Verifying data on new node.\")\n session = self.patient_exclusive_cql_connection(node3)\n assert_all(session, 'SELECT * from {} LIMIT 1'.format(stress_table),\n expected=initial_data,\n cl=ConsistencyLevel.LOCAL_ONE)","def copy_from(self, another: \"TrieMatcher\"):\n # noinspection PyUnresolvedReferences\n from grantinfo.lexmatch.triematcher import TrieMatcher\n\n assert isinstance(another, TrieMatcher), \\\n f\"type(another) = '{type(another)}', should be '{TrieMatcher.__qualname__}'\"\n\n super().copy_from(another)\n\n self.match_helper = another.match_helper\n\n # No need to copy:\n # ... member fields caching params\n # self.name_preference_*\n # ... invariant members\n # self.tknzr\n\n return","def update_node2edge(self):\n self.node2edge = {e.child : e for e in self.edge}\n childrenset = set(self.node2edge.keys())\n rootset = set(e.parent for e in self.edge).difference(childrenset)\n if len(rootset) > 1:\n raise Warning(\"there should be a single root: \" + str(rootset))\n if len(rootset) == 0:\n raise Exception(\"there should be at least one root!\")\n self.root = rootset.pop()","def combine_cluster_from_to(cl1, cl2):\n for node_id in clusters[cl1]:\n nodes[node_id] = cl2\n clusters[cl2].append(node_id)\n clusters.pop(cl1)","def replace_self_references(self) -> None:\n for child in self.get_children_typed_dicts():\n if child is self:\n child.replace_with_dict.add(self.name)\n continue\n for sub_child in child.get_children_typed_dicts():\n if sub_child.replace_with_dict:\n continue\n if sub_child is self:\n sub_child.replace_with_dict.add(child.name)\n continue","def merge_df(self, first_df, second_df):\n self.file = pd.merge(second_df, first_df, on=[(\"NAME\", \"TYPE\")])"],"string":"[\n \"def map2(self, f, pt):\\n logger.debug('[START] PID[%s] map2 skeleton', PID)\\n assert self.__distribution == pt.distribution\\n content = SList([None] * self.__content.length())\\n for i in range(len(self.__global_index[self.__start_index: self.__start_index +\\n self.__nb_segs])):\\n (start, offset) = self.__global_index[self.__start_index: self.__start_index +\\n self.__nb_segs][i]\\n logger.debug('[START] PID[%s] map2_local from %s to %s', PID, start, start + offset)\\n content[start:start + offset] = Segment(self.__content[start:start + offset]). \\\\\\n map2(f, Segment(pt.content[start:start + offset]))\\n logger.debug('[END] PID[%s] map2_local from %s to %s', PID, start, start + offset)\\n res = PTree.init(self, content)\\n logger.debug('[END] PID[%s] map2 skeleton', PID)\\n return res\",\n \"def update(self, other):\\n b = self.hallucinate_merge(other)\\n self.l_child = b.l_child\\n self.r_child = b.r_child\",\n \"def merge_from(self, other):\\n assert not self.is_final\\n if self.parent is not None:\\n assert other.parent is not None\\n self.parent.merge_from(other.parent)\\n self.isolated_names.update(other.isolated_names)\\n self.read.update(other.read)\\n self.modified.update(other.modified)\\n self.bound.update(other.bound)\\n self.deleted.update(other.deleted)\\n self.annotations.update(other.annotations)\\n self.params.update(other.params)\",\n \"def _redirect(self, node1, node2):\\n if node1.parent.right is node1:\\n node1.parent.right = node2\\n else:\\n node1.parent.left = node2\",\n \"def expand_second_partition(device):\\n\\n print('Deleting the original boot partition from the thumb drive')\\n _delete_partition(device, 1)\\n\\n print('Expanding the partition. Resizing isn\\\\'t worth it. Or obvious to do.')\\n resize_command = ['sudo', 'parted', device.path, 'resizepart', '2', '\\\"-1s\\\"']\\n interactive_console(resize_command)\\n\\n print('Fixing the nibbly bits for the partition itself')\\n target_partition = device.partitions(full_paths=True)[0]\\n interactive_console(['sudo', 'e2fsck', '-f', target_partition])\\n\\n print('Fixing ext4 so it goes all the way to the end')\\n target_end = device.partition_specs(2)['End']\\n interactive_console(['sudo', 'resize2fs', target_partition, target_end])\\n\\n print('Success!')\",\n \"def __remap(self, tree1: int, tree2: int) -> None:\\n # if the branch was deleted in the same iteration skip\\n if self.__trees.get(tree1) is None:\\n return\\n\\n # re map all mazes to tree2\\n self.__mappings[tree1] = tree2\\n for key, value in self.__mappings.items():\\n if value == tree1:\\n self.__mappings[key] = tree2\\n self.__trees[tree2] += self.__trees[tree1]\\n del self.__trees[tree1]\",\n \"def merge(self, first, second):\\n return second if self.failed(first) else first\",\n \"def _fix_other_tree(self, this_tree, other_tree):\\n parent_dir, name = osutils.split(self._target_subdir)\\n parent_id = this_tree.path2id(parent_dir)\\n\\n root_ie = other_tree.inventory.root\\n root_ie.parent_id = parent_id\\n root_ie.name = name\\n\\n new_file_id = generate_ids.gen_file_id(name)\\n trace.mutter('munging root_ie.file_id: %s => %s', root_ie.file_id,\\n new_file_id)\\n del other_tree.inventory._byid[root_ie.file_id]\\n root_ie.file_id = new_file_id\\n other_tree.inventory._byid[new_file_id] = root_ie\\n # We need to fake a new id for root_ie\\n for child_ie in root_ie.children.itervalues():\\n child_ie.parent_id = new_file_id\",\n \"def add_child(self, child):\\n if isinstance(child, ET.ElementBase):\\n for f in child.findall('.//form'):\\n f.replace(f.getchildren()[1:])\\n\\n if isinstance(child, Form):\\n child = child.getchildren()[1:]\\n\\n super(Form, self).add_child(child)\",\n \"def inherit_species_module_mapping(self, generation, other, acc, da_scheme=None, inherit_module_mapping=True):\\n if acc > self.max_accuracy:\\n if inherit_module_mapping:\\n other.update_module_refs(generation)\\n self.species_module_ref_map = other.species_module_ref_map\\n\\n self.max_accuracy = acc\\n\\n if da_scheme is not None:\\n self.da_scheme = da_scheme\",\n \"def merge(self, other):\\n\\n for child in other.children:\\n self.add_deep_copy_of(child, merged=True)\",\n \"def test_field_resolution_multiple_inheritance_without_child_field_defined(self):\\n parent_b_field = ParentBM()._get_fields()[\\\"name\\\"]\\n child_field = ChildWithMultipleParents()._get_fields()[\\\"name\\\"]\\n self.assertEqual(parent_b_field.default, \\\"B\\\")\\n self.assertEqual(child_field.default, \\\"A\\\")\\n\\n child_field = ChildWithMultipleParentsWithDifferntOrder()._get_fields()[\\\"name\\\"]\\n self.assertEqual(child_field.default, \\\"B\\\")\",\n \"def cu_for_merge(self, best1, best2, undo=True):\\n\\t\\t#TODO - Might want to consider adding the instance to the merged node.\\n\\t\\tfirst = best1\\n\\t\\tsecond = best2\\n\\n\\t\\tif second < first:\\n\\t\\t\\ttemp = first \\n\\t\\t\\tfirst = second \\n\\t\\t\\tsecond = temp\\n\\n\\t\\tfirst_c = self.tree.children[first]\\n\\t\\tsecond_c = self.tree.children[second]\\n\\n\\t\\tnew_c = self.tree.makeTree(self.tree.root, self.tree)\\n\\t\\tnew_c.utility.update_counts_from_node(first_c)\\n\\t\\tnew_c.utility.update_counts_from_node(second_c)\\n\\n\\t\\tself.tree.children.pop(second)\\n\\t\\tself.tree.children.pop(first)\\n\\t\\tself.tree.children.append(new_c)\\n\\n\\t\\tcu = self.utility.category_utility()\\n\\n\\t\\tif undo:\\n\\t\\t\\tself.tree.children.pop()\\n\\t\\t\\tself.tree.children.insert(first,first_c)\\n\\t\\t\\tself.tree.children.insert(second,second_c)\\n\\t\\telse:\\n\\t\\t\\t# If we aren't undoing the merge then we have to add the leaves\\n\\t\\t\\tnew_c.children.append(first_c)\\n\\t\\t\\tfirst_c.parent = new_c\\n\\t\\t\\tnew_c.children.append(second_c)\\n\\t\\t\\tsecond_c.parent = new_c\\n\\t\\t\\tself.tree.mergedNodes.append([first_c, second_c])\\n\\t\\t\\tself.tree.splitMergeOrder.append(\\\"m\\\")\\n\\t\\t\\tfor m in self.tree.mergedNodes:\\n\\t\\t\\t\\tif len(m) > 2 and first_c in m and second_c in m:\\n\\t\\t\\t\\t\\tm.remove(first_c)\\n\\t\\t\\t\\t\\tm.remove(second_c)\\n\\t\\t\\t\\t\\tm.append(new_c)\\n\\t\\t\\tfor s in self.tree.splitNodes:\\n\\t\\t\\t\\tif len(s) > 2 and first_c in s and second_c in s:\\n\\t\\t\\t\\t\\ts.remove(first_c)\\n\\t\\t\\t\\t\\ts.remove(second_c)\\n\\t\\t\\t\\t\\ts.append(new_c)\\n\\t\\treturn cu\",\n \"def add_spoof_child(self, child):\\n if child.tags is None:\\n raise Exception(\\\"Component {0} tried to add_child \\\"\\n \\\"component: {1} to its children. \\\"\\n \\\"But tags \\\"\\n \\\"was not set.\\\".format(str(self), str(child)))\\n if child.component_type is None:\\n raise Exception(\\\"Component {0} tried to add_child \\\"\\n \\\"component: {1} to its children. \\\"\\n \\\"But component_type \\\"\\n \\\"was not set.\\\".format(str(self), str(child)))\\n if not child._parent is None and child.parent != self:\\n raise Exception(\\\"Component {0} tried to add_child \\\"\\n \\\"component: {1} to its children. \\\"\\n \\\"But it already \\\"\\n \\\"had parent: {2}.\\\".format(str(self), str(child), str(child.parent)))\\n if not child.component_type in self._spoofed_children:\\n self._spoofed_children[child.component_type] = []\\n self._spoofed_children[child.component_type].append(child)\\n self._add_child_to_tag_table(child)\\n child.parent = self\",\n \"def _chain_to_another_future(self, base_future):\\n\\n if base_future in self._chained_futures_log:\\n raise CircularFuturesChainException(\\n 'Circular Futures chain detected. Future {} is already in the resolved chain {}'.format(\\n base_future, set(self._chained_futures_log)\\n )\\n )\\n else:\\n self._chained_futures_log.add(base_future)\\n\\n def _done_handler(base_future):\\n \\\"\\\"\\\"\\n Converts results of underlying future into results of new future\\n\\n :param ThenableFuture base_future: Original Future instance, but now guaranteed to be resolved\\n due to cancellation or completion.\\n \\\"\\\"\\\"\\n if not base_future.done():\\n # this should never ever be true.\\n # having this code here just to avoid infinite timeout\\n self.cancel()\\n return\\n\\n if base_future.cancelled():\\n self.cancel()\\n return\\n\\n try:\\n result = base_future.result()\\n if isinstance(result, Future):\\n self._chain_to_another_future(result)\\n else:\\n self.set_result(result)\\n return\\n except BaseException:\\n # note, that exception may come from self.result()\\n # and from on_fulfilled(result) calls.\\n ex, trace_back = sys.exc_info()[1:]\\n self.set_exception_info(ex, trace_back)\\n return\\n\\n base_future.add_done_callback(_done_handler)\",\n \"def secondary_clustering(sff_file, mapping, bestscores, log_fh,\\r\\n threshold=4.5, verbose=False):\\r\\n if(len(bestscores) == 0):\\r\\n # Either all sequence are already clustered or\\r\\n # we had no seq exceeding the bail out limit\\r\\n return\\r\\n\\r\\n (flowgrams, header) = lazy_parse_sff_handle(open(sff_file))\\r\\n\\r\\n counter = 0\\r\\n for f in flowgrams:\\r\\n (id, score) = bestscores[f.Name]\\r\\n if (score < threshold):\\r\\n counter += 1\\r\\n # update the mapping information\\r\\n mapping[id].extend(mapping[f.Name])\\r\\n mapping[id].append(f.Name)\\r\\n del(mapping[f.Name])\\r\\n if verbose:\\r\\n log_fh.write(\\\"Secondary clustering removed %d flowgrams\\\\n\\\" % counter)\",\n \"def merge_fs(fs1,fs2):\\n # This function merges fs2 into fs1, changing fs1 in-place\\n # It's a cheaper and faster alternative of unify(), which will check\\n # all the similarities and differences between fs1 and fs2. But this one\\n # just assumes that fs2 and fs1 does not have any entries in common\\n # NOTICE: In Templates.lex we cannot guarantee there is no overlap\\n # so only use this function when it IS clear.\\n for k in fs2.keys():\\n if fs1.has_key(k):\\n merge_fs(fs1[k],fs2[k])\\n else:\\n fs1[k] = fs2[k]\\n return\",\n \"def divide(self, secondary_spectrum, copy_header='first', force=True,\\n copy_flux_err = 'No', method='interpolate'):\\n\\n self.check_units(secondary_spectrum)\\n\\n s_one = self.copy()\\n s_two = secondary_spectrum.copy()\\n\\n if not np.array_equal(self.dispersion, s_two.dispersion):\\n print (\\\"Warning: Dispersion does not match.\\\")\\n print (\\\"Warning: Flux will be interpolated.\\\")\\n\\n s_one.match_dispersions(s_two, force=force,\\n match_secondary=False, method=method)\\n\\n new_flux = s_one.flux / s_two.flux\\n print(copy_flux_err)\\n if copy_flux_err == 'No' and isinstance(s_one.flux_err,\\n np.ndarray) and \\\\\\n isinstance(s_two.flux_err, np.ndarray):\\n new_flux_err = np.sqrt( (s_one.flux_err/ s_two.flux)**2 + (new_flux/s_two.flux*s_two.flux_err)**2 )\\n elif copy_flux_err == 'first':\\n new_flux_err = s_one.flux_err\\n elif copy_flux_err == 'second':\\n new_flux_err = s_two.flux_err\\n else:\\n new_flux_err = None\\n\\n print(new_flux_err, s_one.flux_err)\\n\\n if copy_header == 'first':\\n new_header = s_one.header\\n elif copy_header == 'last':\\n new_header = s_two.header\\n\\n return SpecOneD(dispersion=s_one.dispersion,\\n flux=new_flux,\\n flux_err=new_flux_err,\\n header=new_header,\\n unit=s_one.unit,\\n mask=s_one.mask)\",\n \"def _merge(self, drifting_t, another_t):\\n # drifting_t and another_t must exist in graph\\n\\n # add a (t --> another_t) edge for each (t --> drifting_t) edge\\n for t, _, key, data in self.in_edges_iter(\\n nbunch=[drifting_t], data=True, keys=True\\n ):\\n self.add_edge(t, another_t, key=key, attr_dict=data)\\n\\n # add a (another_t --> t) edge for each (drifting_t --> t) edge\\n for _, t, key, data in self.edges_iter(\\n nbunch=[drifting_t], data=True, keys=True\\n ):\\n self.add_edge(another_t, t, key=key, attr_dict=data)\\n\\n # remove drifting_t node (as it was replaced by another_t)\\n self.remove_node(drifting_t)\",\n \"def fl_add_child(ptr_flobject1, ptr_flobject2):\\n _fl_add_child = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_add_child\\\",\\\\\\n None, [cty.POINTER(xfdata.FL_OBJECT), cty.POINTER(xfdata.FL_OBJECT)],\\n \\\"\\\"\\\"void fl_add_child(FL_OBJECT * p1, FL_OBJECT * p2)\\\"\\\"\\\")\\n library.check_if_flinitialized()\\n library.verify_flobjectptr_type(ptr_flobject1)\\n library.verify_flobjectptr_type(ptr_flobject2)\\n library.keep_elem_refs(ptr_flobject1, ptr_flobject2)\\n _fl_add_child(ptr_flobject1, ptr_flobject2)\",\n \"def recoverTree(self, root: TreeNode) -> None:\\n self.inorder(root)\\n self.first.val, self.second.val = self.second.val, self.first.val\",\n \"def merge_nodes(self, parent, child):\\n parent.key += child.key\\n parent.real = child.real\\n parent.value = child.value\\n parent.children = child.children\",\n \"def level_two(self):\\n #swaps a random ingredient by choosing a random place\\n swap_spot = randint(0,len(self.current_recipe.toppings)-1)\\n #chooses which food type to choose from\\n extra_ingredient_type = choice(food_type_databases) \\n new_ingredient = choice(extra_ingredient_type)\\n self.current_recipe.toppings[swap_spot] = new_ingredient\\n self.new_ingredients = self.current_recipe.toppings\",\n \"def to_other(self, c2, cut=False):\\n\\n p = self.c.p\\n\\n p_v = p.v # p may be invalid by the time we want to use it\\n\\n c2, nd = self.unl_to_pos(c2, p)\\n\\n if c2 is None:\\n return\\n\\n # in case nd was created in this outline, invalidating p\\n p = self.c.vnode2position(p_v)\\n\\n self.copy_recursively(p, nd)\\n\\n p = self.c.vnode2position(p_v)\\n\\n nxt = p.copy().visNext(self.c).v\\n\\n if cut:\\n self.c.selectPosition(p)\\n self.c.deleteOutline()\\n self.c.setChanged()\\n\\n if nxt:\\n self.c.selectPosition(self.c.vnode2position(nxt))\\n\\n c2.setChanged()\\n c2.redraw()\\n self.c.bringToFront(c2=self.c)\\n self.c.redraw() # must come second to keep focus\",\n \"def put_forks(self):\\r\\n\\r\\n if self.has_forks:\\r\\n print '%s drops both forks.'% self.name\\r\\n self.left_fork.release()\\r\\n self.right_fork.release()\\r\\n self.has_forks = False\\r\\n else:\\r\\n raise ValueError('%s tried to drop forks it didn\\\\'t have.'% self.name)\",\n \"def recoverTree(self, root: Optional[TreeNode]) -> None:\\n self.inorder(root)\\n self.first.val,self.second.val=self.second.val,self.first.val\",\n \"def fusion(first_fh, fused_fh, compare_file):\\r\\n # initialize\\r\\n ha_seq = \\\"\\\"\\r\\n ha_header = \\\"\\\"\\r\\n # parse through file\\r\\n for line in first_fh:\\r\\n # if a > is found assume it is header\\r\\n if line[0] == \\\">\\\":\\r\\n # ha_header = line\\r\\n # if the header is found (length > 0)\\r\\n if len(ha_header) > 0:\\r\\n # pull needed information from header to make new one\\r\\n matches = re.findall(\\\"(Strain Name:[AB]\\\\/[\\\\/A-Za-z 0-9()\\\\\\\\-_'.]+)\\\", ha_header)\\r\\n subtype_match = re.findall(\\\"(Subtype:[A-Za-z0-9]+)\\\", ha_header)\\r\\n organ = re.findall(\\\"(Organism:[\\\\/A-Za-z 0-9()\\\\\\\\-_'.]+)\\\", ha_header)\\r\\n ha_header = \\\">\\\" + organ[0] + \\\"|\\\" + matches[0] + \\\"|\\\" + subtype_match[0]\\r\\n # print(ha_header)\\r\\n # Call find_match function, input the file to search and the new header created.\\r\\n na_header, na_seq = find_match(compare_file, ha_header)\\r\\n # if return is equal then write to new file with two sequences fused\\r\\n if na_header == ha_header:\\r\\n write_data_2(fused_fh, ha_header, ha_seq.strip() + \\\"\\\\n\\\" + na_seq.strip())\\r\\n # reset variables\\r\\n ha_header = line\\r\\n ha_seq = \\\"\\\"\\r\\n\\r\\n else:\\r\\n # if it is part of the sequence\\r\\n ha_seq = ha_seq + line\\r\\n\\r\\n # To return/write the last entries in the files, won't get written in loop\\r\\n matches = re.findall(\\\"(Strain Name:[AB]\\\\/[\\\\/A-Za-z 0-9()\\\\\\\\-_'.]+)\\\", ha_header)\\r\\n subtype_match = re.findall(\\\"(Subtype:[A-Za-z0-9]+)\\\", ha_header)\\r\\n organ = re.findall(\\\"(Organism:[\\\\/A-Za-z 0-9()\\\\\\\\-_'.]+)\\\", ha_header)\\r\\n ha_header = \\\">\\\" + organ[0] + \\\"|\\\" + matches[0] + \\\"|\\\" + subtype_match[0]\\r\\n na_header, na_seq = find_match(compare_file, ha_header)\\r\\n if na_header == ha_header:\\r\\n # print(\\\"matches2\\\")\\r\\n # print(ha_header)\\r\\n write_data_2(fused_fh, ha_header, ha_seq.strip() + \\\"\\\\n\\\" + na_seq.strip())\\r\\n\\r\\n # Close Files\\r\\n first_fh.close()\\r\\n fused_fh.close()\",\n \"def copy_from_other(self, other):\\n super(RabjDict, self).copy_from_other(other)\\n self.rabjcallable = other.rabjcallable\",\n \"def replace(self, other_cache):\\n # This is used in avant-idle to replace the content of the cache\\n # in a process (where no storage normally takes place) by\\n # that of another where the actual caching of the source is done.\\n self.cache.clear()\\n for key in other_cache:\\n self.add(key, other_cache[key])\",\n \"def normalize(self):\\n queue = {self.entry_point}\\n visited = set()\\n while queue:\\n root = queue.pop()\\n visited.add(root)\\n for child in root.children:\\n if child not in visited:\\n queue.add(child)\\n unreachable = self.blocks - visited\\n for block in unreachable:\\n block.detach()\\n visited.remove(self.entry_point)\\n for block in visited:\\n if block.empty():\\n for parent in block.parents: # Re-parent\\n for child in block.children:\\n parent.add_child(child)\\n block.detach()\\n unreachable.add(block)\\n self.blocks -= unreachable\",\n \"def set_second_incident_node(self, second_incident_node):\\n # overwrite the existing second incident node with the input second incident Node object\\n self.second_incident_node = second_incident_node\",\n \"def modify_d2(d1, d2):\\n val_list = [i for i in d2.keys()]\\n \\n for key in val_list:\\n for i in range(len(d2[key])):\\n try:\\n val = d1[d2[key][i][2]]\\n d2[key][i][2] = val\\n if None in d2[key][i]:\\n d2[key][i].remove(None)\\n except:\\n pass\\n return d2\",\n \"def detect_cut(self, second_iteration=False):\\r\\n if self.dfg:\\r\\n # print(\\\"\\\\n\\\\n\\\")\\r\\n par_cut = self.detect_parallel_cut()\\r\\n conc_cut = self.detect_concurrent_cut()\\r\\n seq_cut = self.detect_sequential_cut()\\r\\n loop_cut = self.detect_loop_cut()\\r\\n\\r\\n if par_cut[0]:\\r\\n union_acti_comp = set()\\r\\n for comp in par_cut[1]:\\r\\n union_acti_comp = union_acti_comp.union(comp)\\r\\n diff_acti_comp = set(self.activities).difference(union_acti_comp)\\r\\n\\r\\n for act in diff_acti_comp:\\r\\n par_cut[1] = add_to_most_probable_component(par_cut[1], act, self.ingoing, self.outgoing)\\r\\n\\r\\n for comp in par_cut[1]:\\r\\n new_dfg = filter_dfg_on_act(self.dfg, comp)\\r\\n self.detected_cut = \\\"parallel\\\"\\r\\n self.children.append(Subtree(new_dfg, self.initial_dfg, comp, self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n else:\\r\\n if conc_cut[0]:\\r\\n for comp in conc_cut[1]:\\r\\n new_dfg = filter_dfg_on_act(self.dfg, comp)\\r\\n self.detected_cut = \\\"concurrent\\\"\\r\\n self.children.append(Subtree(new_dfg, self.initial_dfg, comp, self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n else:\\r\\n if seq_cut[0]:\\r\\n dfg1 = filter_dfg_on_act(self.dfg, seq_cut[1])\\r\\n dfg2 = filter_dfg_on_act(self.dfg, seq_cut[2])\\r\\n self.detected_cut = \\\"sequential\\\"\\r\\n self.children.append(\\r\\n Subtree(dfg1, self.initial_dfg, seq_cut[1], self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n self.children.append(\\r\\n Subtree(dfg2, self.initial_dfg, seq_cut[2], self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n else:\\r\\n if loop_cut[0]:\\r\\n dfg1 = filter_dfg_on_act(self.dfg, loop_cut[1])\\r\\n dfg2 = filter_dfg_on_act(self.dfg, loop_cut[2])\\r\\n self.detected_cut = \\\"loopCut\\\"\\r\\n self.children.append(\\r\\n Subtree(dfg1, self.initial_dfg, loop_cut[1], self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n self.children.append(\\r\\n Subtree(dfg2, self.initial_dfg, loop_cut[2], self.counts, self.rec_depth + 1,\\r\\n noise_threshold=self.noise_threshold))\\r\\n else:\\r\\n if self.noise_threshold > 0:\\r\\n if not second_iteration:\\r\\n self.initialize_tree(self.dfg, self.initial_dfg, None, second_iteration=True)\\r\\n else:\\r\\n pass\\r\\n self.detected_cut = \\\"flower\\\"\\r\\n else:\\r\\n self.detected_cut = \\\"base_concurrent\\\"\",\n \"def _process_last(self, first, second):\\n if not self.can_combine(first, second):\\n # no combining\\n self.combined.append(first)\\n self.combined.append(second)\\n else:\\n # combine and terminate\\n self.move_cursors_to_end(second)\\n self.combine_and_select_block(first)\",\n \"def _fixupChildren(self, ph, alogger):\\n name = alogger.name\\n namelen = len(name)\\n for c in ph.loggerMap.keys():\\n #The if means ... if not c.parent.name.startswith(nm)\\n if c.parent.name[:namelen] != name:\\n alogger.parent = c.parent\\n c.parent = alogger\",\n \"def merge_two_calls(self) -> None:\",\n \"def breadth_first(self, xy1, xy2):\\n tile_col1, tile_row1 = self.the_map.xy_to_cr(xy1[0], xy1[1])\\n tile_col2, tile_row2 = self.the_map.xy_to_cr(xy2[0], xy2[1])\\n \\n successor_to_parent_map = {}\\n start_state = (tile_col1, tile_row1)\\n successor_to_parent_map[(start_state, None)] = None # (Successor, Action) -> (Parent, Action)\\n \\n open_list = PriorityQueue()\\n open_list.update((start_state, None), 0)\\n closed = []\\n \\n while not open_list.isEmpty():\\n current_state, action_to_current_state = open_list.pop()\\n \\n if current_state == (tile_col2, tile_row2):\\n return self.__get_action_path((current_state, action_to_current_state), successor_to_parent_map)\\n \\n if current_state not in closed:\\n for successor_state, action, step_cost in self.__get_successors(current_state):\\n open_list.update((successor_state, action), 0)\\n \\n if successor_state not in closed:\\n successor_to_parent_map[(successor_state, action)] = (current_state, action_to_current_state)\\n \\n closed.append(current_state)\\n \\n return []\",\n \"def _transform_sub_mapping(self, cr, uid, external_session, convertion_type, resource, vals, sub_mapping_list,\\n mapping, mapping_id, mapping_line_filter_ids=None, defaults=None, context=None):\\n if not defaults:\\n defaults={}\\n ir_model_field_obj = self.pool.get('ir.model.fields')\\n for sub_mapping in sub_mapping_list:\\n sub_object_name = sub_mapping['child_mapping_id'][1]\\n sub_mapping_id = sub_mapping['child_mapping_id'][0]\\n if convertion_type == 'from_external_to_openerp':\\n from_field = sub_mapping['external_field']\\n if not from_field:\\n from_field = \\\"%s_%s\\\" %(sub_object_name, sub_mapping_id)\\n to_field = sub_mapping['internal_field']\\n\\n elif convertion_type == 'from_openerp_to_external':\\n from_field = sub_mapping['internal_field']\\n to_field = sub_mapping['external_field'] or 'hidden_field_to_split_%s'%from_field # if the field doesn't have any name we assume at that we will split it\\n\\n field_value = resource[from_field]\\n sub_mapping_obj = self.pool.get(sub_object_name)\\n sub_mapping_defaults = sub_mapping_obj._get_default_import_values(cr, uid, external_session, sub_mapping_id, defaults.get(to_field), context=context)\\n\\n if field_value:\\n transform_args = [cr, uid, external_session, convertion_type, field_value]\\n transform_kwargs = {\\n 'defaults': sub_mapping_defaults,\\n 'mapping': mapping,\\n 'mapping_id': sub_mapping_id,\\n 'mapping_line_filter_ids': mapping_line_filter_ids,\\n 'parent_data': vals,\\n 'context': context,\\n }\\n\\n if sub_mapping['internal_type'] in ['one2many', 'many2many']:\\n if not isinstance(field_value, list):\\n transform_args[4] = [field_value]\\n if not to_field in vals:\\n vals[to_field] = []\\n if convertion_type == 'from_external_to_openerp':\\n lines = sub_mapping_obj._transform_resources(*transform_args, **transform_kwargs)\\n else:\\n mapping, sub_mapping_id = self._init_mapping(cr, uid, external_session.referential_id.id, \\\\\\n convertion_type=convertion_type,\\n mapping=mapping,\\n mapping_id=sub_mapping_id,\\n context=context)\\n field_to_read = [x['internal_field'] for x in mapping[sub_mapping_id]['mapping_lines']]\\n sub_resources = sub_mapping_obj.read(cr, uid, field_value, field_to_read, context=context)\\n transform_args[4] = sub_resources\\n lines = sub_mapping_obj._transform_resources(*transform_args, **transform_kwargs)\\n for line in lines:\\n if 'external_id' in line:\\n del line['external_id']\\n if convertion_type == 'from_external_to_openerp':\\n if sub_mapping['internal_type'] == 'one2many':\\n #TODO refactor to search the id and alternative keys before the update\\n external_id = vals.get('external_id')\\n alternative_keys = mapping[mapping_id]['alternative_keys']\\n #search id of the parent\\n existing_ir_model_data_id, existing_rec_id = \\\\\\n self._get_oeid_from_extid_or_alternative_keys(\\n cr, uid, vals, external_id,\\n external_session.referential_id.id,\\n alternative_keys, context=context)\\n vals_to_append = (0, 0, line)\\n if existing_rec_id:\\n sub_external_id = line.get('external_id')\\n if mapping[sub_mapping_id].get('alternative_keys'):\\n sub_alternative_keys = list(mapping[sub_mapping_id]['alternative_keys'])\\n if self._columns.get(to_field):\\n related_field = self._columns[to_field]._fields_id\\n elif self._inherit_fields.get(to_field):\\n related_field = self._inherit_fields[to_field][2]._fields_id\\n sub_alternative_keys.append(related_field)\\n line[related_field] = existing_rec_id\\n #search id of the sub_mapping related to the id of the parent\\n sub_existing_ir_model_data_id, sub_existing_rec_id = \\\\\\n sub_mapping_obj._get_oeid_from_extid_or_alternative_keys(\\n cr, uid, line, sub_external_id,\\n external_session.referential_id.id,\\n sub_alternative_keys, context=context)\\n del line[related_field]\\n if sub_existing_rec_id:\\n vals_to_append = (1, sub_existing_rec_id, line)\\n vals[to_field].append(vals_to_append)\\n else:\\n vals[to_field].append(line)\\n\\n elif sub_mapping['internal_type'] == 'many2one':\\n if convertion_type == 'from_external_to_openerp':\\n res = sub_mapping_obj._record_one_external_resource(cr, uid, external_session, field_value,\\n defaults=sub_mapping_defaults, mapping=mapping, mapping_id=sub_mapping_id, context=context)\\n vals[to_field] = res.get('write_id') or res.get('create_id')\\n else:\\n sub_resource = sub_mapping_obj.read(cr, uid, field_value[0], context=context)\\n transform_args[4] = sub_resource\\n vals[to_field] = sub_mapping_obj._transform_one_resource(*transform_args, **transform_kwargs)\\n else:\\n raise except_osv(_('User Error'),\\n _('Error with mapping : %s. Sub mapping can be only apply on one2many, many2one or many2many fields') % (sub_mapping['name'],))\\n return vals\",\n \"def update_inplace_from(self, other):\\n self.__dict__ = other.__dict__.copy()\",\n \"def process_changeroot(self):\\n self.__changeroot()\",\n \"def fuse(self):\\n # TODO: Don't fuse unless they have None as the end slants?\\n i = 0\\n while i < len(self.segments) - 1:\\n left = self.segments[i]\\n right = self.segments[i + 1]\\n if (\\n isinstance(left, LineSegment)\\n and isinstance(right, LineSegment)\\n and left.width == right.width\\n and left.color == right.color\\n and collinear(left.a, left.b, right.b)\\n ):\\n fused_segment = left.fused_with(right)\\n self.segments[i:i+2] = [fused_segment]\\n # Leave i unchanged so fused_segment will be the\\n # \\\"left\\\" segment next iteration.\\n else:\\n # Cannot fuse, try the next pair.\\n i += 1\",\n \"def _replace(self, x, y):\\n y.parent = x.parent\\n if x is self.root:\\n self.root = y\\n return\\n elif x is x.parent.left:\\n x.parent.left = y\\n else:\\n x.parent.right = y\\n\\n self.update(y, -1)\",\n \"def copy_structure(self, other_directory):\\n pass\",\n \"def bundle_data_old(\\n bundle_data, second_sample_vcf, second_family_vcf, old_timestamp, other_case\\n) -> dict:\\n _bundle = deepcopy(bundle_data)\\n _bundle[\\\"name\\\"] = other_case\\n _bundle[\\\"created_at\\\"] = old_timestamp\\n _bundle[\\\"files\\\"][0][\\\"path\\\"] = str(second_sample_vcf)\\n _bundle[\\\"files\\\"][1][\\\"path\\\"] = str(second_family_vcf)\\n return _bundle\",\n \"def osl_fill_from(self, other):\\n #TODO: What about inherited properties?\\n for p in self._osl.properties:\\n conditional_copy(other, self, p[0])\\n return self\",\n \"def test_field_resolution_single_inheritance_with_child_field_defined(self):\\n child_field = ChildWithTheSameField()._get_fields()[\\\"name\\\"]\\n self.assertEqual(child_field.default, \\\"C\\\")\",\n \"def _shrink_secondary(self, amt):\\n self._resize_secondary(-amt)\",\n \"def detect_cut(self, second_iteration=False):\\n if pkgutil.find_loader(\\\"networkx\\\"):\\n import networkx as nx\\n else:\\n msg = \\\"networkx is not available. inductive miner cannot be used!\\\"\\n logging.error(msg)\\n raise Exception(msg)\\n\\n if self.dfg:\\n\\n this_nx_graph = transform_dfg_to_directed_nx_graph(self.dfg, activities=self.activities)\\n conn_components = detection_utils.get_connected_components(self.ingoing, self.outgoing, self.activities)\\n strongly_connected_components = [list(x) for x in nx.strongly_connected_components(this_nx_graph)]\\n\\n xor_cut = self.detect_xor_cut(conn_components, this_nx_graph, strongly_connected_components)\\n\\n if xor_cut[0]:\\n for comp in xor_cut[1]:\\n new_dfg = filter_dfg_on_act(self.dfg, comp)\\n self.detected_cut = \\\"xor\\\"\\n self.children.append(\\n SubtreeDFGBased(new_dfg, self.master_dfg, self.initial_dfg, comp, self.counts,\\n self.rec_depth + 1,\\n noise_threshold=self.noise_threshold,\\n initial_start_activities=self.initial_start_activities,\\n initial_end_activities=self.initial_end_activities))\\n else:\\n seq_cut = self.detect_sequential_cut(conn_components, this_nx_graph, strongly_connected_components)\\n if seq_cut[0]:\\n self.detected_cut = \\\"sequential\\\"\\n for child in seq_cut[1]:\\n dfg_child = filter_dfg_on_act(self.dfg, child)\\n self.children.append(\\n SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child, self.counts,\\n self.rec_depth + 1,\\n noise_threshold=self.noise_threshold,\\n initial_start_activities=self.initial_start_activities,\\n initial_end_activities=self.initial_end_activities))\\n self.put_skips_in_seq_cut()\\n else:\\n par_cut = self.detect_parallel_cut(conn_components, this_nx_graph, strongly_connected_components)\\n if par_cut[0]:\\n self.detected_cut = \\\"parallel\\\"\\n for comp in par_cut[1]:\\n new_dfg = filter_dfg_on_act(self.dfg, comp)\\n self.children.append(\\n SubtreeDFGBased(new_dfg, self.master_dfg, new_dfg, comp, self.counts,\\n self.rec_depth + 1,\\n noise_threshold=self.noise_threshold,\\n initial_start_activities=self.initial_start_activities,\\n initial_end_activities=self.initial_end_activities))\\n else:\\n loop_cut = self.detect_loop_cut(conn_components, this_nx_graph, strongly_connected_components)\\n if loop_cut[0]:\\n if loop_cut[2]:\\n self.detected_cut = \\\"loopCut\\\"\\n for index_enum, child in enumerate(loop_cut[1]):\\n dfg_child = filter_dfg_on_act(self.dfg, child)\\n next_subtree = SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child,\\n self.counts, self.rec_depth + 1,\\n noise_threshold=self.noise_threshold,\\n initial_start_activities=self.initial_start_activities,\\n initial_end_activities=self.initial_end_activities)\\n if loop_cut[3]:\\n next_subtree.must_insert_skip = True\\n self.children.append(next_subtree)\\n else:\\n self.detected_cut = \\\"sequential\\\"\\n self.need_loop_on_subtree = True\\n for index_enum, child in enumerate(loop_cut[1]):\\n dfg_child = filter_dfg_on_act(self.dfg, child)\\n next_subtree = SubtreeDFGBased(dfg_child, self.master_dfg, self.initial_dfg, child,\\n self.counts, self.rec_depth + 1,\\n noise_threshold=self.noise_threshold,\\n initial_start_activities=self.initial_start_activities,\\n initial_end_activities=self.initial_end_activities)\\n self.children.append(next_subtree)\\n next_subtree.must_insert_skip = True\\n else:\\n if self.noise_threshold > 0:\\n if not second_iteration:\\n self.initialize_tree(self.dfg, self.initial_dfg, None, second_iteration=True)\\n else:\\n self.detected_cut = \\\"flower\\\"\\n else:\\n self.detected_cut = \\\"flower\\\"\\n\\n else:\\n self.detected_cut = \\\"base_xor\\\"\",\n \"def __isub__(self, other):\\n\\t\\t#print(\\\"isub\\\")\\n\\t\\t# merge other branch\\n\\t\\tself.graph.update(other.graph)\\n\\t\\tself.bottoms.update(other.bottoms)\\n\\t\\tself.output_shape.update(other.output_shape)\\n\\t\\tlayer_name = \\\"sub_{}\\\".format(len(self.graph))\\n\\t\\tself.graph[layer_name] = layer_name\\n\\t\\tself.bottoms[layer_name] = [self.cur_id, other.cur_id]\\n\\t\\tself.output_shape[layer_name] = self.cur_tensor.size()\\n\\t\\tself.cur_id = layer_name\\n\\t\\t# save memory\\n\\t\\tdel other\\n\\t\\treturn self\",\n \"def project(self, other, normalized=...):\\n ...\",\n \"def breadth_first_update(self, extra_roots=[], extra_updated=set()):\\n queue = []\\n updated = extra_updated\\n for k in self.__node_dict.keys():\\n if len(self.__node_dict[k].inputs) == 0:\\n queue.append(self.__node_dict[k])\\n queue.extend(extra_roots)\\n while (len(queue) != 0):\\n node_to_update = queue.pop(0)\\n # print('update {}'.format(node_to_update.uid))\\n if node_to_update not in updated:\\n node_to_update.update()\\n updated.add(node_to_update)\\n for element in node_to_update.outputs:\\n child = element['to_node']\\n if all([i['from_node'] in updated for i in child.inputs]):\\n queue.append(child)\\n # print('----done----')\",\n \"def pick_second(self, x, y):\\n\\n return self.cast(y, x.type.combine(y.type))\",\n \"def ancestor(self, fc2):\\n\\n acache = {}\\n\\n # prime the ancestor cache for the working directory\\n for c in (self, fc2):\\n if c._filerev == None:\\n pl = [(n.path(), n.filenode()) for n in c.parents()]\\n acache[(c._path, None)] = pl\\n\\n flcache = {self._repopath:self._filelog, fc2._repopath:fc2._filelog}\\n def parents(vertex):\\n if vertex in acache:\\n return acache[vertex]\\n f, n = vertex\\n if f not in flcache:\\n flcache[f] = self._repo.file(f)\\n fl = flcache[f]\\n pl = [(f, p) for p in fl.parents(n) if p != nullid]\\n re = fl.renamed(n)\\n if re:\\n pl.append(re)\\n acache[vertex] = pl\\n return pl\\n\\n a, b = (self._path, self._filenode), (fc2._path, fc2._filenode)\\n v = ancestor.ancestor(a, b, parents)\\n if v:\\n f, n = v\\n return filectx(self._repo, f, fileid=n, filelog=flcache[f])\\n\\n return None\",\n \"def replace_values(dfg1, dfg2):\\r\\n for edge in dfg1:\\r\\n if edge in dfg2:\\r\\n dfg1[edge] = dfg2[edge]\\r\\n return dfg1\",\n \"def decimate_to_fs2(st, fs2):\\n if fs2 is not None:\\n for tr in st:\\n fs = tr.stats.sampling_rate\\n factor = int(round(fs/fs2))\\n tr.decimate(factor=factor)\\n return st\",\n \"def fixture_second_bundle_data(\\n bundle_data, second_sample_vcf, second_family_vcf, second_timestamp\\n) -> dict:\\n second_bundle = deepcopy(bundle_data)\\n second_bundle[\\\"created_at\\\"] = second_timestamp\\n second_bundle[\\\"files\\\"][0][\\\"path\\\"] = str(second_sample_vcf)\\n second_bundle[\\\"files\\\"][1][\\\"path\\\"] = str(second_family_vcf)\\n return second_bundle\",\n \"def merge_contextual(self, other):\\n # TODO: This is currently dependent on our data model? Make more robust to schema changes\\n # Currently we assume all lists at Compound level, with 1 further potential nested level of lists\\n for k in self.keys():\\n # print('key: %s' % k)\\n for item in self[k]:\\n # print('item: %s' % item)\\n for other_item in other.get(k, []):\\n # Skip text properties (don't merge names, labels, roles)\\n if isinstance(other_item, six.text_type):\\n continue\\n for otherk in other_item.keys():\\n if isinstance(other_item[otherk], list):\\n if len(other_item[otherk]) > 0 and len(item[otherk]) > 0:\\n other_nested_item = other_item[otherk][0]\\n for othernestedk in other_nested_item.keys():\\n for nested_item in item[otherk]:\\n if not nested_item[othernestedk]:\\n nested_item[othernestedk] = other_nested_item[othernestedk]\\n elif not item[otherk]:\\n item[otherk] = other_item[otherk]\\n log.debug('Result: %s' % self.serialize())\\n return self\",\n \"def copy_from(self, other):\\n assert not self.is_final\\n if self.parent is not None:\\n assert other.parent is not None\\n self.parent.copy_from(other.parent)\\n self.isolated_names = copy.copy(other.isolated_names)\\n self.modified = copy.copy(other.modified)\\n self.read = copy.copy(other.read)\\n self.deleted = copy.copy(other.deleted)\\n self.bound = copy.copy(other.bound)\\n self.annotations = copy.copy(other.annotations)\\n self.params = copy.copy(other.params)\",\n \"def merge_forest(self, forest):\\n\\t\\tif len(forest) == 1:\\n\\t\\t\\treturn forest[0]\\n\\n\\t\\tfinal_tree = forest.pop()\\n\\t\\ttrees_to_process = forest\\n\\t\\twhile not len(trees_to_process) == 0:\\n\\t\\t\\ttree_in_question = trees_to_process.pop(0)\\n\\t\\t\\tif final_tree.contains(tree_in_question.value):\\n\\t\\t\\t\\tnodes_to_process = [final_tree]\\n\\t\\t\\t\\twhile not len(nodes_to_process) == 0:\\n\\t\\t\\t\\t\\tnode_in_question = nodes_to_process.pop()\\n\\t\\t\\t\\t\\tif node_in_question.value == tree_in_question.value:\\n\\t\\t\\t\\t\\t\\tnode_in_question.children += [tree_in_question]\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif not len(node_in_question.children) == 0:\\n\\t\\t\\t\\t\\t\\t\\tnodes_to_process += node_in_question.children\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttrees_to_process += [final_tree]\\n\\t\\t\\t\\tfinal_tree = tree_in_question\\n\\t\\treturn final_tree\",\n \"def test_field_resolution_multiple_inheritance_with_child_field_defined(self):\\n child_field = ChildWithMultipleParentsAndTheSameField()._get_fields()[\\\"name\\\"]\\n self.assertEqual(child_field.default, \\\"C\\\")\",\n \"def _grow_secondary(self, amt):\\n self._resize_secondary(amt)\",\n \"def process_other_feature_line(self, line):\\n kwargs = self.extract_other_feature_args(line)\\n if not kwargs:\\n return\\n parent_id = kwargs['parent_id']\\n if parent_id not in self.mrnas:\\n self.orphans.append(line)\\n return\\n parent_mrna = self.mrnas[parent_id]\\n parent_mrna.other_features.append(GenePart(**kwargs))\",\n \"def _merge_inplace(self, other):\\n if other is None:\\n yield\\n else:\\n # don't include indexes in priority_vars, because we didn't align\\n # first\\n priority_vars = OrderedDict(\\n (k, v) for k, v in self.variables.items() if k not in self.dims)\\n variables = merge_coords_without_align(\\n [self.variables, other.variables], priority_vars=priority_vars)\\n yield\\n self._update_coords(variables)\",\n \"def _deduplicate(self):\\n if self._clean:\\n return\\n\\n sorted_entries = sorted(\\n self._entries, key=lambda entry: (entry.depth, -len(entry.tail))\\n )\\n\\n self._entries = []\\n for entry in sorted_entries:\\n if any(entry.startswith(p) for p in self._entries):\\n continue\\n self._entries.append(entry)\\n self._clean = True\",\n \"def _check_other_folding(self, other):\\n if isinstance(other, self.__class__)\\\\\\n and (other.folded != self.folded):\\n raise ValueError('Cannot operate with a folded Spectrum and an '\\n 'unfolded one.')\",\n \"def fixupSecondaryFileNames(process):\\n if not hasattr(process.source, \\\"secondaryFileNames\\\"):\\n process.source.secondaryFileNames = cms.untracked.vstring()\\n return\",\n \"def resolve(self, vcf_field_key, first_vcf_field_value,\\n second_vcf_field_value):\\n # type: (str, Union[str, int], Union[str, int]) -> Union[str, int]\\n if vcf_field_key == VcfParserConstants.TYPE:\\n return self._resolve_type(first_vcf_field_value, second_vcf_field_value)\\n elif vcf_field_key == VcfParserConstants.NUM:\\n return self._resolve_number(first_vcf_field_value, second_vcf_field_value)\\n else:\\n # We only care about conflicts in 'num' and 'type' fields.\\n return first_vcf_field_value\",\n \"def _init_child(self,child,path):\\n pass\",\n \"def _resolve_dependency(self, chunks):\\n chunks = self._concatenate_inner(chunks, True)\\n chunks = self._concatenate_inner(chunks, False)\\n return chunks\",\n \"def handleLFNForMerge(self, mergefile, step):\\n\\n # First get the output module\\n # Do this by finding the name in the step report\\n # And then finding that module in the WMStep Helper\\n\\n outputName = getattr(mergefile, 'module_label', None)\\n if not outputName:\\n logging.error(\\\"Attempt to merge directly failed due to \\\" \\\\\\n + \\\"No module_label in file.\\\")\\n if outputName.lower() == \\\"merged\\\":\\n # Don't skip merge for merged files!\\n return mergefile\\n stepHelper = self.task.getStep(stepName=step)\\n outputMod = stepHelper.getOutputModule(moduleName=outputName)\\n\\n if not outputMod:\\n # Then we couldn't get the output module\\n logging.error(\\\"Attempt to directly merge failed \\\" \\\\\\n + \\\"due to no output module %s in WMStep\\\" \\\\\\n % (outputName))\\n return mergefile\\n\\n # Okay, now we should have the output Module\\n # Now we just need a second LFN\\n\\n newBase = getattr(outputMod, 'mergedLFNBase', None)\\n oldBase = getattr(outputMod, 'lfnBase', None)\\n\\n if not newBase:\\n # Then we don't have a base to change it to\\n logging.error(\\\"Direct to Merge failed due to no mergedLFNBase in %s\\\", outputName)\\n return mergefile\\n\\n # Replace the actual LFN base\\n oldLFN = getattr(mergefile, 'lfn')\\n newLFN = oldLFN.replace(oldBase, newBase)\\n\\n # Set the file attributes\\n setattr(mergefile, 'lfn', newLFN)\\n setattr(mergefile, 'merged', True)\\n\\n # Return the file\\n return mergefile\",\n \"def normalize(self):\\n blocks = set(self.blocks)\\n queue = set([self.entry_point])\\n visited = set()\\n while queue:\\n root = queue.pop()\\n visited.add(root)\\n for child in root.children:\\n if child not in visited:\\n queue.add(child)\\n unreachable = blocks - visited\\n for block in unreachable:\\n block.detach()\\n visited.remove(self.entry_point)\\n for block in visited:\\n if block.empty():\\n for parent in block.parents: # Re-parent\\n for child in block.children:\\n parent.add_child(child)\\n block.detach()\\n unreachable.add(block)\\n blocks -= unreachable\\n self.blocks = [block for block in self.blocks if block in blocks]\",\n \"def first_scf(self):\\n\\n files, input_dict, structure_with_tags = cp2k_utils.get_dft_inputs(\\n self.inputs.dft_params.get_dict(),\\n self.inputs.structure,\\n \\\"scf_ot_protocol.yml\\\",\\n self.inputs.protocol.value,\\n )\\n\\n builder = Cp2kCalculation.get_builder()\\n builder.structure = orm.StructureData(ase=structure_with_tags)\\n builder.code = self.inputs.code\\n builder.file = files\\n builder.metadata.options = self.ctx.scf_options\\n builder.metadata.label = \\\"scf\\\"\\n builder.metadata.options.parser_name = \\\"cp2k_advanced_parser\\\"\\n input_dict[\\\"GLOBAL\\\"][\\\"WALLTIME\\\"] = 86000\\n builder.parameters = orm.Dict(input_dict)\\n\\n future = self.submit(builder)\\n self.report(f\\\"Submitted scf of the initial geometry: {future.pk}\\\")\\n self.to_context(initial_scf=future)\",\n \"def flip_two(lnk):\\n if lnk is not Link.empty and lnk.rest is not Link.empty:\\n lnk.first, lnk.rest.first = lnk.rest.first, lnk.first\\n flip_two(lnk.rest.rest)\",\n \"def __ror__(self, other):\\n return self._dunder_concat(\\n other=other,\\n base_class=BaseForecaster,\\n composite_class=MultiplexForecaster,\\n attr_name=\\\"forecasters\\\",\\n concat_order=\\\"right\\\",\\n )\",\n \"def recombine(parent_1, parent_2, adaptive_mutation):\\n\\tchild_genotype = blend_crossover(parent_1, parent_2)\\n\\tif adaptive_mutation:\\n\\t\\tchild_sigma = child_sigma_v4(parent_1, parent_2)\\n\\telse:\\n\\t\\t# child sigma will be ignored in this case\\n\\t\\tchild_sigma = parent_1.sigma\\n\\n\\t# return new child object\\n\\treturn Individual(child_genotype, child_sigma)\",\n \"def pass_combine(firstgroup, secondgroup, xCar, buffer='30'):\\n #import ast\\n import pandas as pd #\\n import geopandas as gpd\\n from shapely.geometry import Point\\n buffer = float(buffer)\\n\\n if not \\\"prev_read\\\" in secondgroup.columns:\\n sgrp = secondgroup.copy()\\n secondgroup['prev_read'] = sgrp.loc[:, 'min_read']\\n\\n ### MAKE GEOPANDAS FRAME OF THE FIRST GROUP PEAKS\\n first_geo = [Point(lon, lat) for lon, lat in zip(firstgroup['pk_LON'], firstgroup['pk_LAT'])]\\n # crs = {'init': 'epsg:4326'}\\n #crs = {'init': 'epsg:32610'}\\n crs = 'EPSG:32610'\\n\\n #if 'geometry' in firstgroup.columns:\\n # firstgrp = gpd.GeoDataFrame(firstgroup.drop(columns=['geometry', 'pkGEO']), crs=crs, geometry=first_geo)\\n #else:\\n # firstgrp = gpd.GeoDataFrame(firstgroup.drop(columns=['pkGEO']), crs=crs, geometry=first_geo)\\n firstgrp = gpd.GeoDataFrame(firstgroup[firstgroup.columns.difference(['geometry','pkGEO'])].reset_index(drop=True),crs = crs,geometry=first_geo)\\n\\n first_buffg = firstgrp.copy()\\n first_buff = first_buffg.copy().drop(columns=['geometry'])\\n first_buff['geometry'] = first_buffg.apply(lambda x: x.geometry.buffer(0.00001 * buffer), axis=1)\\n firstgrp = first_buff.copy()\\n\\n sec_geo = [Point(lon, lat) for lon, lat in zip(secondgroup['pk_LON'], secondgroup['pk_LAT'])]\\n secgrp = gpd.GeoDataFrame(secondgroup.drop(columns=['geometry', 'pkGEO']), crs=crs, geometry=sec_geo)\\n\\n sec_buffg = secgrp.copy()\\n sec_buff = sec_buffg.copy().drop(columns=['geometry'])\\n sec_buff['geometry'] = sec_buffg.apply(lambda x: x.geometry.buffer(0.00001 * buffer), axis=1)\\n secgrp = sec_buff.copy()\\n\\n ## choosing the unique OPs from each group\\n first_pks = firstgrp.loc[:, ['OP_NUM', 'min_read', 'pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB']].drop_duplicates()\\n sec_pks = secgrp.loc[:, ['OP_NUM', 'min_read', 'pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB']].drop_duplicates()\\n\\n # combining to make one large dataframe of unique OPs\\n tot_pks = pd.concat([first_pks, sec_pks])\\n\\n ### COMBINE EACH GROUP (GEOMETRICALLY) BY THEIR OVERALL NAME (COULD BE VERIFIED)\\n first_dis = firstgrp.dissolve(by='min_read', as_index=False)[\\n ['min_read', 'geometry', 'recombine', 'verified', 'pass']].copy()\\n sec_dis = secgrp.dissolve(by='min_read', as_index=False)[\\n ['min_read', 'geometry', 'recombine', 'verified', 'pass']].copy()\\n\\n gdf_bind_pks = pd.concat([first_dis, sec_dis]).loc[:, ['min_read', 'geometry', 'recombine']]\\n gdf_tog = pd.concat([firstgroup.drop(['pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB'], axis=1),\\n secondgroup.drop(['pk_LAT', 'pk_LON', 'pk_maxCH4_AB','pk_maxC2H6_AB'], axis=1)]).copy()\\n gdf_tog2 = pd.concat([firstgroup, secondgroup]).copy()\\n\\n gdf_bind_pks['prev_read'] = gdf_bind_pks.loc[:, 'min_read']\\n gdf_tog['prev_read'] = gdf_tog.loc[:, 'min_read']\\n if gdf_bind_pks.shape[0] > 1:\\n data_overlap = gpd.GeoDataFrame(crs=gdf_bind_pks.crs).copy()\\n data_temp = gdf_bind_pks.copy()\\n data_temp = data_temp.to_crs(epsg=32610)\\n\\n for index, row in data_temp.iterrows():\\n data_temp1 = data_temp.loc[data_temp.min_read != row.min_read,]\\n data_temp1 = data_temp1.to_crs(epsg=32610)\\n # check if intersection occured\\n overlaps = data_temp1[data_temp1.geometry.overlaps(row.geometry)]['min_read'].tolist()\\n if len(overlaps) > 0:\\n # compare the area with threshold\\n for y in overlaps:\\n temp_area = gpd.overlay(data_temp.loc[data_temp.min_read == y,],\\n data_temp.loc[data_temp.min_read == row.min_read,], how='intersection')\\n temp_area = temp_area.to_crs(epsg=32610)\\n temp_area = temp_area.loc[temp_area.geometry.area >= 0]\\n # temp_union = gpd.overlay(data_temp.loc[data_temp.PEAK_NUM==y,],data_temp.loc[data_temp.PEAK_NUM==row.PEAK_NUM,],how='union')\\n if temp_area.shape[0] > 0:\\n temp_union = gpd.overlay(data_temp.loc[data_temp.min_read == y,],\\n data_temp.loc[data_temp.min_read == row.min_read,], how='union')\\n data_overlap = gpd.GeoDataFrame(pd.concat([temp_union, data_overlap], ignore_index=True),\\n crs=data_temp.crs)\\n\\n if data_overlap.size != 0:\\n firstnull = data_overlap[data_overlap.min_read_1.isnull()].copy()\\n firstnull.loc[:, 'min_read_1'] = firstnull.loc[:, 'min_read_2']\\n\\n secnull = data_overlap[data_overlap.min_read_2.isnull()].copy()\\n secnull['min_read_2'] = secnull['min_read_1'].copy()\\n\\n withoutNA = data_overlap.dropna().copy()\\n allTog = pd.concat([firstnull, secnull, withoutNA]).reset_index().copy()\\n\\n over = allTog.copy().drop(columns=['index'])\\n over['sorted'] = over.apply(lambda y: sorted([y['min_read_1'], y['min_read_2']]), axis=1).copy()\\n over['sorted'] = over.sorted.apply(lambda y: ','.join(y)).copy()\\n\\n over['same'] = over.apply(lambda x: x.min_read_1 != x.min_read_2, axis=1)\\n over = over.loc[over.same == True, :].drop(columns=['same'])\\n over = over.copy().drop_duplicates('sorted').reset_index(drop=True)\\n\\n\\n\\n over['bothcombine'] = over.apply(lambda x: sorted(check_lst(x.recombine_1) + check_lst(x.recombine_2)),\\n axis=1)\\n\\n over['combined'] = [list(x) for x in list(over.loc[:, ['min_read_1', 'min_read_2']].to_numpy())].copy()\\n over['VER_NUM'] = over.apply(lambda y: y.combined, axis=1).copy()\\n over['min_val'] = over.apply(lambda y: min(y.combined), axis=1).copy()\\n over = over.reset_index().loc[:,\\n ['min_read_1', 'min_read_2', 'geometry', 'combined', 'min_val', 'bothcombine']]\\n\\n new_1 = over.copy().drop(columns=['min_read_2']).rename(columns={'min_read_1': 'min_read'})\\n new_2 = over.copy().drop(columns=['min_read_1']).rename(columns={'min_read_2': 'min_read'})\\n newtog = pd.concat([new_1, new_2])\\n minreads = newtog.min_read.unique().tolist()\\n\\n if 'prev_read' in gdf_tog2.columns:\\n toChange = gdf_tog2[gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry', 'prev_read'])\\n elif 'prev_read' not in gdf_tog2.columns:\\n toChange = gdf_tog2[gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry'])\\n\\n toChangecombined = pd.merge(toChange, newtog, on=['min_read']).drop(\\n columns=['geometry', 'numtimes', 'verified', 'recombine'])\\n toChangecombined = toChangecombined.rename(columns={'min_read': 'prev_read', 'bothcombine': 'recombine'})\\n toChangecombined['numtimes'] = toChangecombined.apply(lambda x: count_times(x.recombine, xCar), axis=1)\\n\\n toChangecombined['verified'] = toChangecombined.apply(lambda x: x.numtimes > 1, axis=1)\\n toChangecombined = toChangecombined.rename(columns={'min_val': 'min_read'}).drop(columns=['combined'])\\n\\n toNotChange = gdf_tog2[~gdf_tog2['min_read'].isin(minreads)].drop(columns=['geometry'])\\n\\n if 'prev_read' in toNotChange.columns:\\n toNotChange = toNotChange.drop(columns=['prev_read'])\\n toNotChange['prev_read'] = toNotChange.min_read\\n elif 'prev_read' not in toNotChange.columns:\\n toNotChange.loc[:, 'prev_read'] = gdf_tog2[~gdf_tog2['min_read'].isin(minreads)].min_read\\n\\n newCombined = pd.concat([toChangecombined, toNotChange])\\n elif data_overlap.size == 0:\\n newCombined = gdf_tog2.copy()\\n if 'prev_read' not in newCombined.columns:\\n newCombined.loc[:, 'prev_read'] = gdf_tog2.loc[:, 'min_read']\\n elif gdf_bind_pks.shape[0] == 1:\\n newCombined = gdf_tog2.copy()\\n if 'prev_read' not in newCombined.columns:\\n newCombined.loc[:, 'prev_read'] = gdf_tog2.loc[:, 'min_read']\\n opCount = newCombined.groupby('OB_EPOCH').count()\\n samesies = list(opCount.loc[opCount.numtimes > 1, :].index)\\n if len(samesies) == 0:\\n smallCombined = newCombined.copy()\\n elif len(samesies) != 0:\\n smallCombined = newCombined.loc[~newCombined.OB_EPOCH.isin(samesies), :]\\n for index, op in enumerate(samesies):\\n smalldf = newCombined.loc[newCombined.OB_EPOCH == op, :]\\n recombined2 = (list(set([a for b in smalldf.recombine.tolist() for a in b])))\\n newminread = min(recombined2)\\n smalldf = smalldf.drop(columns=['min_read', 'recombine'])\\n smalldf['min_read'] = smalldf.apply(lambda x: newminread, axis=1)\\n smalldf = smalldf.drop_duplicates().reset_index(drop=True)\\n smalldf['recombine'] = smalldf.apply(lambda x: recombined2, axis=1)\\n smallCombined = pd.concat([smallCombined, smalldf]).reset_index(drop=True)\\n return (smallCombined)\",\n \"def merge_bom(self, other_bom):\\n for bom_entry in other_bom.entries():\\n self.create_and_add_entry(**bom_entry.attrs)\",\n \"def regrid_cfsv2(input_forcings, config_options, wrf_hydro_geo_meta, mpi_config):\\n # If the expected file is missing, this means we are allowing missing files, simply\\n # exit out of this routine as the regridded fields have already been set to NDV.\\n if not os.path.isfile(input_forcings.file_in2):\\n return\\n\\n # Check to see if the regrid complete flag for this\\n # output time step is true. This entails the necessary\\n # inputs have already been regridded and we can move on.\\n if input_forcings.regridComplete:\\n # Check to see if we are running NWM-custom interpolation/bias\\n # correction on incoming CFSv2 data. Because of the nature, we\\n # need to regrid bias-corrected data every hour.\\n if mpi_config.rank == 0:\\n config_options.statusMsg = \\\"No need to read in new CFSv2 data at this time.\\\"\\n err_handler.log_msg(config_options, mpi_config)\\n return\\n\\n # Create a path for a temporary NetCDF file\\n input_forcings.tmpFile = config_options.scratch_dir + \\\"/\\\" + \\\"CFSv2_TMP-{}.nc\\\".format(mkfilename())\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n if input_forcings.fileType != NETCDF:\\n\\n # This file shouldn't exist.... but if it does (previously failed\\n # execution of the program), remove it.....\\n if mpi_config.rank == 0:\\n if os.path.isfile(input_forcings.tmpFile):\\n config_options.statusMsg = \\\"Found old temporary file: \\\" + \\\\\\n input_forcings.tmpFile + \\\" - Removing.....\\\"\\n err_handler.log_warning(config_options, mpi_config)\\n try:\\n os.remove(input_forcings.tmpFile)\\n except OSError as err:\\n config_options.errMsg = \\\"Unable to remove previous temporary file: \\\" \\\\\\n + input_forcings.tmpFile + str(err)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n fields = []\\n for force_count, grib_var in enumerate(input_forcings.grib_vars):\\n if mpi_config.rank == 0:\\n config_options.statusMsg = \\\"Converting CFSv2 Variable: \\\" + grib_var\\n err_handler.log_msg(config_options, mpi_config)\\n fields.append(':' + grib_var + ':' +\\n input_forcings.grib_levels[force_count] + ':'\\n + str(input_forcings.fcst_hour2) + \\\" hour fcst:\\\")\\n fields.append(\\\":(HGT):(surface):\\\")\\n\\n # Create a temporary NetCDF file from the GRIB2 file.\\n cmd = '$WGRIB2 -match \\\"(' + '|'.join(fields) + ')\\\" ' + input_forcings.file_in2 + \\\\\\n \\\" -netcdf \\\" + input_forcings.tmpFile\\n id_tmp = ioMod.open_grib2(input_forcings.file_in2, input_forcings.tmpFile, cmd,\\n config_options, mpi_config, inputVar=None)\\n err_handler.check_program_status(config_options, mpi_config)\\n else:\\n create_link(\\\"CFSv2\\\", input_forcings.file_in2, input_forcings.tmpFile, config_options, mpi_config)\\n id_tmp = ioMod.open_netcdf_forcing(input_forcings.tmpFile, config_options, mpi_config)\\n\\n for force_count, grib_var in enumerate(input_forcings.grib_vars):\\n if mpi_config.rank == 0:\\n config_options.statusMsg = \\\"Processing CFSv2 Variable: \\\" + grib_var\\n err_handler.log_msg(config_options, mpi_config)\\n\\n calc_regrid_flag = check_regrid_status(id_tmp, force_count, input_forcings,\\n config_options, wrf_hydro_geo_meta, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n if calc_regrid_flag:\\n if mpi_config.rank == 0:\\n config_options.statusMsg = \\\"Calculate CFSv2 regridding weights.\\\"\\n err_handler.log_msg(config_options, mpi_config)\\n\\n calculate_weights(id_tmp, force_count, input_forcings, config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Read in the RAP height field, which is used for downscaling purposes.\\n # if mpi_config.rank == 0:\\n # config_options.statusMsg = \\\"Reading in CFSv2 elevation data.\\\"\\n # err_handler.log_msg(config_options, mpi_config)\\n #\\n # cmd = \\\"$WGRIB2 \\\" + input_forcings.file_in2 + \\\" -match \\\" + \\\\\\n # \\\"\\\\\\\":(HGT):(surface):\\\\\\\" \\\" + \\\\\\n # \\\" -netcdf \\\" + input_forcings.tmpFileHeight\\n # id_tmp_height = ioMod.open_grib2(input_forcings.file_in2, input_forcings.tmpFileHeight,\\n # cmd, config_options, mpi_config, 'HGT_surface')\\n # err_handler.check_program_status(config_options, mpi_config)\\n\\n # Regrid the height variable.\\n var_tmp = None\\n if mpi_config.rank == 0:\\n try:\\n var_tmp = id_tmp.variables['HGT_surface'][0, :, :]\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to extract HGT_surface from file: \\\" \\\\\\n + input_forcings.file_in2 + \\\" (\\\" + str(err) + \\\")\\\"\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n var_sub_tmp = mpi_config.scatter_array(input_forcings, var_tmp, config_options)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n try:\\n input_forcings.esmf_field_in.data[:, :] = var_sub_tmp\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to place CFSv2 elevation data into the ESMF field object: \\\" + str(err)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n if mpi_config.rank == 0:\\n config_options.statusMsg = \\\"Regridding CFSv2 elevation data to the WRF-Hydro domain.\\\"\\n err_handler.log_msg(config_options, mpi_config)\\n\\n try:\\n input_forcings.esmf_field_out = input_forcings.regridObj(input_forcings.esmf_field_in,\\n input_forcings.esmf_field_out)\\n except ValueError as ve:\\n config_options.errMsg = \\\"Unable to regrid CFSv2 elevation data to the WRF-Hydro domain: \\\" + str(ve)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Set any pixel cells outside the input domain to the global missing value.\\n try:\\n input_forcings.esmf_field_out.data[np.where(input_forcings.regridded_mask == 0)] = \\\\\\n config_options.globalNdv\\n except (ValueError, ArithmeticError) as npe:\\n config_options.errMsg = \\\"Unable to run mask calculation on CFSv2 elevation data: \\\" + str(npe)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n try:\\n input_forcings.height[:, :] = input_forcings.esmf_field_out.data\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to extract CFSv2 regridded elevation data from ESMF field: \\\" + str(err)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Close the temporary NetCDF file and remove it.\\n # if mpi_config.rank == 0:\\n # try:\\n # id_tmp_height.close()\\n # except OSError:\\n # config_options.errMsg = \\\"Unable to close temporary file: \\\" + input_forcings.tmpFileHeight\\n # err_handler.log_critical(config_options, mpi_config)\\n # err_handler.check_program_status(config_options, mpi_config)\\n #\\n # if mpi_config.rank == 0:\\n # try:\\n # os.remove(input_forcings.tmpFileHeight)\\n # except OSError:\\n # config_options.errMsg = \\\"Unable to remove temporary file: \\\" + input_forcings.tmpFileHeight\\n # err_handler.log_critical(config_options, mpi_config)\\n # err_handler.check_program_status(config_options, mpi_config)\\n\\n # Regrid the input variables.\\n var_tmp = None\\n if mpi_config.rank == 0:\\n if not config_options.runCfsNldasBiasCorrect:\\n config_options.statusMsg = \\\"Regridding CFSv2 variable: \\\" + \\\\\\n input_forcings.netcdf_var_names[force_count]\\n err_handler.log_msg(config_options, mpi_config)\\n try:\\n var_tmp = id_tmp.variables[input_forcings.netcdf_var_names[force_count]][0, :, :]\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to extract: \\\" + input_forcings.netcdf_var_names[force_count] + \\\\\\n \\\" from file: \\\" + input_forcings.tmpFile + \\\" (\\\" + str(err) + \\\")\\\"\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Scatter the global CFSv2 data to the local processors.\\n var_sub_tmp = mpi_config.scatter_array(input_forcings, var_tmp, config_options)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Assign local CFSv2 data to the input forcing object.. IF..... we are running the\\n # bias correction. These grids are interpolated in a separate routine, AFTER bias\\n # correction has taken place.\\n if config_options.runCfsNldasBiasCorrect:\\n if input_forcings.coarse_input_forcings1 is None: # and config_options.current_output_step == 1:\\n # if not np.any(input_forcings.coarse_input_forcings1) and not \\\\\\n # np.any(input_forcings.coarse_input_forcings2) and \\\\\\n # ConfigOptions.current_output_step == 1:\\n # We need to create NumPy arrays to hold the CFSv2 global data.\\n input_forcings.coarse_input_forcings1 = np.empty([8, var_sub_tmp.shape[0], var_sub_tmp.shape[1]],\\n np.float64)\\n\\n if input_forcings.coarse_input_forcings2 is None: # and config_options.current_output_step == 1:\\n # if not np.any(input_forcings.coarse_input_forcings1) and not \\\\\\n # np.any(input_forcings.coarse_input_forcings2) and \\\\\\n # ConfigOptions.current_output_step == 1:\\n # We need to create NumPy arrays to hold the CFSv2 global data.\\n input_forcings.coarse_input_forcings2 = np.empty([8, var_sub_tmp.shape[0], var_sub_tmp.shape[1]],\\n np.float64)\\n\\n try:\\n input_forcings.coarse_input_forcings2[input_forcings.input_map_output[force_count], :, :] = var_sub_tmp\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to place local CFSv2 input variable: \\\" + \\\\\\n input_forcings.netcdf_var_names[force_count] + \\\\\\n \\\" into local numpy array. (\\\" + str(err) + \\\")\\\"\\n # except TypeError:\\n # print(\\\"DEBUG: \\\", input_forcings.coarse_input_forcings2, input_forcings.input_map_output, force_count)\\n\\n if config_options.current_output_step == 1:\\n input_forcings.coarse_input_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\\\\n input_forcings.coarse_input_forcings2[input_forcings.input_map_output[force_count], :, :]\\n else:\\n input_forcings.coarse_input_forcings2 = None\\n input_forcings.coarse_input_forcings1 = None\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Only regrid the current files if we did not specify the NLDAS2 NWM bias correction, which needs to take place\\n # first before any regridding can take place. That takes place in the bias-correction routine.\\n if not config_options.runCfsNldasBiasCorrect:\\n try:\\n input_forcings.esmf_field_in.data[:, :] = var_sub_tmp\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to place CFSv2 forcing data into temporary ESMF field: \\\" + str(err)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n try:\\n input_forcings.esmf_field_out = input_forcings.regridObj(input_forcings.esmf_field_in,\\n input_forcings.esmf_field_out)\\n except ValueError as ve:\\n config_options.errMsg = \\\"Unable to regrid CFSv2 variable: \\\" + \\\\\\n input_forcings.netcdf_var_names[force_count] + \\\" (\\\" + str(ve) + \\\")\\\"\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # Set any pixel cells outside the input domain to the global missing value.\\n try:\\n input_forcings.esmf_field_out.data[np.where(input_forcings.regridded_mask == 0)] = \\\\\\n config_options.globalNdv\\n except (ValueError, ArithmeticError) as npe:\\n config_options.errMsg = \\\"Unable to run mask calculation on CFSv2 variable: \\\" + \\\\\\n input_forcings.netcdf_var_names[force_count] + \\\" (\\\" + str(npe) + \\\")\\\"\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n try:\\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :] = \\\\\\n input_forcings.esmf_field_out.data\\n except (ValueError, KeyError, AttributeError) as err:\\n config_options.errMsg = \\\"Unable to extract ESMF field data for CFSv2: \\\" + str(err)\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n # If we are on the first timestep, set the previous regridded field to be\\n # the latest as there are no states for time 0.\\n if config_options.current_output_step == 1:\\n input_forcings.regridded_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\\\\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :]\\n err_handler.check_program_status(config_options, mpi_config)\\n else:\\n # Set regridded arrays to dummy values as they are regridded later in the bias correction routine.\\n input_forcings.regridded_forcings1[input_forcings.input_map_output[force_count], :, :] = \\\\\\n config_options.globalNdv\\n input_forcings.regridded_forcings2[input_forcings.input_map_output[force_count], :, :] = \\\\\\n config_options.globalNdv\\n\\n # Close the temporary NetCDF file and remove it.\\n if mpi_config.rank == 0:\\n try:\\n id_tmp.close()\\n except OSError:\\n config_options.errMsg = \\\"Unable to close NetCDF file: \\\" + input_forcings.tmpFile\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\\n\\n if mpi_config.rank == 0:\\n try:\\n os.remove(input_forcings.tmpFile)\\n except OSError:\\n config_options.errMsg = \\\"Unable to remove NetCDF file: \\\" + input_forcings.tmpFile\\n err_handler.log_critical(config_options, mpi_config)\\n err_handler.check_program_status(config_options, mpi_config)\",\n \"def _finish_init(self):\\n\\n # This is usually done in set_other(), but we already set it as part of\\n # the constructor.\\n self.this_branch.fetch(self.other_branch,\\n last_revision=self.other_basis)\",\n \"def merge_new_domain (cls, base, nffg, log=logging.getLogger(\\\"MERGE\\\")):\\n # Get new domain name\\n domain = cls.detect_domains(nffg=nffg)\\n if len(domain) == 0:\\n log.error(\\\"No domain detected in new %s!\\\" % nffg)\\n return\\n if len(domain) > 1:\\n log.warning(\\\"Multiple domain name detected in new %s!\\\" % nffg)\\n return\\n # Copy infras\\n log.debug(\\\"Merge domain: %s resource info into %s...\\\" % (domain.pop(),\\n base.id))\\n # Check if the infra with given id is already exist in the base NFFG\\n for infra in nffg.infras:\\n if infra.id not in base:\\n c_infra = base.add_infra(infra=deepcopy(infra))\\n log.debug(\\\"Copy infra node: %s\\\" % c_infra)\\n else:\\n log.warning(\\\"Infra node: %s does already exist in %s. Skip adding...\\\" %\\n (infra, base))\\n # Copy NFs\\n for nf in nffg.nfs:\\n if nf.id not in base:\\n c_nf = base.add_nf(nf=deepcopy(nf))\\n log.debug(\\\"Copy NF node: %s\\\" % c_nf)\\n else:\\n log.warning(\\\"NF node: %s does already exist in %s. Skip adding...\\\" %\\n (nf, base))\\n # Copy SAPs\\n for sap_id in [s.id for s in nffg.saps]:\\n if sap_id in [s.id for s in base.saps]:\\n # Found inter-domain SAP\\n log.debug(\\\"Found Inter-domain SAP: %s\\\" % sap_id)\\n # Search outgoing links from SAP, should be only one\\n b_links = [l for u, v, l in base.real_out_edges_iter(sap_id)]\\n if len(b_links) < 1:\\n log.warning(\\n \\\"SAP is not connected to any node! Maybe you forgot to call \\\"\\n \\\"duplicate_static_links?\\\")\\n return\\n elif 1 < len(b_links):\\n log.warning(\\n \\\"Inter-domain SAP should have one and only one connection to the \\\"\\n \\\"domain! Using only the first connection.\\\")\\n continue\\n # Get inter-domain port in base NFFG\\n domain_port_dov = b_links[0].dst\\n sap_port_dov = b_links[0].src\\n log.debug(\\\"Found inter-domain port: %s\\\" % domain_port_dov)\\n # Search outgoing links from SAP, should be only one\\n n_links = [l for u, v, l in nffg.real_out_edges_iter(sap_id)]\\n if len(n_links) < 1:\\n log.warning(\\n \\\"SAP is not connected to any node! Maybe you forgot to call \\\"\\n \\\"duplicate_static_links?\\\")\\n return\\n elif 1 < len(n_links):\\n log.warning(\\n \\\"Inter-domain SAP should have one and only one connection to the \\\"\\n \\\"domain! Using only the first connection.\\\")\\n continue\\n # Get port and Infra id's in nffg NFFG\\n p_id = n_links[0].dst.id\\n n_id = n_links[0].dst.node.id\\n # Get the inter-domain port from already copied Infra\\n domain_port_nffg = base.network.node[n_id].ports[p_id]\\n sap_port_nffg = n_links[0].src\\n log.debug(\\\"Found inter-domain port: %s\\\" % domain_port_nffg)\\n\\n # # If the two resource value does not match\\n # if sap_port_dov.delay != sap_port_nffg.delay:\\n # if sap_port_dov.delay is None:\\n # # If first is None the other can not be None\\n # s_delay = sap_port_nffg.delay\\n # elif sap_port_nffg.delay is None:\\n # # If second is None the other can not be None\\n # s_delay = sap_port_dov.delay\\n # else:\\n # # Both values are valid, but different\\n # s_delay = max(sap_port_dov.delay, sap_port_nffg.delay)\\n # log.warning(\\n # \\\"Inter-domain delay values (%s, %s) are set but do not match!\\\"\\n # \\\" Use max: %s\\\" % (sap_port_dov.delay, sap_port_nffg.delay,\\n # s_delay))\\n # else:\\n # # Both value match: ether valid values or Nones --> choose first\\n # value\\n # s_delay = sap_port_dov.delay\\n #\\n # # If the two resource value does not match\\n # if sap_port_dov.bandwidth != sap_port_nffg.bandwidth:\\n # if sap_port_dov.bandwidth is None:\\n # # If first is None the other can not be None\\n # s_bandwidth = sap_port_nffg.bandwidth\\n # elif sap_port_nffg.bandwidth is None:\\n # # If second is None the other can not be None\\n # s_bandwidth = sap_port_dov.bandwidth\\n # else:\\n # # Both values are valid, but different\\n # s_bandwidth = min(sap_port_dov.bandwidth,\\n # sap_port_nffg.bandwidth)\\n # log.warning(\\n # \\\"Inter-domain bandwidth values (%s, %s) are set but do not\\n # match!\\\"\\n # \\\" Use min: %s\\\" % (sap_port_dov.bandwidth,\\n # sap_port_nffg.bandwidth, s_bandwidth))\\n # else:\\n # # Both value match: ether valid values or Nones --> choose first\\n # value\\n # s_bandwidth = sap_port_dov.bandwidth\\n #\\n # log.debug(\\\"Detected inter-domain resource values: delay: %s, \\\"\\n # \\\"bandwidth: %s\\\" % (s_delay, s_bandwidth))\\n\\n # Copy inter-domain port properties/values for redundant storing\\n if len(domain_port_nffg.properties) > 0:\\n domain_port_dov.properties.update(domain_port_nffg.properties)\\n log.debug(\\\"Copy inter-domain port properties: %s\\\" %\\n domain_port_dov.properties)\\n elif len(domain_port_dov.properties) > 0:\\n domain_port_nffg.properties.update(domain_port_dov.properties)\\n log.debug(\\\"Copy inter-domain port properties: %s\\\" %\\n domain_port_nffg.properties)\\n # Ensure to add sap tag to inter domain ports\\n if 'sap' not in domain_port_dov.properties:\\n domain_port_dov.add_property(\\\"sap\\\", sap_id)\\n if 'sap' not in domain_port_nffg.properties:\\n domain_port_nffg.add_property(\\\"sap\\\", sap_id)\\n # Signal Inter-domain port type\\n domain_port_dov.add_property(\\\"type\\\", \\\"inter-domain\\\")\\n domain_port_nffg.add_property(\\\"type\\\", \\\"inter-domain\\\")\\n\\n # Copy SAP port values into the infra ports\\n domain_port_dov.name = sap_port_dov.name\\n domain_port_dov.sap = sap_port_dov.sap\\n domain_port_dov.capability = sap_port_dov.capability\\n domain_port_dov.technology = sap_port_dov.technology\\n domain_port_dov.delay = sap_port_dov.delay\\n domain_port_dov.bandwidth = sap_port_dov.bandwidth\\n domain_port_dov.cost = sap_port_dov.cost\\n domain_port_dov.controller = sap_port_dov.controller\\n domain_port_dov.orchestrator = sap_port_dov.orchestrator\\n domain_port_dov.l2 = sap_port_dov.l2\\n domain_port_dov.l4 = sap_port_dov.l4\\n for l3 in sap_port_dov.l3:\\n domain_port_dov.l3.append(l3.copy())\\n domain_port_dov.metadata.update(sap_port_dov.metadata)\\n\\n domain_port_nffg.name = sap_port_nffg.name\\n domain_port_nffg.sap = sap_port_nffg.sap\\n domain_port_nffg.capability = sap_port_nffg.capability\\n domain_port_nffg.technology = sap_port_nffg.technology\\n domain_port_nffg.delay = sap_port_nffg.delay\\n domain_port_nffg.bandwidth = sap_port_nffg.bandwidth\\n domain_port_nffg.cost = sap_port_nffg.cost\\n domain_port_nffg.controller = sap_port_nffg.controller\\n domain_port_nffg.orchestrator = sap_port_nffg.orchestrator\\n domain_port_nffg.l2 = sap_port_nffg.l2\\n domain_port_nffg.l4 = sap_port_nffg.l4\\n for l3 in sap_port_nffg.l3:\\n domain_port_nffg.l3.append(l3.copy())\\n domain_port_nffg.metadata.update(sap_port_nffg.metadata)\\n\\n # Delete both inter-domain SAP and links connected to them\\n base.del_node(sap_id)\\n nffg.del_node(sap_id)\\n\\n # Add the inter-domain links for both ways\\n l1, l2 = base.add_undirected_link(\\n p1p2id=\\\"inter-domain-link-%s\\\" % sap_id,\\n p2p1id=\\\"inter-domain-link-%s-back\\\" % sap_id,\\n port1=domain_port_dov,\\n port2=domain_port_nffg)\\n # Set delay/bandwidth values for outgoing link port1 -> port2\\n l1.delay = domain_port_dov.delay\\n l1.bandwidth = domain_port_dov.bandwidth\\n # Set delay/bandwidth values for outgoing link port2 -> port2\\n l2.delay = domain_port_nffg.delay\\n l2.bandwidth = domain_port_nffg.bandwidth\\n\\n else:\\n # Normal SAP --> copy SAP\\n c_sap = base.add_sap(sap_obj=deepcopy(nffg.network.node[sap_id]))\\n log.debug(\\\"Copy SAP: %s\\\" % c_sap)\\n # Copy remaining links which should be valid\\n for u, v, link in nffg.network.edges_iter(data=True):\\n src_port = base.network.node[u].ports[link.src.id]\\n dst_port = base.network.node[v].ports[link.dst.id]\\n c_link = deepcopy(link)\\n c_link.src = src_port\\n c_link.dst = dst_port\\n base.add_link(src_port=src_port, dst_port=dst_port, link=c_link)\\n log.debug(\\\"Copy Link: %s\\\" % c_link)\\n log.debug(\\\"Domain merging has been finished!\\\")\\n # Return the updated NFFG\\n return base\",\n \"def kspace_project_out(self, other):\\n\\n n_points = np.max(np.array([n_lattice(self), n_lattice(other)]), axis = 0)\\n self_k = transform(self, np.fft.fftn, n_points = n_points)\\n other_k = transform(other, np.fft.fftn, n_points = n_points)\\n\\n for i in np.arange(len(self_k.blocks)-1):\\n self_k.blocks[i] -= other_k.blocks[i]\",\n \"def merge(path_to_mf_lf_1, path_to_mf_lf_2, path_to_mf_hf_1, path_to_mf_hf_2, path_to_sf,\\n path_to_mf_lf, path_to_mf_hf, path_to_sf_copy):\\n mf_lf = merge_one_case(pd.read_csv(path_to_mf_lf_1, index_col=0), pd.read_csv(path_to_mf_lf_2, index_col=0))\\n mf_hf = merge_one_case(pd.read_csv(path_to_mf_hf_1, index_col=0), pd.read_csv(path_to_mf_hf_2, index_col=0))\\n sf = pd.read_csv(path_to_sf, index_col=0) # only bypassed\\n mf_lf.to_csv(path_to_mf_lf, index=True, header=True)\\n mf_hf.to_csv(path_to_mf_hf, index=True, header=True)\\n sf.to_csv(path_to_sf_copy, index=True, header=True)\",\n \"def mySecondTree (ns):\\n\\n # Make a list of the child nodes specified by TDLOptions:\\n cc = []\\n if copt_MeqFreq:\\n cc.append(ns.MeqFreq << Meq.Freq())\\n if copt_MeqTime:\\n cc.append(ns.MeqTime << Meq.Time())\\n if copt_complex:\\n cc.append(ns.complex << Meq.ToComplex(ns << Meq.Freq(), ns << Meq.Time()))\\n if copt_MeqGaussNoise>0:\\n cc.append(ns.MeqGaussNoise << Meq.GaussNoise(stddev=copt_MeqGaussNoise))\\n\\n # Make sure that there is at least one child, and add them all:\\n if len(cc)==0:\\n cc.append(ns.zero << 0.0)\\n rootnode = ns.sum << Meq.Add(*cc)\\n\\n # Finishing touches:\\n BM.bookpage_nodes (cc+[rootnode], help=None,\\n name='mySecondTree nodes')\\n rootnode = BM.bookpage_function_result (rootnode, func=mySecondTree, ns=ns, other=[])\\n return rootnode\",\n \"def _rewrite_concat(self, node: saldag.Concat):\\n\\n assert (not node.is_lower_boundary())\\n\\n out_stored_with = node.out_rel.stored_with\\n ordered_pars = node.get_sorted_parents()\\n for parent in ordered_pars:\\n par_stored_with = parent.out_rel.stored_with\\n if par_stored_with != out_stored_with:\\n out_rel = copy.deepcopy(parent.out_rel)\\n out_rel.rename(out_rel.name + \\\"_close\\\")\\n out_rel.stored_with = copy.copy(out_stored_with)\\n # create and insert close node\\n store_op = saldag.Close(out_rel, None)\\n store_op.is_mpc = True\\n saldag.insert_between(parent, node, store_op)\",\n \"def merge_two_keyword_chunks(data_first, data_second):\\n common_keyword = data_first.columns.intersection(data_second.columns)[0]\\n scaling_factor = np.nanmedian(\\n data_first[common_keyword] / data_second[common_keyword])\\n data_second = data_second.apply(lambda x: x * scaling_factor)\\n data = pd.merge(data_first, data_second.drop(\\n common_keyword, axis=1), left_index=True, right_index=True)\\n return data\",\n \"def double(self):\\r\\n for i in range(len(self.links)):\\r\\n s = self.links[i]\\r\\n second_copy = self.link(s.a, s.b)\\r\\n if s.value == 'RUNG':\\r\\n second_copy.value = 'SCAFFOLD_RUNG'\\r\\n else:\\r\\n second_copy.value = 'SCAFFOLD'\\r\\n second_copy.index = None\",\n \"def _sync_children(self, source_parent, destination_parent, new_child):\\r\\n destination_reordered = []\\r\\n destination_children = destination_parent['fields']['children']\\r\\n source_children = source_parent['fields']['children']\\r\\n orphans = set()\\r\\n for child in destination_children:\\r\\n try:\\r\\n source_children.index(child)\\r\\n except ValueError:\\r\\n orphans.add(child)\\r\\n for child in source_children:\\r\\n if child == new_child or child in destination_children:\\r\\n destination_reordered.append(child)\\r\\n destination_parent['fields']['children'] = destination_reordered\\r\\n return orphans\",\n \"def add_dependent_lookup_field(self, displayName, primaryLookupField, lookupField):\\n return_field = Field(self.context)\\n self.add_child(return_field)\\n parameters = {\\n \\\"displayName\\\": displayName,\\n \\\"primaryLookupField\\\": primaryLookupField,\\n \\\"lookupField\\\": lookupField\\n }\\n qry = ServiceOperationQuery(self, \\\"AddDependentLookupField\\\", None, parameters, None, return_field)\\n self.context.add_query(qry)\\n return return_field\",\n \"def second_category_axis(self, second_category_axis):\\n\\n self.container['second_category_axis'] = second_category_axis\",\n \"def post_process(fasta_fp, mapping_fp, denoised_seqs_fp,\\r\\n otu_picker_otu_map_fp, out_dir):\\r\\n\\r\\n combine_mappings(open(fasta_fp), open(mapping_fp),\\r\\n open(denoised_seqs_fp),\\r\\n open(otu_picker_otu_map_fp), out_dir)\",\n \"def _splitBucket(self, bucket):\\n idx = self.buckets.index(bucket)\\n self.buckets.pop(idx)\\n middle = int(bucket.low + (bucket.high - bucket.low)/2)\\n \\n bucketLow = Bucket(bucket.low, middle, bucket.refreshed)\\n bucketHigh = Bucket(middle+1, bucket.high, refreshed.refreshed)\\n \\n self.buckets.append(bucketLow)\\n self.buckets.append(bucketHigh)\\n \\n for bucket in bucket.nodes:\\n if bucketLow.inRange(bucket):\\n bucketLow.addNode(bucket)\\n else:\\n bucketHigh.addNode(bucket)\\n \\n return (bucketLow, bucketHigh)\",\n \"def merge(self, other_btree):\\n pass\",\n \"def mconcat(a, b):\\r\\n if a is None:\\r\\n return b\\r\\n if b is None:\\r\\n return a\\r\\n for key in b.keyset:\\r\\n value=get(b,key)\\r\\n put(a,key,value)\\r\\n return a\",\n \"def __finalize__(self, other, method=None, **kwargs):\\r\\n # merge operation: using metadata of the left object\\r\\n if method == 'merge':\\r\\n for name in self._metadata:\\r\\n object.__setattr__(self, name, getattr(other.left, name, None))\\r\\n # concat operation: using metadata of the first object\\r\\n elif method == 'concat':\\r\\n for name in self._metadata:\\r\\n object.__setattr__(self, name, getattr(other.objs[0], name, None))\\r\\n else:\\r\\n for name in self._metadata:\\r\\n object.__setattr__(self, name, getattr(other, name, None))\\r\\n return self\",\n \"def multi_dc_replace_with_rf1_test(self):\\n cluster = self.cluster\\n cluster.populate([1, 1])\\n cluster.start()\\n node1, node2 = cluster.nodelist()\\n\\n node1 = cluster.nodes['node1']\\n yaml_config = \\\"\\\"\\\"\\n # Create the keyspace and table\\n keyspace: keyspace1\\n keyspace_definition: |\\n CREATE KEYSPACE keyspace1 WITH replication = {'class': 'NetworkTopologyStrategy', 'dc1': 1, 'dc2': 1};\\n table: users\\n table_definition:\\n CREATE TABLE users (\\n username text,\\n first_name text,\\n last_name text,\\n email text,\\n PRIMARY KEY(username)\\n ) WITH compaction = {'class':'SizeTieredCompactionStrategy'};\\n insert:\\n partitions: fixed(1)\\n batchtype: UNLOGGED\\n queries:\\n read:\\n cql: select * from users where username = ?\\n fields: samerow\\n \\\"\\\"\\\"\\n with tempfile.NamedTemporaryFile(mode='w+') as stress_config:\\n stress_config.write(yaml_config)\\n stress_config.flush()\\n node1.stress(['user', 'profile=' + stress_config.name, 'n=10k', 'no-warmup',\\n 'ops(insert=1)', '-rate', 'threads=50'])\\n\\n session = self.patient_cql_connection(node1)\\n\\n # change system_auth keyspace to 2 (default is 1) to avoid\\n # \\\"Unable to find sufficient sources for streaming\\\" warning\\n if cluster.cassandra_version() >= '2.2.0':\\n session.execute(\\\"\\\"\\\"\\n ALTER KEYSPACE system_auth\\n WITH replication = {'class':'SimpleStrategy', 'replication_factor':2};\\n \\\"\\\"\\\")\\n\\n # Save initial data\\n stress_table = 'keyspace1.users'\\n query = SimpleStatement('select * from %s LIMIT 1' % stress_table, consistency_level=ConsistencyLevel.TWO)\\n initial_data = rows_to_list(session.execute(query))\\n\\n # stop node to replace\\n debug(\\\"Stopping node to replace.\\\")\\n node2.stop(wait_other_notice=True)\\n\\n node3 = new_node(cluster, data_center='dc2')\\n node3.start(replace_address='127.0.0.2', wait_for_binary_proto=True)\\n\\n assert_bootstrap_state(self, node3, 'COMPLETED')\\n\\n # Check that keyspace was replicated from dc1 to dc2\\n self.assertFalse(node3.grep_log(\\\"Unable to find sufficient sources for streaming range\\\"))\\n\\n # query should work again with node1 stopped\\n node1.stop(wait_other_notice=True)\\n debug(\\\"Verifying data on new node.\\\")\\n session = self.patient_exclusive_cql_connection(node3)\\n assert_all(session, 'SELECT * from {} LIMIT 1'.format(stress_table),\\n expected=initial_data,\\n cl=ConsistencyLevel.LOCAL_ONE)\",\n \"def copy_from(self, another: \\\"TrieMatcher\\\"):\\n # noinspection PyUnresolvedReferences\\n from grantinfo.lexmatch.triematcher import TrieMatcher\\n\\n assert isinstance(another, TrieMatcher), \\\\\\n f\\\"type(another) = '{type(another)}', should be '{TrieMatcher.__qualname__}'\\\"\\n\\n super().copy_from(another)\\n\\n self.match_helper = another.match_helper\\n\\n # No need to copy:\\n # ... member fields caching params\\n # self.name_preference_*\\n # ... invariant members\\n # self.tknzr\\n\\n return\",\n \"def update_node2edge(self):\\n self.node2edge = {e.child : e for e in self.edge}\\n childrenset = set(self.node2edge.keys())\\n rootset = set(e.parent for e in self.edge).difference(childrenset)\\n if len(rootset) > 1:\\n raise Warning(\\\"there should be a single root: \\\" + str(rootset))\\n if len(rootset) == 0:\\n raise Exception(\\\"there should be at least one root!\\\")\\n self.root = rootset.pop()\",\n \"def combine_cluster_from_to(cl1, cl2):\\n for node_id in clusters[cl1]:\\n nodes[node_id] = cl2\\n clusters[cl2].append(node_id)\\n clusters.pop(cl1)\",\n \"def replace_self_references(self) -> None:\\n for child in self.get_children_typed_dicts():\\n if child is self:\\n child.replace_with_dict.add(self.name)\\n continue\\n for sub_child in child.get_children_typed_dicts():\\n if sub_child.replace_with_dict:\\n continue\\n if sub_child is self:\\n sub_child.replace_with_dict.add(child.name)\\n continue\",\n \"def merge_df(self, first_df, second_df):\\n self.file = pd.merge(second_df, first_df, on=[(\\\"NAME\\\", \\\"TYPE\\\")])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.49451524","0.48374847","0.4816826","0.47681516","0.47121134","0.46719477","0.46434382","0.4612929","0.45820156","0.45763972","0.4503654","0.45029733","0.44901878","0.44694677","0.44611233","0.44572702","0.4405865","0.4381707","0.43751577","0.43663976","0.43463948","0.43383056","0.4318211","0.43122473","0.43044317","0.42847285","0.4284434","0.42740804","0.4261431","0.42483723","0.42393687","0.42233568","0.4215681","0.4212712","0.42126065","0.42104197","0.42050523","0.42046538","0.42046124","0.42017403","0.41940245","0.41939113","0.41902924","0.41882488","0.41812566","0.4172939","0.4169072","0.4166653","0.41644597","0.4154366","0.41536143","0.4151372","0.41475597","0.41413814","0.41304442","0.4130242","0.4127373","0.41188562","0.4112576","0.41083813","0.4100796","0.4099253","0.4095279","0.4087989","0.4080605","0.4076361","0.40751383","0.40741518","0.40695003","0.4064381","0.40640312","0.4056866","0.40556058","0.4053596","0.40532848","0.4052854","0.40525904","0.40510106","0.4048512","0.4047699","0.40367365","0.4033035","0.40319028","0.40313503","0.4028396","0.4023992","0.4023711","0.40236026","0.4023098","0.40226966","0.40226582","0.40223306","0.4021724","0.40186378","0.40184578","0.4017148","0.40140012","0.4012981","0.4009407","0.40079984"],"string":"[\n \"0.49451524\",\n \"0.48374847\",\n \"0.4816826\",\n \"0.47681516\",\n \"0.47121134\",\n \"0.46719477\",\n \"0.46434382\",\n \"0.4612929\",\n \"0.45820156\",\n \"0.45763972\",\n \"0.4503654\",\n \"0.45029733\",\n \"0.44901878\",\n \"0.44694677\",\n \"0.44611233\",\n \"0.44572702\",\n \"0.4405865\",\n \"0.4381707\",\n \"0.43751577\",\n \"0.43663976\",\n \"0.43463948\",\n \"0.43383056\",\n \"0.4318211\",\n \"0.43122473\",\n \"0.43044317\",\n \"0.42847285\",\n \"0.4284434\",\n \"0.42740804\",\n \"0.4261431\",\n \"0.42483723\",\n \"0.42393687\",\n \"0.42233568\",\n \"0.4215681\",\n \"0.4212712\",\n \"0.42126065\",\n \"0.42104197\",\n \"0.42050523\",\n \"0.42046538\",\n \"0.42046124\",\n \"0.42017403\",\n \"0.41940245\",\n \"0.41939113\",\n \"0.41902924\",\n \"0.41882488\",\n \"0.41812566\",\n \"0.4172939\",\n \"0.4169072\",\n \"0.4166653\",\n \"0.41644597\",\n \"0.4154366\",\n \"0.41536143\",\n \"0.4151372\",\n \"0.41475597\",\n \"0.41413814\",\n \"0.41304442\",\n \"0.4130242\",\n \"0.4127373\",\n \"0.41188562\",\n \"0.4112576\",\n \"0.41083813\",\n \"0.4100796\",\n \"0.4099253\",\n \"0.4095279\",\n \"0.4087989\",\n \"0.4080605\",\n \"0.4076361\",\n \"0.40751383\",\n \"0.40741518\",\n \"0.40695003\",\n \"0.4064381\",\n \"0.40640312\",\n \"0.4056866\",\n \"0.40556058\",\n \"0.4053596\",\n \"0.40532848\",\n \"0.4052854\",\n \"0.40525904\",\n \"0.40510106\",\n \"0.4048512\",\n \"0.4047699\",\n \"0.40367365\",\n \"0.4033035\",\n \"0.40319028\",\n \"0.40313503\",\n \"0.4028396\",\n \"0.4023992\",\n \"0.4023711\",\n \"0.40236026\",\n \"0.4023098\",\n \"0.40226966\",\n \"0.40226582\",\n \"0.40223306\",\n \"0.4021724\",\n \"0.40186378\",\n \"0.40184578\",\n \"0.4017148\",\n \"0.40140012\",\n \"0.4012981\",\n \"0.4009407\",\n \"0.40079984\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.41888988"},"document_rank":{"kind":"string","value":"43"}}},{"rowIdx":17091,"cells":{"query":{"kind":"string","value":"For LciaEngines, we use the default behavior of ContextManager which is to first try 'attach', then fallback to 'rename'"},"document":{"kind":"string","value":"def _add_compartments(self, comps):\n return self._cm.add_compartments(comps)"},"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 update_context(name, ctx=None):\n if ctx is None:\n ctx = builtins.__xonsh__.ctx\n modctx = xontrib_context(name)\n if modctx is None:\n if not hasattr(update_context, \"bad_imports\"):\n update_context.bad_imports = []\n update_context.bad_imports.append(name)\n return ctx\n return ctx.update(modctx)","def attachable(name, path=None):\n cachekey = f\"lxc.attachable{name}{path}\"\n try:\n return __context__[cachekey]\n except KeyError:\n _ensure_exists(name, path=path)\n # Can't use run() here because it uses attachable() and would\n # endlessly recurse, resulting in a traceback\n log.debug(\"Checking if LXC container %s is attachable\", name)\n cmd = \"lxc-attach\"\n if path:\n cmd += f\" -P {shlex.quote(path)}\"\n cmd += f\" --clear-env -n {name} -- /usr/bin/env\"\n result = (\n __salt__[\"cmd.retcode\"](\n cmd, python_shell=False, output_loglevel=\"quiet\", ignore_retcode=True\n )\n == 0\n )\n __context__[cachekey] = result\n return __context__[cachekey]","def change_dir_without_context_manager(filename1, filename2):","def handle_context_missing(self):","def _set_context(self, ctx):\n try:\n current_engine_name = self.parent.engine.name \n if sgtk.platform.current_engine(): \n sgtk.platform.current_engine().destroy()\n sgtk.platform.start_engine(current_engine_name, ctx.tank, ctx)\n except Exception, e:\n QtGui.QMessageBox.critical(self, \n \"Could not Switch!\", \n \"Could not change work area and start a new \" \n \"engine. This can be because the task doesn't \"\n \"have a step. Details: %s\" % e)\n return","def detach(self) -> ContextManager[None]:","def neutralContextManager():\n yield","def test_add_additional_context(self):\n self.old_manifest.add_additional_context({\"testme\": \"testyou\"})\n assert \"testme\" in self.old_manifest.additional_context_variables\n self.old_manifest.add_additional_context({\"testhim\": \"testher\"})\n assert \"testme\" in self.old_manifest.additional_context_variables\n assert \"testhim\" in self.old_manifest.additional_context_variables","def _set_from_env(name, context, default):\n if default is _DEFAULT_ARG and name not in os.environ:\n return\n\n context[name] = os.environ.get(name, default)","def ensure_context(self):\n with driver.get_active_context():\n oldctx = self._get_attached_context()\n newctx = self.get_or_create_context(None)\n self._set_attached_context(newctx)\n try:\n yield\n finally:\n self._set_attached_context(oldctx)","def post_setup(self, context):\n pass","def change_folname(self, name):\r\n self.oname = f\"{name}\\\\\"\r\n self.ver = os.path.join(self.p, self.oname)\r\n try:\r\n os.chdir(self.ver)\r\n self.confirmed = True\r\n except Exception as error:\r\n return error\r\n finally:\r\n return self.confirmed","def _set_default(name, value, context):\n if name not in context:\n context[name] = value","def OverridePlatformName(name):\n global override_platform_name\n override_platform_name = name","def cooked_mode(self) -> ContextManager[None]:","def _bind_device_context():\n _bind_device_ctx()","def _update_context(self):\n # update file for context\n self._engine.update_file_for_context()","def _process_contexts(w_context):\n try:\n plugins.load()\n ctxs = []\n for ctx_name in w_context:\n ctx_cls = context.Context.get(ctx_name)\n ctxs.append((ctx_cls.get_order(), ctx_cls.get_fullname()))\n ctxs.sort()\n ctxs = [\"%s.setup\" % ctx_name for _i, ctx_name in ctxs]\n ctxs.extend([ctx.replace(\".setup\", \".cleanup\")\n for ctx in reversed(ctxs)])\n return ctxs\n except Exception:\n # the proper of context can be missed while applying the migration, it\n # should not stop us from migrating the database\n return None","def __attrs_post_init__(self):\n self.path = (Path(CONFIG['conda_folder']) / 'envs' / self.name)","def _open_changed ( self ):\n file_name = open_file( extensions = FileInfo(), id = demo_id )\n if file_name != '':\n self.file_name = file_name","def __init__(self, context, name):\n self.context = context\n self.name = name","def __init__(self, context, name):\n self._context = context\n self.name = name","def get_or_create_context(self, devnum):\n if devnum is None:\n attached_ctx = self._get_attached_context()\n if attached_ctx is None:\n return self._get_or_create_context_uncached(devnum)\n else:\n return attached_ctx\n else:\n if USE_NV_BINDING:\n devnum = int(devnum)\n return self._activate_context_for(devnum)","def attach_file_system(self, user_open, user_close, user_read, user_seek):\n if user_open:\n user_open = FILE_OPEN_CALLBACK(user_open)\n if user_close:\n user_close = FILE_CLOSE_CALLBACK(user_close)\n if user_read:\n user_read = FILE_READ_CALLBACK(user_read)\n if user_seek:\n user_seek = FILE_SEEK_CALLBACK(user_seek)\n self._call_fmod(\n \"FMOD_System_AttachFileSystem\", user_open, user_close, user_read, user_seek\n )\n self._user_open = user_open\n self._user_close = user_close\n self._user_read = user_read\n self._user_seek = user_seek","def get_available_name(self, name):\n if self.file_overwrite:\n return name\n return super(OverwriteFileSystemStorage, self).get_available_name(name)","def switch_context(self, context):\r\n self.context_stack.append(self.current_context)\r\n self.current_context = context","def _backup_dev_name(self):\n if self._orig_dev_name is None:\n self._orig_dev_name = self.dev_name","def handle_reload_toolbox(self):","def _get_engine_name(self):","def testRecoveryUseAlternativeNaming(self):\n expected = (IMAGE_SERVER_PREFIX + '/stable-channel/x86-alex-rc/' +\n '0.12.433.269',\n ['chromeos', '0.12.433.269', 'x86-alex', 'recovery',\n 'stable-channel', 'mp', '.bin'])\n actual = cb_name_lib.GetRecoveryName(self.board,\n self.version_string,\n 1)\n self.assertEqual(expected, actual)","def context_local(context=None):\n class manager(object):\n def __init__(self, ctx):\n \"\"\"\n :type ctx: Context\n \"\"\"\n self.context = ctx.copy()\n\n def __enter__(self):\n self.orig_context = context_get()\n context_set(self.context)\n return self.context\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n context_set(self.orig_context)\n\n if context is None:\n context = context_get()\n return manager(context)","def __getFromCvmfsOrLocal(self):\n try:\n ver_dir = \"/cvmfs/atlas.cern.ch/repo/sw/JEM-WN/%s\" % self.version\n if os.path.exists(ver_dir):\n try:\n import commands\n r = commands.getoutput(\"sh -c 'source %s/setup.sh && echo $JEM_PACKAGEPATH'\" % ver_dir)\n if os.path.exists(r + \"/JEM.py\"):\n os.environ[\"JEM_PACKAGEPATH\"] = r\n self.logger.debug('loaded JEM from CVMFS: ' + ver_dir)\n except:\n pass\n except:\n pass\n\n # check if JEM may already just be there! :)\n if \"JEM_PACKAGEPATH\" in os.environ:\n path = os.environ[\"JEM_PACKAGEPATH\"]\n if os.path.exists(path + os.sep + \"JEM.py\"):\n self.dest_dir = path\n self.logger.info(\"using JEM from %s\" % path)\n return True\n else:\n return False","def attach(self):\n assert(False) #No implementation","def _onStart(self, name):\n logging.debug(\"onStart...\")","def set_default_source(self, name):\n self._set_default_source = pa_context_success_cb_t(self._context_success_cb)\n pa_context_set_default_source(self._context,\n name,\n self._set_default_source,\n None)","def redirectLocalImports(name, globals=None, *a, **kw):\n if globals is not None:\n mf = globals.get('__exocet_context__', None)\n if mf is not None:\n trace(\"isolated __import__ of\", name, \"called in exocet module\", mf, mf.mapper)\n return _isolateImports(mf, _originalImport, name, globals, *a, **kw)\n else:\n return _originalImport(name, globals, *a, **kw)\n else:\n return _originalImport(name, globals, *a, **kw)","def attach(self, name: str, path: str | Path) -> None:\n with self.begin() as con:\n con.exec_driver_sql(f\"ATTACH DATABASE {str(path)!r} AS {self._quote(name)}\")","def test_rename_fail(cleandir, fake_db):\n cmd = commands.Rename(['bad_alias', 'NEW'])\n with pytest.raises(errors.AliasNotDefinedError):\n cmd()","def testRecoveryUseDefaultNaming(self):\n expected = (IMAGE_SERVER_PREFIX + '/stable-channel/x86-alex/0.12.433.269',\n ['chromeos', '0.12.433.269', 'x86-alex', 'recovery',\n 'stable-channel', 'mp', '.bin'])\n actual = cb_name_lib.GetRecoveryName(self.board,\n self.version_string,\n 0)\n self.assertEqual(expected, actual)","def upgrade_environment(self, db):\n\n pass","def my_rename(self, src, dst):\n self.renamerCalled = True","def context_set(context):\n global __context\n if context == DefaultContext:\n context = context.copy()\n __context = context","def test_duplicate_attach(self):\n # Ground work.\n self._s1ap_wrapper.configUEDevice(1)\n req = self._s1ap_wrapper.ue_req\n print(\"************************* Running duplicate attach test\")\n self._s1ap_wrapper._s1_util.attach(\n req.ue_id,\n s1ap_types.tfwCmd.UE_ATTACH_REQUEST,\n s1ap_types.tfwCmd.UE_AUTH_REQ_IND,\n s1ap_types.ueAttachComplete_t,\n )\n auth_res = s1ap_types.ueAuthResp_t()\n auth_res.ue_Id = req.ue_id\n sqn_recvd = s1ap_types.ueSqnRcvd_t()\n sqn_recvd.pres = False\n auth_res.sqnRcvd = sqn_recvd\n\n self._s1ap_wrapper._s1_util.issue_cmd(\n s1ap_types.tfwCmd.UE_AUTH_RESP,\n auth_res,\n )\n response = self._s1ap_wrapper.s1_util.get_response()\n assert response.msg_type == s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value\n\n sec_mode_complete = s1ap_types.ueSecModeComplete_t()\n sec_mode_complete.ue_Id = req.ue_id\n self._s1ap_wrapper._s1_util.issue_cmd(\n s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE,\n sec_mode_complete,\n )\n\n # Receive initial context setup and attach accept indication\n response = (\n self._s1ap_wrapper._s1_util\n .receive_initial_ctxt_setup_and_attach_accept()\n )\n attach_acc = response.cast(s1ap_types.ueAttachAccept_t)\n print(\n \"************************ Dropping received attach accept for UE Id:\",\n attach_acc.ue_Id,\n )\n\n while True:\n response = self._s1ap_wrapper.s1_util.get_response()\n if (\n response.msg_type\n == s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value\n ):\n attach_acc = response.cast(s1ap_types.ueAttachAccept_t)\n print(\n \"************************ Dropping received attach accept for UE Id:\",\n attach_acc.ue_Id,\n )\n continue\n\n assert response.msg_type == s1ap_types.tfwCmd.UE_CTX_REL_IND.value\n print(\n \"************************ Received UE context release indication\",\n )\n break\n\n print(\"************************ Running RE-Attach\")\n self._s1ap_wrapper._s1_util.attach(\n req.ue_id,\n s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,\n s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,\n s1ap_types.ueAttachAccept_t,\n )\n\n # Wait on EMM Information from MME\n self._s1ap_wrapper._s1_util.receive_emm_info()\n print(\"************************* Running UE detach\")\n # Now detach the UE\n self._s1ap_wrapper._s1_util.detach(\n req.ue_id,\n s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value,\n )","def fixupSecondaryFileNames(process):\n if not hasattr(process.source, \"secondaryFileNames\"):\n process.source.secondaryFileNames = cms.untracked.vstring()\n return","def test_add_context_duplicate_with_replace():\n\n application_services.add_context('context3', 'value3')\n application_services.add_context('context3', 'value4', replace=True)\n assert application_services.get_context('context3') == 'value4'","def __enter__(self):\n if not self.exists():\n self.make_path()\n self.touch()\n\n self.set_permissions(666)","async def reinit_manager(ctx):\n await ext_manager.reinit()\n await ctx.send(\"Successfully reinitialize.\")","def use_alias(self):\n\n # alias = self.args.chdir\n\n with open(\"alias.json\", \"r\") as file:\n try:\n aliases = loads(file.read())\n except:\n raise Exception(\"No stored aliases\")\n \n if alias in aliases:\n pass\n # chdir(aliases[alias])\n # print(getcwd())\n else:\n raise Exception(\"invalid alias\")","def __init__(self, name, bases, attrs):\n self.__context__ = context.cur_context\n self.__context__.className = name\n print \"Set context for \"+str(self)+\" to \"+str(self.__context__.className)","def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):\n _method_name = '__apply_wlst_context_changes'\n\n self.__resolve_folder_params(path_name, alias_dict)\n\n # if folder is not valid for this version/mode of WLS,\n # add folder to parent_dict UNRESOLVED_FOLDERS_MAP and return None\n if not self.__use_alias_dict(path_name, alias_dict, parent_dict):\n return None\n\n result = dict()\n if FOLDERS in alias_dict:\n result_folders = dict()\n folders = alias_dict[FOLDERS]\n for folder in folders:\n folder_dict = self.__apply_wlst_context_changes(path_name + '/' + folder, folders[folder], result)\n # if folder_dict is None, this folder was invalid for this version/mode of WLS\n if folder_dict is not None:\n result_folders[folder] = folder_dict\n result[FOLDERS] = result_folders\n\n if FLATTENED_FOLDER_DATA in alias_dict:\n result_flattened = dict()\n flattened_data = alias_dict[FLATTENED_FOLDER_DATA]\n for key, value in flattened_data.iteritems():\n result_flattened[key] = self._resolve_curly_braces(value)\n result[FLATTENED_FOLDER_DATA] = result_flattened\n\n if WLST_TYPE in alias_dict:\n result[WLST_TYPE] = self._resolve_curly_braces(alias_dict[WLST_TYPE])\n\n if CHILD_FOLDERS_TYPE in alias_dict:\n result[CHILD_FOLDERS_TYPE] = alias_dict[CHILD_FOLDERS_TYPE]\n else:\n result[CHILD_FOLDERS_TYPE] = SINGLE\n\n if DEFAULT_NAME_VALUE in alias_dict:\n result[DEFAULT_NAME_VALUE] = self._resolve_curly_braces(alias_dict[DEFAULT_NAME_VALUE])\n\n if SHORT_NAME in alias_dict:\n result[SHORT_NAME] = alias_dict[SHORT_NAME]\n\n if FOLDER_ORDER in alias_dict:\n result[FOLDER_ORDER] = alias_dict[FOLDER_ORDER]\n\n if ONLINE_BEAN in alias_dict:\n result[ONLINE_BEAN] = alias_dict[ONLINE_BEAN]\n\n if WLST_PATHS in alias_dict:\n wlst_paths = alias_dict[WLST_PATHS]\n result_wlst_paths = dict()\n for key in wlst_paths:\n result_wlst_paths[key] = self._resolve_curly_braces(wlst_paths[key])\n result[WLST_PATHS] = result_wlst_paths\n else:\n ex = exception_helper.create_alias_exception('WLSDPLY-08127', path_name)\n _logger.throwing(ex, class_name=_class_name, method_name=_method_name)\n raise ex\n\n if WLST_ATTRIBUTES_PATH in alias_dict:\n result[WLST_ATTRIBUTES_PATH] = self._resolve_curly_braces(alias_dict[WLST_ATTRIBUTES_PATH])\n if WLST_SUBFOLDERS_PATH in alias_dict:\n result[WLST_SUBFOLDERS_PATH] = self._resolve_curly_braces(alias_dict[WLST_SUBFOLDERS_PATH])\n if WLST_LIST_PATH in alias_dict:\n result[WLST_LIST_PATH] = self._resolve_curly_braces(alias_dict[WLST_LIST_PATH])\n if WLST_CREATE_PATH in alias_dict:\n result[WLST_CREATE_PATH] = self._resolve_curly_braces(alias_dict[WLST_CREATE_PATH])\n\n if ATTRIBUTES in alias_dict:\n result_model_attrs = dict()\n result_wlst_attrs = dict()\n unresolved_attrs = dict()\n wlst_skip_attrs = list()\n\n model_attrs = alias_dict[ATTRIBUTES]\n for model_attr in model_attrs:\n model_attr_dict, unresolved_version_range = \\\n self.__resolve_attribute_by_wlst_context(path_name, model_attr, model_attrs)\n if model_attr_dict is None:\n unresolved_attrs[model_attr] = unresolved_version_range\n continue\n\n #\n # At this point, the attribute is matched to a single dictionary. All we\n # need to do is to remove the version and wlst_mode attributes. We do not\n # resolve and replace the wlst_path value yet since the path tokens cannot\n # yet be replaced. We will resolve and replace the wlst_path at runtime\n # to make the token replacement more efficient.\n #\n del model_attr_dict[VERSION_RANGE]\n del model_attr_dict[WLST_MODE]\n\n if WLST_NAME in model_attr_dict:\n wlst_name = model_attr_dict[WLST_NAME]\n else:\n ex = exception_helper.create_alias_exception('WLSDPLY-08128', model_attr, path_name)\n _logger.throwing(ex, class_name=_class_name, method_name=_method_name)\n raise ex\n\n #\n # To make the reverse lookup map usable, we need to add the model attribute name to the\n # model_attr_dict. Otherwise, it is impossible to find the model attribute name when\n # looking up the attribute by the WLST name.\n #\n model_attr_dict[MODEL_NAME] = model_attr\n result_model_attrs[model_attr] = model_attr_dict\n result_wlst_attrs[wlst_name] = model_attr_dict\n\n # if attribute is dual-password, add its WLST skip name to the skip list\n skip_name = password_utils.get_wlst_skip_name(model_attr_dict, self._wlst_mode)\n if skip_name is not None:\n wlst_skip_attrs.append(skip_name)\n\n result[ATTRIBUTES] = result_model_attrs\n result[WLST_NAMES_MAP] = result_wlst_attrs\n result[UNRESOLVED_ATTRIBUTES_MAP] = unresolved_attrs\n result[WLST_SKIP_NAMES] = wlst_skip_attrs\n\n return result","def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:","def aml_run_attach():\n AmlRunWrapper().setup(attach=True)","def pre_configure_target(name):\n ListenerManager.call(_target_pre_configure_manager, name)","def set_contexts(self, path_context: str):\n self.path, self.model_context, self.save_path = self.create_contexts(path_context)","def test_log_dir_overrides(self, monkeypatch, tmp_path):\n # Checks that explicit_log_dir ignores exp_dir, name, and version\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\n log_dir = exp_manager(test_trainer, {\"explicit_log_dir\": str(tmp_path / \"test_log_dir_overrides\")})\n assert log_dir.resolve() == (tmp_path / \"test_log_dir_overrides\").resolve()\n assert Path(tmp_path).exists()\n assert Path(tmp_path / \"test_log_dir_overrides\").exists()\n\n # Checks that exp_manager uses exp_dir, default name, and explicit version\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\n log_dir = exp_manager(test_trainer, {\"exp_dir\": str(tmp_path / \"test_no_name\"), \"version\": 957})\n assert log_dir.resolve() == (tmp_path / \"test_no_name\" / \"default\" / \"957\").resolve()\n assert Path(tmp_path).exists()\n assert Path(tmp_path / \"test_no_name\" / \"default\" / \"957\").exists()\n\n monkeypatch.delenv(NEMO_ENV_VARNAME_VERSION)\n # Checks that use_datetime_version False toggle works\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\n log_dir = exp_manager(test_trainer, {\"exp_dir\": str(tmp_path / \"test_no_name\"), \"use_datetime_version\": False})\n assert log_dir.resolve() == (tmp_path / \"test_no_name\" / \"default\" / \"version_0\").resolve()\n assert Path(tmp_path).exists()\n assert Path(tmp_path / \"test_no_name\" / \"default\" / \"version_0\").exists()\n\n monkeypatch.delenv(NEMO_ENV_VARNAME_VERSION)\n # Checks that use_datetime_version False toggle works and version increments\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\n log_dir = exp_manager(test_trainer, {\"exp_dir\": str(tmp_path / \"test_no_name\"), \"use_datetime_version\": False})\n assert log_dir.resolve() == (tmp_path / \"test_no_name\" / \"default\" / \"version_1\").resolve()\n assert Path(tmp_path).exists()\n assert Path(tmp_path / \"test_no_name\" / \"default\" / \"version_1\").exists()","def test_component_rename_error_bad_new_name(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('component rename component1 component2')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def on_path(self, new):\n self.name = basename(new)","def __upgrade(self):","def assign_opengl_context(self, context):\n self.assigned_opengl_context = context","def use_manager(manager_name, environment):\n assert manager_name in environment.managers, (\n 'Manager {selected} was not created by this test run. '\n 'Available managers are: {available}'.format(\n selected=manager_name,\n available=', '.join(environment.managers.keys()),\n )\n )\n\n manager = environment.managers[manager_name]\n\n environment.add_cleanup(\n environment.cfy.profiles.delete,\n kwargs={\n 'profile_name': manager['ip'],\n },\n )\n\n environment.cfy.profiles.use(\n ip=manager['ip'],\n username=manager['username'],\n password=manager['password'],\n rest_certificate=manager['certificate_path'],\n )","def test_rename_overwrite(getch, y_or_n, cleandir, fake_db, alias_dict):\n getch.side_effect = lambda x: y_or_n\n fnames = [name for name in alias_dict]\n OLD, NEW = fnames[0], fnames[1]\n cmd = commands.Rename([OLD, NEW])\n cmd()\n\n loaded_aliases = shared.load_aliases()\n if y_or_n == \"y\":\n cmd_string = alias_dict[OLD]\n else:\n cmd_string = alias_dict[NEW]\n\n assert loaded_aliases[NEW] == cmd_string","def in_context(self):\n pass","async def test_sync_ctx_manager():\n with pytest.raises(RuntimeError):\n with Scope():\n pass","def test_set_context(self):\n original = Context(SSLv23_METHOD)\n replacement = Context(SSLv23_METHOD)\n connection = Connection(original, None)\n connection.set_context(replacement)\n assert replacement is connection.get_context()\n # Lose our references to the contexts, just in case the Connection\n # isn't properly managing its own contributions to their reference\n # counts.\n del original, replacement\n collect()","def _activate_invocation_descriptors(self):\n self._prepare_invocation_descriptors()\n try:\n yield\n finally:\n self._close_remote_side_descriptors()","def manage_existing(self, volume, existing_ref):\n existing_vol_name = self._get_existing_vol_name(existing_ref)\n try:\n vol_props = self.zfssa.get_volume(existing_vol_name)\n except exception.VolumeNotFound:\n err_msg = (_(\"Volume %s doesn't exist on the ZFSSA backend.\") %\n existing_vol_name)\n LOG.error(err_msg)\n raise exception.InvalidInput(reason=err_msg)\n\n self._verify_volume_to_manage(existing_vol_name, vol_props)\n\n try:\n self.zfssa.rename_volume(existing_vol_name, volume['name'])\n except Exception:\n LOG.error(_LE(\"Failed to rename volume %(existing)s to %(new)s. \"\n \"Volume manage failed.\"),\n {'existing': existing_vol_name,\n 'new': volume['name']})\n raise\n\n try:\n self.zfssa.set_file_props(volume['name'],\n {'cinder_managed': 'True'})\n except Exception:\n self.zfssa.rename_volume(volume['name'], existing_vol_name)\n LOG.error(_LE(\"Failed to set properties for volume %(existing)s. \"\n \"Volume manage failed.\"),\n {'existing': volume['name']})\n raise\n\n return {'provider_location': self.mount_path}","async def reload(self, ctx, name: str):\n try:\n self.bot.reload_extension(f\"cogs.{name}\")\n except Exception as e:\n return await ctx.send(default.traceback_maker(e))\n await ctx.send(f\"{emote.check} | Reloaded extension **{name}**\")","def set_selinux_context(path, context):\n if context == get_selinux_context(path):\n return True\n else:\n return not bool(selinux.lsetfilecon(path, ':'.join(context)))","def test_patch_hyperflex_app_catalog(self):\n pass","def rename(self,name):\n for key in OBJECTS_MASTER_DICT:\n if OBJECTS_MASTER_DICT[key] == self.alias:\n OBJECTS_MASTER_DICT[key] = name\n self.alias = name","def exec_in_context(self,arg):\n ## contains elaborate scheme to detect what is specified by\n ## -s, and to warn about any replacement\n current_ids = dict([(k,id(v)) for k,v in self.context.items()])\n\n exec arg in self.context\n\n for k,v in self.context.items():\n if k in self.unused_names and id(v)!=current_ids[k]:\n self.warning(\"Replacing previous value of '%s' with '%s'\"%(k,v))\n\n new_names = set(self.context.keys()).difference(set(current_ids.keys()))\n for k in new_names:\n self.unused_names.add(k)","def setCaptainNames(self):\n self.captainNames = anwp.func.names.getNames('system_names.txt',self.maxCaptainNames+100, self.rand.randint(1,100))\n self.currentCaptainName = 0","def monkeypatch_connections(self):\n \n def create_test_db(self, verbosity=1, autoclobber=False):\n \"\"\"\n Creates a test database, prompting the user for confirmation if the\n database already exists. Returns the name of the test database created.\n \"\"\"\n # Don't import django.core.management if it isn't needed.\n test_database_name = self._get_test_db_name()\n \n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\n and test_database_name != ':memory:':\n if os.access(test_database_name, os.F_OK):\n print \"sqlite test database found !\"\n \n #self._create_test_db(verbosity, autoclobber)\n \n self.connection.close()\n self.connection.settings_dict[\"NAME\"] = test_database_name\n \n # Confirm the feature set of the test database\n self.connection.features.confirm()\n \n # Get a cursor (even though we don't need one yet). This has\n # the side effect of initializing the test database.\n self.connection.cursor()\n\n return test_database_name\n \n def destroy_test_db(self, old_database_name, verbosity=1):\n \"\"\"\n Destroy a test database, prompting the user for confirmation if the\n database already exists.\n \"\"\"\n self.connection.close()\n test_database_name = self.connection.settings_dict['NAME']\n if verbosity >= 1:\n test_db_repr = ''\n if verbosity >= 2:\n test_db_repr = \" ('%s')\" % test_database_name\n print \"Ignore the test database for alias '%s'%s...\" % (\n self.connection.alias, test_db_repr)\n \n # Temporarily use a new connection and a copy of the settings dict.\n # This prevents the production database from being exposed to potential\n # child threads while (or after) the test database is destroyed.\n # Refs #10868 and #17786.\n settings_dict = self.connection.settings_dict.copy()\n settings_dict['NAME'] = old_database_name \n \n def _destroy_test_db(self, test_database_name, verbosity):\n print \"Keep the test database !\" #%test_database_name\n self.connection.close()\n \n \n for alias in connections:\n \"\"\"\n django.test.simple.DjangoTestSuiteRunner\n django.db.backends.creation\n django.db.backends.mysql.base\n \"\"\"\n connection = connections[alias]\n #if connection.settings_dict.get('ENGINE', '').endswith('.sqlite3'):\n \n if not self.options['setupdbs']:\n f1 = types.MethodType(create_test_db, connection.creation, DatabaseCreation)\n connection.creation.create_test_db = f1\n \n if not self.options['teardowndbs']:\n f2 = types.MethodType(destroy_test_db, connection.creation, DatabaseCreation)\n connection.creation.destroy_test_db = f2","def __exit__(self, exc_type, exc_val, exc_tb):\n if self.plugin_name == 'sideboard':\n return\n \n difference = set(sys.modules.keys()) - self.original_keys\n if difference:\n # we apparently imported something new within the context and we should persist\n # it to the module cache\n _module_cache[self.plugin_name].update({k:sys.modules[k] for k in difference})\n\n # sanity check that original sys.modules was not overwritten underneath us\n assert self.original_keys == set(self._original_modules.keys()), (\n 'DETECTED CHANGE IN SAVED SYS.MODULES REFERENCE')\n\n sys.path = self._original_path\n\n for module_name in difference:\n # much like in __enter__, we need to update in place\n # TODO: determine if there's a danger for overwriting a module reference\n # in the main sys.modules with a plug-in's version of the same module?\n\n # we explicitly want to error if the module name somehow isn't there\n del sys.modules[module_name]","def __init__(self):\n self._cmd_list = ['use']","def detach_intent(self, intent_name):\n new_parsers = [\n p for p in self.engine.intent_parsers if p.name != intent_name\n ]\n self.engine.intent_parsers = new_parsers","def swap_aliases():\n # store existing aliases, so we can restore them.\n existing = {}\n for name in COMMANDS:\n if name in builtins.aliases:\n existing[name] = builtins.aliases[name]\n alt_name = name.replace(\"_\", \"-\")\n if alt_name in builtins.aliases:\n existing[alt_name] = builtins.aliases[alt_name]\n load_aliases()\n yield\n unload_aliases()\n\n builtins.aliases.update(existing)","def get_context(self):\n symbol_chain = self.split_completion_object(self.get_word_before())\n current_rs_object = self.module\n\n for symbol in symbol_chain:\n try:\n current_rs_object = current_rs_object.get_object(symbol)\n logging.info(f\"New context found: {current_rs_object.name}\")\n except:\n logging.error(f\"{type(current_rs_object)} has no method get_object yet.\")\n return current_rs_object\n\n return current_rs_object","def __enter__(self):\n if self.plugin_name == 'sideboard':\n return\n \n self._original_path = sys.path\n self._original_modules = sys.modules.copy()\n self.original_keys = set(self._original_modules.keys())\n\n #TODO: determine if there a sufficiently negative performance implication\n # to rethink doing this in recursive imports\n sys.path = _path_cache[self.plugin_name] + sys.path\n\n #This really does need to be an update in place.\n #Setting sys.modules = SOME_NEW_DICTIONARY means that\n # imports still write to the original sys.modules\n sys.modules.update(_module_cache[self.plugin_name])","def _pre_chroot_block(self):\n pass","def load_alias(name):\n mod = importlib.import_module(\"umdone.commands.\" + name)\n main = getattr(mod, \"main\")\n builtins.aliases[name] = main\n builtins.aliases[name.replace(\"_\", \"-\")] = main","def update_context(self, intent):\n for tag in intent['__tags__']:\n if 'entities' not in tag:\n continue\n context_entity = tag['entities'][0]\n if self.context_greedy:\n self.context_manager.inject_context(context_entity)\n elif context_entity['data'][0][1] in self.context_keywords:\n self.context_manager.inject_context(context_entity)","def xontrib_context(name):\n spec = find_xontrib(name)\n if spec is None:\n return None\n m = importlib.import_module(spec.name)\n pubnames = getattr(m, \"__all__\", None)\n if pubnames is not None:\n ctx = {k: getattr(m, k) for k in pubnames}\n else:\n ctx = {k: getattr(m, k) for k in dir(m) if not k.startswith(\"_\")}\n return ctx","def setup(self, context, entity, path, reduced_path, adapter, **kwargs):\n\n pass","def _make_context():\n return {\n 'api': application.mounts['/api'],\n 'db': db,\n 'User': User,\n 'admin': application.mounts['/admin']\n }","def fixupFileNames(process):\n if not hasattr(process.source, \"fileNames\"):\n process.source.fileNames = cms.untracked.vstring()\n return","def use(self, item_name):\n pass","def main(ctx, name, verbose):\n ctx.ensure_object(dict)\n ctx.obj['NAME'] = name\n ctx.obj['VERBOSE'] = verbose","def __setattr__(self, name, value):\n if self._loop.is_running():\n super().__setattr__(name, value)\n else:\n setattr(tlocals, name, value)","def restore_context(self, filepath):\n\n raise NotImplementedError()","def prep(self):\n self.language.wrap_directory","def _config_context():\n config_path = os.path.join(DATA_DIR, CONFIG_FILENAME)\n previous_config = None\n try:\n os.symlink(config_path, CONFIG_FILENAME)\n except FileExistsError:\n if not os.path.islink(CONFIG_FILENAME):\n with open(CONFIG_FILENAME) as f:\n previous_config = f.read()\n os.unlink(CONFIG_FILENAME)\n os.symlink(config_path, CONFIG_FILENAME)\n try:\n yield\n finally:\n os.unlink(CONFIG_FILENAME)\n if previous_config is not None:\n with open(CONFIG_FILENAME, \"w\") as f:\n f.write(previous_config)","def __enter__(self):\n self._in_context_block = True\n # TODO: create local backup of file in case we can't upload and have to roll back\n return self","def _name_changed(self):\n self._named = True","def before(self, context):\n raise NotImplementedError","def _override_context(): \r\n if _CDjangoPluginActivator._instance._IsDjangoProject():\r\n return [wingapi.kContextNewMenu(_(\"Djang_o\"), group=2)]\r\n else:\r\n return []","def filesystem_layers(self):\n pass","def switch(self, context):\n return","def on_start(self, ctx):\n pass","def prepare(self, context):\n raise NotImplementedError","def migrate(self, **kwargs):\n volume_name = kwargs['NAME']\n vm = kwargs['vm']\n volume_info = self.cm.find_name(name=volume_name)\n volume_attached_vm = volume_info[0]['AttachedToVm']\n vm_info = Shell.run(f\"multipass info {vm} --format=json\")\n vm_info = json.loads(vm_info)\n vm_status = vm_info[\"info\"][vm]['state']\n if vm_status == 'running':\n param = {'NAME': volume_name}\n self.detach(**param)\n self.attach(**param, vm=vm)\n try:\n for old_vm in volume_attached_vm:\n volume_info[0]['AttachedToVm'].remove(old_vm)\n except:\n pass\n volume_info[0]['AttachedToVm'].append(vm)\n return volume_info"],"string":"[\n \"def update_context(name, ctx=None):\\n if ctx is None:\\n ctx = builtins.__xonsh__.ctx\\n modctx = xontrib_context(name)\\n if modctx is None:\\n if not hasattr(update_context, \\\"bad_imports\\\"):\\n update_context.bad_imports = []\\n update_context.bad_imports.append(name)\\n return ctx\\n return ctx.update(modctx)\",\n \"def attachable(name, path=None):\\n cachekey = f\\\"lxc.attachable{name}{path}\\\"\\n try:\\n return __context__[cachekey]\\n except KeyError:\\n _ensure_exists(name, path=path)\\n # Can't use run() here because it uses attachable() and would\\n # endlessly recurse, resulting in a traceback\\n log.debug(\\\"Checking if LXC container %s is attachable\\\", name)\\n cmd = \\\"lxc-attach\\\"\\n if path:\\n cmd += f\\\" -P {shlex.quote(path)}\\\"\\n cmd += f\\\" --clear-env -n {name} -- /usr/bin/env\\\"\\n result = (\\n __salt__[\\\"cmd.retcode\\\"](\\n cmd, python_shell=False, output_loglevel=\\\"quiet\\\", ignore_retcode=True\\n )\\n == 0\\n )\\n __context__[cachekey] = result\\n return __context__[cachekey]\",\n \"def change_dir_without_context_manager(filename1, filename2):\",\n \"def handle_context_missing(self):\",\n \"def _set_context(self, ctx):\\n try:\\n current_engine_name = self.parent.engine.name \\n if sgtk.platform.current_engine(): \\n sgtk.platform.current_engine().destroy()\\n sgtk.platform.start_engine(current_engine_name, ctx.tank, ctx)\\n except Exception, e:\\n QtGui.QMessageBox.critical(self, \\n \\\"Could not Switch!\\\", \\n \\\"Could not change work area and start a new \\\" \\n \\\"engine. This can be because the task doesn't \\\"\\n \\\"have a step. Details: %s\\\" % e)\\n return\",\n \"def detach(self) -> ContextManager[None]:\",\n \"def neutralContextManager():\\n yield\",\n \"def test_add_additional_context(self):\\n self.old_manifest.add_additional_context({\\\"testme\\\": \\\"testyou\\\"})\\n assert \\\"testme\\\" in self.old_manifest.additional_context_variables\\n self.old_manifest.add_additional_context({\\\"testhim\\\": \\\"testher\\\"})\\n assert \\\"testme\\\" in self.old_manifest.additional_context_variables\\n assert \\\"testhim\\\" in self.old_manifest.additional_context_variables\",\n \"def _set_from_env(name, context, default):\\n if default is _DEFAULT_ARG and name not in os.environ:\\n return\\n\\n context[name] = os.environ.get(name, default)\",\n \"def ensure_context(self):\\n with driver.get_active_context():\\n oldctx = self._get_attached_context()\\n newctx = self.get_or_create_context(None)\\n self._set_attached_context(newctx)\\n try:\\n yield\\n finally:\\n self._set_attached_context(oldctx)\",\n \"def post_setup(self, context):\\n pass\",\n \"def change_folname(self, name):\\r\\n self.oname = f\\\"{name}\\\\\\\\\\\"\\r\\n self.ver = os.path.join(self.p, self.oname)\\r\\n try:\\r\\n os.chdir(self.ver)\\r\\n self.confirmed = True\\r\\n except Exception as error:\\r\\n return error\\r\\n finally:\\r\\n return self.confirmed\",\n \"def _set_default(name, value, context):\\n if name not in context:\\n context[name] = value\",\n \"def OverridePlatformName(name):\\n global override_platform_name\\n override_platform_name = name\",\n \"def cooked_mode(self) -> ContextManager[None]:\",\n \"def _bind_device_context():\\n _bind_device_ctx()\",\n \"def _update_context(self):\\n # update file for context\\n self._engine.update_file_for_context()\",\n \"def _process_contexts(w_context):\\n try:\\n plugins.load()\\n ctxs = []\\n for ctx_name in w_context:\\n ctx_cls = context.Context.get(ctx_name)\\n ctxs.append((ctx_cls.get_order(), ctx_cls.get_fullname()))\\n ctxs.sort()\\n ctxs = [\\\"%s.setup\\\" % ctx_name for _i, ctx_name in ctxs]\\n ctxs.extend([ctx.replace(\\\".setup\\\", \\\".cleanup\\\")\\n for ctx in reversed(ctxs)])\\n return ctxs\\n except Exception:\\n # the proper of context can be missed while applying the migration, it\\n # should not stop us from migrating the database\\n return None\",\n \"def __attrs_post_init__(self):\\n self.path = (Path(CONFIG['conda_folder']) / 'envs' / self.name)\",\n \"def _open_changed ( self ):\\n file_name = open_file( extensions = FileInfo(), id = demo_id )\\n if file_name != '':\\n self.file_name = file_name\",\n \"def __init__(self, context, name):\\n self.context = context\\n self.name = name\",\n \"def __init__(self, context, name):\\n self._context = context\\n self.name = name\",\n \"def get_or_create_context(self, devnum):\\n if devnum is None:\\n attached_ctx = self._get_attached_context()\\n if attached_ctx is None:\\n return self._get_or_create_context_uncached(devnum)\\n else:\\n return attached_ctx\\n else:\\n if USE_NV_BINDING:\\n devnum = int(devnum)\\n return self._activate_context_for(devnum)\",\n \"def attach_file_system(self, user_open, user_close, user_read, user_seek):\\n if user_open:\\n user_open = FILE_OPEN_CALLBACK(user_open)\\n if user_close:\\n user_close = FILE_CLOSE_CALLBACK(user_close)\\n if user_read:\\n user_read = FILE_READ_CALLBACK(user_read)\\n if user_seek:\\n user_seek = FILE_SEEK_CALLBACK(user_seek)\\n self._call_fmod(\\n \\\"FMOD_System_AttachFileSystem\\\", user_open, user_close, user_read, user_seek\\n )\\n self._user_open = user_open\\n self._user_close = user_close\\n self._user_read = user_read\\n self._user_seek = user_seek\",\n \"def get_available_name(self, name):\\n if self.file_overwrite:\\n return name\\n return super(OverwriteFileSystemStorage, self).get_available_name(name)\",\n \"def switch_context(self, context):\\r\\n self.context_stack.append(self.current_context)\\r\\n self.current_context = context\",\n \"def _backup_dev_name(self):\\n if self._orig_dev_name is None:\\n self._orig_dev_name = self.dev_name\",\n \"def handle_reload_toolbox(self):\",\n \"def _get_engine_name(self):\",\n \"def testRecoveryUseAlternativeNaming(self):\\n expected = (IMAGE_SERVER_PREFIX + '/stable-channel/x86-alex-rc/' +\\n '0.12.433.269',\\n ['chromeos', '0.12.433.269', 'x86-alex', 'recovery',\\n 'stable-channel', 'mp', '.bin'])\\n actual = cb_name_lib.GetRecoveryName(self.board,\\n self.version_string,\\n 1)\\n self.assertEqual(expected, actual)\",\n \"def context_local(context=None):\\n class manager(object):\\n def __init__(self, ctx):\\n \\\"\\\"\\\"\\n :type ctx: Context\\n \\\"\\\"\\\"\\n self.context = ctx.copy()\\n\\n def __enter__(self):\\n self.orig_context = context_get()\\n context_set(self.context)\\n return self.context\\n\\n def __exit__(self, exc_type, exc_val, exc_tb):\\n context_set(self.orig_context)\\n\\n if context is None:\\n context = context_get()\\n return manager(context)\",\n \"def __getFromCvmfsOrLocal(self):\\n try:\\n ver_dir = \\\"/cvmfs/atlas.cern.ch/repo/sw/JEM-WN/%s\\\" % self.version\\n if os.path.exists(ver_dir):\\n try:\\n import commands\\n r = commands.getoutput(\\\"sh -c 'source %s/setup.sh && echo $JEM_PACKAGEPATH'\\\" % ver_dir)\\n if os.path.exists(r + \\\"/JEM.py\\\"):\\n os.environ[\\\"JEM_PACKAGEPATH\\\"] = r\\n self.logger.debug('loaded JEM from CVMFS: ' + ver_dir)\\n except:\\n pass\\n except:\\n pass\\n\\n # check if JEM may already just be there! :)\\n if \\\"JEM_PACKAGEPATH\\\" in os.environ:\\n path = os.environ[\\\"JEM_PACKAGEPATH\\\"]\\n if os.path.exists(path + os.sep + \\\"JEM.py\\\"):\\n self.dest_dir = path\\n self.logger.info(\\\"using JEM from %s\\\" % path)\\n return True\\n else:\\n return False\",\n \"def attach(self):\\n assert(False) #No implementation\",\n \"def _onStart(self, name):\\n logging.debug(\\\"onStart...\\\")\",\n \"def set_default_source(self, name):\\n self._set_default_source = pa_context_success_cb_t(self._context_success_cb)\\n pa_context_set_default_source(self._context,\\n name,\\n self._set_default_source,\\n None)\",\n \"def redirectLocalImports(name, globals=None, *a, **kw):\\n if globals is not None:\\n mf = globals.get('__exocet_context__', None)\\n if mf is not None:\\n trace(\\\"isolated __import__ of\\\", name, \\\"called in exocet module\\\", mf, mf.mapper)\\n return _isolateImports(mf, _originalImport, name, globals, *a, **kw)\\n else:\\n return _originalImport(name, globals, *a, **kw)\\n else:\\n return _originalImport(name, globals, *a, **kw)\",\n \"def attach(self, name: str, path: str | Path) -> None:\\n with self.begin() as con:\\n con.exec_driver_sql(f\\\"ATTACH DATABASE {str(path)!r} AS {self._quote(name)}\\\")\",\n \"def test_rename_fail(cleandir, fake_db):\\n cmd = commands.Rename(['bad_alias', 'NEW'])\\n with pytest.raises(errors.AliasNotDefinedError):\\n cmd()\",\n \"def testRecoveryUseDefaultNaming(self):\\n expected = (IMAGE_SERVER_PREFIX + '/stable-channel/x86-alex/0.12.433.269',\\n ['chromeos', '0.12.433.269', 'x86-alex', 'recovery',\\n 'stable-channel', 'mp', '.bin'])\\n actual = cb_name_lib.GetRecoveryName(self.board,\\n self.version_string,\\n 0)\\n self.assertEqual(expected, actual)\",\n \"def upgrade_environment(self, db):\\n\\n pass\",\n \"def my_rename(self, src, dst):\\n self.renamerCalled = True\",\n \"def context_set(context):\\n global __context\\n if context == DefaultContext:\\n context = context.copy()\\n __context = context\",\n \"def test_duplicate_attach(self):\\n # Ground work.\\n self._s1ap_wrapper.configUEDevice(1)\\n req = self._s1ap_wrapper.ue_req\\n print(\\\"************************* Running duplicate attach test\\\")\\n self._s1ap_wrapper._s1_util.attach(\\n req.ue_id,\\n s1ap_types.tfwCmd.UE_ATTACH_REQUEST,\\n s1ap_types.tfwCmd.UE_AUTH_REQ_IND,\\n s1ap_types.ueAttachComplete_t,\\n )\\n auth_res = s1ap_types.ueAuthResp_t()\\n auth_res.ue_Id = req.ue_id\\n sqn_recvd = s1ap_types.ueSqnRcvd_t()\\n sqn_recvd.pres = False\\n auth_res.sqnRcvd = sqn_recvd\\n\\n self._s1ap_wrapper._s1_util.issue_cmd(\\n s1ap_types.tfwCmd.UE_AUTH_RESP,\\n auth_res,\\n )\\n response = self._s1ap_wrapper.s1_util.get_response()\\n assert response.msg_type == s1ap_types.tfwCmd.UE_SEC_MOD_CMD_IND.value\\n\\n sec_mode_complete = s1ap_types.ueSecModeComplete_t()\\n sec_mode_complete.ue_Id = req.ue_id\\n self._s1ap_wrapper._s1_util.issue_cmd(\\n s1ap_types.tfwCmd.UE_SEC_MOD_COMPLETE,\\n sec_mode_complete,\\n )\\n\\n # Receive initial context setup and attach accept indication\\n response = (\\n self._s1ap_wrapper._s1_util\\n .receive_initial_ctxt_setup_and_attach_accept()\\n )\\n attach_acc = response.cast(s1ap_types.ueAttachAccept_t)\\n print(\\n \\\"************************ Dropping received attach accept for UE Id:\\\",\\n attach_acc.ue_Id,\\n )\\n\\n while True:\\n response = self._s1ap_wrapper.s1_util.get_response()\\n if (\\n response.msg_type\\n == s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND.value\\n ):\\n attach_acc = response.cast(s1ap_types.ueAttachAccept_t)\\n print(\\n \\\"************************ Dropping received attach accept for UE Id:\\\",\\n attach_acc.ue_Id,\\n )\\n continue\\n\\n assert response.msg_type == s1ap_types.tfwCmd.UE_CTX_REL_IND.value\\n print(\\n \\\"************************ Received UE context release indication\\\",\\n )\\n break\\n\\n print(\\\"************************ Running RE-Attach\\\")\\n self._s1ap_wrapper._s1_util.attach(\\n req.ue_id,\\n s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,\\n s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,\\n s1ap_types.ueAttachAccept_t,\\n )\\n\\n # Wait on EMM Information from MME\\n self._s1ap_wrapper._s1_util.receive_emm_info()\\n print(\\\"************************* Running UE detach\\\")\\n # Now detach the UE\\n self._s1ap_wrapper._s1_util.detach(\\n req.ue_id,\\n s1ap_types.ueDetachType_t.UE_NORMAL_DETACH.value,\\n )\",\n \"def fixupSecondaryFileNames(process):\\n if not hasattr(process.source, \\\"secondaryFileNames\\\"):\\n process.source.secondaryFileNames = cms.untracked.vstring()\\n return\",\n \"def test_add_context_duplicate_with_replace():\\n\\n application_services.add_context('context3', 'value3')\\n application_services.add_context('context3', 'value4', replace=True)\\n assert application_services.get_context('context3') == 'value4'\",\n \"def __enter__(self):\\n if not self.exists():\\n self.make_path()\\n self.touch()\\n\\n self.set_permissions(666)\",\n \"async def reinit_manager(ctx):\\n await ext_manager.reinit()\\n await ctx.send(\\\"Successfully reinitialize.\\\")\",\n \"def use_alias(self):\\n\\n # alias = self.args.chdir\\n\\n with open(\\\"alias.json\\\", \\\"r\\\") as file:\\n try:\\n aliases = loads(file.read())\\n except:\\n raise Exception(\\\"No stored aliases\\\")\\n \\n if alias in aliases:\\n pass\\n # chdir(aliases[alias])\\n # print(getcwd())\\n else:\\n raise Exception(\\\"invalid alias\\\")\",\n \"def __init__(self, name, bases, attrs):\\n self.__context__ = context.cur_context\\n self.__context__.className = name\\n print \\\"Set context for \\\"+str(self)+\\\" to \\\"+str(self.__context__.className)\",\n \"def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):\\n _method_name = '__apply_wlst_context_changes'\\n\\n self.__resolve_folder_params(path_name, alias_dict)\\n\\n # if folder is not valid for this version/mode of WLS,\\n # add folder to parent_dict UNRESOLVED_FOLDERS_MAP and return None\\n if not self.__use_alias_dict(path_name, alias_dict, parent_dict):\\n return None\\n\\n result = dict()\\n if FOLDERS in alias_dict:\\n result_folders = dict()\\n folders = alias_dict[FOLDERS]\\n for folder in folders:\\n folder_dict = self.__apply_wlst_context_changes(path_name + '/' + folder, folders[folder], result)\\n # if folder_dict is None, this folder was invalid for this version/mode of WLS\\n if folder_dict is not None:\\n result_folders[folder] = folder_dict\\n result[FOLDERS] = result_folders\\n\\n if FLATTENED_FOLDER_DATA in alias_dict:\\n result_flattened = dict()\\n flattened_data = alias_dict[FLATTENED_FOLDER_DATA]\\n for key, value in flattened_data.iteritems():\\n result_flattened[key] = self._resolve_curly_braces(value)\\n result[FLATTENED_FOLDER_DATA] = result_flattened\\n\\n if WLST_TYPE in alias_dict:\\n result[WLST_TYPE] = self._resolve_curly_braces(alias_dict[WLST_TYPE])\\n\\n if CHILD_FOLDERS_TYPE in alias_dict:\\n result[CHILD_FOLDERS_TYPE] = alias_dict[CHILD_FOLDERS_TYPE]\\n else:\\n result[CHILD_FOLDERS_TYPE] = SINGLE\\n\\n if DEFAULT_NAME_VALUE in alias_dict:\\n result[DEFAULT_NAME_VALUE] = self._resolve_curly_braces(alias_dict[DEFAULT_NAME_VALUE])\\n\\n if SHORT_NAME in alias_dict:\\n result[SHORT_NAME] = alias_dict[SHORT_NAME]\\n\\n if FOLDER_ORDER in alias_dict:\\n result[FOLDER_ORDER] = alias_dict[FOLDER_ORDER]\\n\\n if ONLINE_BEAN in alias_dict:\\n result[ONLINE_BEAN] = alias_dict[ONLINE_BEAN]\\n\\n if WLST_PATHS in alias_dict:\\n wlst_paths = alias_dict[WLST_PATHS]\\n result_wlst_paths = dict()\\n for key in wlst_paths:\\n result_wlst_paths[key] = self._resolve_curly_braces(wlst_paths[key])\\n result[WLST_PATHS] = result_wlst_paths\\n else:\\n ex = exception_helper.create_alias_exception('WLSDPLY-08127', path_name)\\n _logger.throwing(ex, class_name=_class_name, method_name=_method_name)\\n raise ex\\n\\n if WLST_ATTRIBUTES_PATH in alias_dict:\\n result[WLST_ATTRIBUTES_PATH] = self._resolve_curly_braces(alias_dict[WLST_ATTRIBUTES_PATH])\\n if WLST_SUBFOLDERS_PATH in alias_dict:\\n result[WLST_SUBFOLDERS_PATH] = self._resolve_curly_braces(alias_dict[WLST_SUBFOLDERS_PATH])\\n if WLST_LIST_PATH in alias_dict:\\n result[WLST_LIST_PATH] = self._resolve_curly_braces(alias_dict[WLST_LIST_PATH])\\n if WLST_CREATE_PATH in alias_dict:\\n result[WLST_CREATE_PATH] = self._resolve_curly_braces(alias_dict[WLST_CREATE_PATH])\\n\\n if ATTRIBUTES in alias_dict:\\n result_model_attrs = dict()\\n result_wlst_attrs = dict()\\n unresolved_attrs = dict()\\n wlst_skip_attrs = list()\\n\\n model_attrs = alias_dict[ATTRIBUTES]\\n for model_attr in model_attrs:\\n model_attr_dict, unresolved_version_range = \\\\\\n self.__resolve_attribute_by_wlst_context(path_name, model_attr, model_attrs)\\n if model_attr_dict is None:\\n unresolved_attrs[model_attr] = unresolved_version_range\\n continue\\n\\n #\\n # At this point, the attribute is matched to a single dictionary. All we\\n # need to do is to remove the version and wlst_mode attributes. We do not\\n # resolve and replace the wlst_path value yet since the path tokens cannot\\n # yet be replaced. We will resolve and replace the wlst_path at runtime\\n # to make the token replacement more efficient.\\n #\\n del model_attr_dict[VERSION_RANGE]\\n del model_attr_dict[WLST_MODE]\\n\\n if WLST_NAME in model_attr_dict:\\n wlst_name = model_attr_dict[WLST_NAME]\\n else:\\n ex = exception_helper.create_alias_exception('WLSDPLY-08128', model_attr, path_name)\\n _logger.throwing(ex, class_name=_class_name, method_name=_method_name)\\n raise ex\\n\\n #\\n # To make the reverse lookup map usable, we need to add the model attribute name to the\\n # model_attr_dict. Otherwise, it is impossible to find the model attribute name when\\n # looking up the attribute by the WLST name.\\n #\\n model_attr_dict[MODEL_NAME] = model_attr\\n result_model_attrs[model_attr] = model_attr_dict\\n result_wlst_attrs[wlst_name] = model_attr_dict\\n\\n # if attribute is dual-password, add its WLST skip name to the skip list\\n skip_name = password_utils.get_wlst_skip_name(model_attr_dict, self._wlst_mode)\\n if skip_name is not None:\\n wlst_skip_attrs.append(skip_name)\\n\\n result[ATTRIBUTES] = result_model_attrs\\n result[WLST_NAMES_MAP] = result_wlst_attrs\\n result[UNRESOLVED_ATTRIBUTES_MAP] = unresolved_attrs\\n result[WLST_SKIP_NAMES] = wlst_skip_attrs\\n\\n return result\",\n \"def attach(self, input_ready_callback: Callable[[], None]) -> ContextManager[None]:\",\n \"def aml_run_attach():\\n AmlRunWrapper().setup(attach=True)\",\n \"def pre_configure_target(name):\\n ListenerManager.call(_target_pre_configure_manager, name)\",\n \"def set_contexts(self, path_context: str):\\n self.path, self.model_context, self.save_path = self.create_contexts(path_context)\",\n \"def test_log_dir_overrides(self, monkeypatch, tmp_path):\\n # Checks that explicit_log_dir ignores exp_dir, name, and version\\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\\n log_dir = exp_manager(test_trainer, {\\\"explicit_log_dir\\\": str(tmp_path / \\\"test_log_dir_overrides\\\")})\\n assert log_dir.resolve() == (tmp_path / \\\"test_log_dir_overrides\\\").resolve()\\n assert Path(tmp_path).exists()\\n assert Path(tmp_path / \\\"test_log_dir_overrides\\\").exists()\\n\\n # Checks that exp_manager uses exp_dir, default name, and explicit version\\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\\n log_dir = exp_manager(test_trainer, {\\\"exp_dir\\\": str(tmp_path / \\\"test_no_name\\\"), \\\"version\\\": 957})\\n assert log_dir.resolve() == (tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"957\\\").resolve()\\n assert Path(tmp_path).exists()\\n assert Path(tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"957\\\").exists()\\n\\n monkeypatch.delenv(NEMO_ENV_VARNAME_VERSION)\\n # Checks that use_datetime_version False toggle works\\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\\n log_dir = exp_manager(test_trainer, {\\\"exp_dir\\\": str(tmp_path / \\\"test_no_name\\\"), \\\"use_datetime_version\\\": False})\\n assert log_dir.resolve() == (tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"version_0\\\").resolve()\\n assert Path(tmp_path).exists()\\n assert Path(tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"version_0\\\").exists()\\n\\n monkeypatch.delenv(NEMO_ENV_VARNAME_VERSION)\\n # Checks that use_datetime_version False toggle works and version increments\\n test_trainer = pl.Trainer(checkpoint_callback=False, logger=False)\\n log_dir = exp_manager(test_trainer, {\\\"exp_dir\\\": str(tmp_path / \\\"test_no_name\\\"), \\\"use_datetime_version\\\": False})\\n assert log_dir.resolve() == (tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"version_1\\\").resolve()\\n assert Path(tmp_path).exists()\\n assert Path(tmp_path / \\\"test_no_name\\\" / \\\"default\\\" / \\\"version_1\\\").exists()\",\n \"def test_component_rename_error_bad_new_name(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('component rename component1 component2')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def on_path(self, new):\\n self.name = basename(new)\",\n \"def __upgrade(self):\",\n \"def assign_opengl_context(self, context):\\n self.assigned_opengl_context = context\",\n \"def use_manager(manager_name, environment):\\n assert manager_name in environment.managers, (\\n 'Manager {selected} was not created by this test run. '\\n 'Available managers are: {available}'.format(\\n selected=manager_name,\\n available=', '.join(environment.managers.keys()),\\n )\\n )\\n\\n manager = environment.managers[manager_name]\\n\\n environment.add_cleanup(\\n environment.cfy.profiles.delete,\\n kwargs={\\n 'profile_name': manager['ip'],\\n },\\n )\\n\\n environment.cfy.profiles.use(\\n ip=manager['ip'],\\n username=manager['username'],\\n password=manager['password'],\\n rest_certificate=manager['certificate_path'],\\n )\",\n \"def test_rename_overwrite(getch, y_or_n, cleandir, fake_db, alias_dict):\\n getch.side_effect = lambda x: y_or_n\\n fnames = [name for name in alias_dict]\\n OLD, NEW = fnames[0], fnames[1]\\n cmd = commands.Rename([OLD, NEW])\\n cmd()\\n\\n loaded_aliases = shared.load_aliases()\\n if y_or_n == \\\"y\\\":\\n cmd_string = alias_dict[OLD]\\n else:\\n cmd_string = alias_dict[NEW]\\n\\n assert loaded_aliases[NEW] == cmd_string\",\n \"def in_context(self):\\n pass\",\n \"async def test_sync_ctx_manager():\\n with pytest.raises(RuntimeError):\\n with Scope():\\n pass\",\n \"def test_set_context(self):\\n original = Context(SSLv23_METHOD)\\n replacement = Context(SSLv23_METHOD)\\n connection = Connection(original, None)\\n connection.set_context(replacement)\\n assert replacement is connection.get_context()\\n # Lose our references to the contexts, just in case the Connection\\n # isn't properly managing its own contributions to their reference\\n # counts.\\n del original, replacement\\n collect()\",\n \"def _activate_invocation_descriptors(self):\\n self._prepare_invocation_descriptors()\\n try:\\n yield\\n finally:\\n self._close_remote_side_descriptors()\",\n \"def manage_existing(self, volume, existing_ref):\\n existing_vol_name = self._get_existing_vol_name(existing_ref)\\n try:\\n vol_props = self.zfssa.get_volume(existing_vol_name)\\n except exception.VolumeNotFound:\\n err_msg = (_(\\\"Volume %s doesn't exist on the ZFSSA backend.\\\") %\\n existing_vol_name)\\n LOG.error(err_msg)\\n raise exception.InvalidInput(reason=err_msg)\\n\\n self._verify_volume_to_manage(existing_vol_name, vol_props)\\n\\n try:\\n self.zfssa.rename_volume(existing_vol_name, volume['name'])\\n except Exception:\\n LOG.error(_LE(\\\"Failed to rename volume %(existing)s to %(new)s. \\\"\\n \\\"Volume manage failed.\\\"),\\n {'existing': existing_vol_name,\\n 'new': volume['name']})\\n raise\\n\\n try:\\n self.zfssa.set_file_props(volume['name'],\\n {'cinder_managed': 'True'})\\n except Exception:\\n self.zfssa.rename_volume(volume['name'], existing_vol_name)\\n LOG.error(_LE(\\\"Failed to set properties for volume %(existing)s. \\\"\\n \\\"Volume manage failed.\\\"),\\n {'existing': volume['name']})\\n raise\\n\\n return {'provider_location': self.mount_path}\",\n \"async def reload(self, ctx, name: str):\\n try:\\n self.bot.reload_extension(f\\\"cogs.{name}\\\")\\n except Exception as e:\\n return await ctx.send(default.traceback_maker(e))\\n await ctx.send(f\\\"{emote.check} | Reloaded extension **{name}**\\\")\",\n \"def set_selinux_context(path, context):\\n if context == get_selinux_context(path):\\n return True\\n else:\\n return not bool(selinux.lsetfilecon(path, ':'.join(context)))\",\n \"def test_patch_hyperflex_app_catalog(self):\\n pass\",\n \"def rename(self,name):\\n for key in OBJECTS_MASTER_DICT:\\n if OBJECTS_MASTER_DICT[key] == self.alias:\\n OBJECTS_MASTER_DICT[key] = name\\n self.alias = name\",\n \"def exec_in_context(self,arg):\\n ## contains elaborate scheme to detect what is specified by\\n ## -s, and to warn about any replacement\\n current_ids = dict([(k,id(v)) for k,v in self.context.items()])\\n\\n exec arg in self.context\\n\\n for k,v in self.context.items():\\n if k in self.unused_names and id(v)!=current_ids[k]:\\n self.warning(\\\"Replacing previous value of '%s' with '%s'\\\"%(k,v))\\n\\n new_names = set(self.context.keys()).difference(set(current_ids.keys()))\\n for k in new_names:\\n self.unused_names.add(k)\",\n \"def setCaptainNames(self):\\n self.captainNames = anwp.func.names.getNames('system_names.txt',self.maxCaptainNames+100, self.rand.randint(1,100))\\n self.currentCaptainName = 0\",\n \"def monkeypatch_connections(self):\\n \\n def create_test_db(self, verbosity=1, autoclobber=False):\\n \\\"\\\"\\\"\\n Creates a test database, prompting the user for confirmation if the\\n database already exists. Returns the name of the test database created.\\n \\\"\\\"\\\"\\n # Don't import django.core.management if it isn't needed.\\n test_database_name = self._get_test_db_name()\\n \\n if self.connection.settings_dict.get('ENGINE', '').endswith('.sqlite3')\\\\\\n and test_database_name != ':memory:':\\n if os.access(test_database_name, os.F_OK):\\n print \\\"sqlite test database found !\\\"\\n \\n #self._create_test_db(verbosity, autoclobber)\\n \\n self.connection.close()\\n self.connection.settings_dict[\\\"NAME\\\"] = test_database_name\\n \\n # Confirm the feature set of the test database\\n self.connection.features.confirm()\\n \\n # Get a cursor (even though we don't need one yet). This has\\n # the side effect of initializing the test database.\\n self.connection.cursor()\\n\\n return test_database_name\\n \\n def destroy_test_db(self, old_database_name, verbosity=1):\\n \\\"\\\"\\\"\\n Destroy a test database, prompting the user for confirmation if the\\n database already exists.\\n \\\"\\\"\\\"\\n self.connection.close()\\n test_database_name = self.connection.settings_dict['NAME']\\n if verbosity >= 1:\\n test_db_repr = ''\\n if verbosity >= 2:\\n test_db_repr = \\\" ('%s')\\\" % test_database_name\\n print \\\"Ignore the test database for alias '%s'%s...\\\" % (\\n self.connection.alias, test_db_repr)\\n \\n # Temporarily use a new connection and a copy of the settings dict.\\n # This prevents the production database from being exposed to potential\\n # child threads while (or after) the test database is destroyed.\\n # Refs #10868 and #17786.\\n settings_dict = self.connection.settings_dict.copy()\\n settings_dict['NAME'] = old_database_name \\n \\n def _destroy_test_db(self, test_database_name, verbosity):\\n print \\\"Keep the test database !\\\" #%test_database_name\\n self.connection.close()\\n \\n \\n for alias in connections:\\n \\\"\\\"\\\"\\n django.test.simple.DjangoTestSuiteRunner\\n django.db.backends.creation\\n django.db.backends.mysql.base\\n \\\"\\\"\\\"\\n connection = connections[alias]\\n #if connection.settings_dict.get('ENGINE', '').endswith('.sqlite3'):\\n \\n if not self.options['setupdbs']:\\n f1 = types.MethodType(create_test_db, connection.creation, DatabaseCreation)\\n connection.creation.create_test_db = f1\\n \\n if not self.options['teardowndbs']:\\n f2 = types.MethodType(destroy_test_db, connection.creation, DatabaseCreation)\\n connection.creation.destroy_test_db = f2\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n if self.plugin_name == 'sideboard':\\n return\\n \\n difference = set(sys.modules.keys()) - self.original_keys\\n if difference:\\n # we apparently imported something new within the context and we should persist\\n # it to the module cache\\n _module_cache[self.plugin_name].update({k:sys.modules[k] for k in difference})\\n\\n # sanity check that original sys.modules was not overwritten underneath us\\n assert self.original_keys == set(self._original_modules.keys()), (\\n 'DETECTED CHANGE IN SAVED SYS.MODULES REFERENCE')\\n\\n sys.path = self._original_path\\n\\n for module_name in difference:\\n # much like in __enter__, we need to update in place\\n # TODO: determine if there's a danger for overwriting a module reference\\n # in the main sys.modules with a plug-in's version of the same module?\\n\\n # we explicitly want to error if the module name somehow isn't there\\n del sys.modules[module_name]\",\n \"def __init__(self):\\n self._cmd_list = ['use']\",\n \"def detach_intent(self, intent_name):\\n new_parsers = [\\n p for p in self.engine.intent_parsers if p.name != intent_name\\n ]\\n self.engine.intent_parsers = new_parsers\",\n \"def swap_aliases():\\n # store existing aliases, so we can restore them.\\n existing = {}\\n for name in COMMANDS:\\n if name in builtins.aliases:\\n existing[name] = builtins.aliases[name]\\n alt_name = name.replace(\\\"_\\\", \\\"-\\\")\\n if alt_name in builtins.aliases:\\n existing[alt_name] = builtins.aliases[alt_name]\\n load_aliases()\\n yield\\n unload_aliases()\\n\\n builtins.aliases.update(existing)\",\n \"def get_context(self):\\n symbol_chain = self.split_completion_object(self.get_word_before())\\n current_rs_object = self.module\\n\\n for symbol in symbol_chain:\\n try:\\n current_rs_object = current_rs_object.get_object(symbol)\\n logging.info(f\\\"New context found: {current_rs_object.name}\\\")\\n except:\\n logging.error(f\\\"{type(current_rs_object)} has no method get_object yet.\\\")\\n return current_rs_object\\n\\n return current_rs_object\",\n \"def __enter__(self):\\n if self.plugin_name == 'sideboard':\\n return\\n \\n self._original_path = sys.path\\n self._original_modules = sys.modules.copy()\\n self.original_keys = set(self._original_modules.keys())\\n\\n #TODO: determine if there a sufficiently negative performance implication\\n # to rethink doing this in recursive imports\\n sys.path = _path_cache[self.plugin_name] + sys.path\\n\\n #This really does need to be an update in place.\\n #Setting sys.modules = SOME_NEW_DICTIONARY means that\\n # imports still write to the original sys.modules\\n sys.modules.update(_module_cache[self.plugin_name])\",\n \"def _pre_chroot_block(self):\\n pass\",\n \"def load_alias(name):\\n mod = importlib.import_module(\\\"umdone.commands.\\\" + name)\\n main = getattr(mod, \\\"main\\\")\\n builtins.aliases[name] = main\\n builtins.aliases[name.replace(\\\"_\\\", \\\"-\\\")] = main\",\n \"def update_context(self, intent):\\n for tag in intent['__tags__']:\\n if 'entities' not in tag:\\n continue\\n context_entity = tag['entities'][0]\\n if self.context_greedy:\\n self.context_manager.inject_context(context_entity)\\n elif context_entity['data'][0][1] in self.context_keywords:\\n self.context_manager.inject_context(context_entity)\",\n \"def xontrib_context(name):\\n spec = find_xontrib(name)\\n if spec is None:\\n return None\\n m = importlib.import_module(spec.name)\\n pubnames = getattr(m, \\\"__all__\\\", None)\\n if pubnames is not None:\\n ctx = {k: getattr(m, k) for k in pubnames}\\n else:\\n ctx = {k: getattr(m, k) for k in dir(m) if not k.startswith(\\\"_\\\")}\\n return ctx\",\n \"def setup(self, context, entity, path, reduced_path, adapter, **kwargs):\\n\\n pass\",\n \"def _make_context():\\n return {\\n 'api': application.mounts['/api'],\\n 'db': db,\\n 'User': User,\\n 'admin': application.mounts['/admin']\\n }\",\n \"def fixupFileNames(process):\\n if not hasattr(process.source, \\\"fileNames\\\"):\\n process.source.fileNames = cms.untracked.vstring()\\n return\",\n \"def use(self, item_name):\\n pass\",\n \"def main(ctx, name, verbose):\\n ctx.ensure_object(dict)\\n ctx.obj['NAME'] = name\\n ctx.obj['VERBOSE'] = verbose\",\n \"def __setattr__(self, name, value):\\n if self._loop.is_running():\\n super().__setattr__(name, value)\\n else:\\n setattr(tlocals, name, value)\",\n \"def restore_context(self, filepath):\\n\\n raise NotImplementedError()\",\n \"def prep(self):\\n self.language.wrap_directory\",\n \"def _config_context():\\n config_path = os.path.join(DATA_DIR, CONFIG_FILENAME)\\n previous_config = None\\n try:\\n os.symlink(config_path, CONFIG_FILENAME)\\n except FileExistsError:\\n if not os.path.islink(CONFIG_FILENAME):\\n with open(CONFIG_FILENAME) as f:\\n previous_config = f.read()\\n os.unlink(CONFIG_FILENAME)\\n os.symlink(config_path, CONFIG_FILENAME)\\n try:\\n yield\\n finally:\\n os.unlink(CONFIG_FILENAME)\\n if previous_config is not None:\\n with open(CONFIG_FILENAME, \\\"w\\\") as f:\\n f.write(previous_config)\",\n \"def __enter__(self):\\n self._in_context_block = True\\n # TODO: create local backup of file in case we can't upload and have to roll back\\n return self\",\n \"def _name_changed(self):\\n self._named = True\",\n \"def before(self, context):\\n raise NotImplementedError\",\n \"def _override_context(): \\r\\n if _CDjangoPluginActivator._instance._IsDjangoProject():\\r\\n return [wingapi.kContextNewMenu(_(\\\"Djang_o\\\"), group=2)]\\r\\n else:\\r\\n return []\",\n \"def filesystem_layers(self):\\n pass\",\n \"def switch(self, context):\\n return\",\n \"def on_start(self, ctx):\\n pass\",\n \"def prepare(self, context):\\n raise NotImplementedError\",\n \"def migrate(self, **kwargs):\\n volume_name = kwargs['NAME']\\n vm = kwargs['vm']\\n volume_info = self.cm.find_name(name=volume_name)\\n volume_attached_vm = volume_info[0]['AttachedToVm']\\n vm_info = Shell.run(f\\\"multipass info {vm} --format=json\\\")\\n vm_info = json.loads(vm_info)\\n vm_status = vm_info[\\\"info\\\"][vm]['state']\\n if vm_status == 'running':\\n param = {'NAME': volume_name}\\n self.detach(**param)\\n self.attach(**param, vm=vm)\\n try:\\n for old_vm in volume_attached_vm:\\n volume_info[0]['AttachedToVm'].remove(old_vm)\\n except:\\n pass\\n volume_info[0]['AttachedToVm'].append(vm)\\n return volume_info\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5382174","0.52348757","0.5089552","0.4976699","0.4921123","0.4909736","0.4871767","0.48032677","0.47282645","0.47134584","0.46923074","0.46920326","0.46766403","0.46594715","0.4586809","0.45746368","0.456511","0.45414543","0.45359203","0.45268455","0.4520585","0.44956425","0.4494386","0.44887647","0.44880614","0.44812965","0.4470825","0.44577345","0.4437977","0.44292647","0.4403023","0.4399337","0.43860972","0.43604463","0.43468297","0.43440393","0.43424296","0.43420213","0.4341197","0.4339003","0.43340054","0.4333513","0.43321526","0.432634","0.43208796","0.43193868","0.4313181","0.43111387","0.43003497","0.4299729","0.4299698","0.42941543","0.42922568","0.4289692","0.42862666","0.42841843","0.42682058","0.42669085","0.42522326","0.42519152","0.42400897","0.42385152","0.42382297","0.42375204","0.42313325","0.4230599","0.42302147","0.422689","0.42246005","0.42244935","0.42183802","0.4216604","0.42131013","0.42122546","0.42120156","0.42113757","0.42086086","0.4205256","0.4196036","0.41923696","0.4181384","0.41812667","0.4179379","0.4173198","0.41690075","0.4165077","0.4164023","0.41630575","0.4159829","0.41588655","0.41569972","0.41522378","0.41474792","0.41469264","0.4145566","0.41455367","0.41450208","0.4142315","0.41411656","0.41400877","0.4140055"],"string":"[\n \"0.5382174\",\n \"0.52348757\",\n \"0.5089552\",\n \"0.4976699\",\n \"0.4921123\",\n \"0.4909736\",\n \"0.4871767\",\n \"0.48032677\",\n \"0.47282645\",\n \"0.47134584\",\n \"0.46923074\",\n \"0.46920326\",\n \"0.46766403\",\n \"0.46594715\",\n \"0.4586809\",\n \"0.45746368\",\n \"0.456511\",\n \"0.45414543\",\n \"0.45359203\",\n \"0.45268455\",\n \"0.4520585\",\n \"0.44956425\",\n \"0.4494386\",\n \"0.44887647\",\n \"0.44880614\",\n \"0.44812965\",\n \"0.4470825\",\n \"0.44577345\",\n \"0.4437977\",\n \"0.44292647\",\n \"0.4403023\",\n \"0.4399337\",\n \"0.43860972\",\n \"0.43604463\",\n \"0.43468297\",\n \"0.43440393\",\n \"0.43424296\",\n \"0.43420213\",\n \"0.4341197\",\n \"0.4339003\",\n \"0.43340054\",\n \"0.4333513\",\n \"0.43321526\",\n \"0.432634\",\n \"0.43208796\",\n \"0.43193868\",\n \"0.4313181\",\n \"0.43111387\",\n \"0.43003497\",\n \"0.4299729\",\n \"0.4299698\",\n \"0.42941543\",\n \"0.42922568\",\n \"0.4289692\",\n \"0.42862666\",\n \"0.42841843\",\n \"0.42682058\",\n \"0.42669085\",\n \"0.42522326\",\n \"0.42519152\",\n \"0.42400897\",\n \"0.42385152\",\n \"0.42382297\",\n \"0.42375204\",\n \"0.42313325\",\n \"0.4230599\",\n \"0.42302147\",\n \"0.422689\",\n \"0.42246005\",\n \"0.42244935\",\n \"0.42183802\",\n \"0.4216604\",\n \"0.42131013\",\n \"0.42122546\",\n \"0.42120156\",\n \"0.42113757\",\n \"0.42086086\",\n \"0.4205256\",\n \"0.4196036\",\n \"0.41923696\",\n \"0.4181384\",\n \"0.41812667\",\n \"0.4179379\",\n \"0.4173198\",\n \"0.41690075\",\n \"0.4165077\",\n \"0.4164023\",\n \"0.41630575\",\n \"0.4159829\",\n \"0.41588655\",\n \"0.41569972\",\n \"0.41522378\",\n \"0.41474792\",\n \"0.41469264\",\n \"0.4145566\",\n \"0.41455367\",\n \"0.41450208\",\n \"0.4142315\",\n \"0.41411656\",\n \"0.41400877\",\n \"0.4140055\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17092,"cells":{"query":{"kind":"string","value":"Given a quantity, import its CFs into the local database. Unfortunately this is still going to be slow because every part of the CF still needs to be canonicalized. The only thing that's saved is creating a new Characterization instance."},"document":{"kind":"string","value":"def import_cfs(self, quantity):\n try:\n qq = self._canonical_q(quantity)\n except KeyError:\n qq = self.add_quantity(quantity)\n\n count = 0\n for cf in quantity.factors():\n count += 1\n # print(cf)\n try:\n fb = self._fm[cf.flowable]\n except KeyError:\n fb = self._create_flowable(*quantity.query_synonyms(cf.flowable))\n\n self.add_quantity(cf.ref_quantity) # this may lead to the creation of non-converting quantities if units mismatch\n\n cx = self[cf.context]\n\n self._qassign(qq, fb, cf, context=cx)\n self._factors_for_later[quantity] = True\n print('Imported %d factors for %s' % (count, quantity))"},"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 import_counties():\n\n query = 'INSERT INTO texas_counties(county, region) VALUES(%s,%s)'\n with persistence() as db:\n # create new cursor instance\n cursor = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\n\n for council, counties in COUNCIL_DATA.items():\n for county in counties:\n cursor.execute(query, (county, council))\n db.commit()","def import_in_db(self):\n\n super().new_entry()\n\n if Categories.objects.all().count() > 0:\n try:\n category_compare = Categories.objects.get(\n name=self.product_infos['compare_to']\n )\n except:\n category_compare = None\n else:\n category_compare = None\n\n product_object = Products.objects.create(\n code=self.code,\n name=self.name,\n url=self.product_infos['product_url'],\n quantity=self.product_infos['quantity'],\n country=self.product_infos['countries'],\n ingredients=self.product_infos['ingredients'],\n energy=self.product_infos['energy-kcal_100g'],\n fat=self.product_infos['fat_100g'],\n satured_fat=self.product_infos['saturated-fat_100g'],\n carbohydrates=self.product_infos['carbohydrates_100g'],\n sugar=self.product_infos['sugars_100g'],\n fibers=self.product_infos['fiber_100g'],\n proteins=self.product_infos['proteins_100g'],\n salt=self.product_infos['salt_100g'],\n sodium=self.product_infos['sodium_100g'],\n nutriscore=self.product_infos['nutriscore'],\n image_url=self.product_infos['image_url'],\n compare_to_category=category_compare\n )\n\n ProductImportation.count += 1\n\n return product_object","def import_and_clean():\n \n with open(\"inventory.csv\", newline=\"\") as csvfile:\n inventory = csv.DictReader(csvfile)\n rows = list(inventory)\n\n for row in rows:\n row[\"product_price\"] = row[\"product_price\"].replace(\"$\", \"\")\n row[\"product_price\"] = row[\"product_price\"].replace(\".\", \"\")\n row[\"product_price\"] = int(float(row[\"product_price\"]))\n row[\"date_updated\"] = datetime.datetime.strptime(row[\"date_updated\"], \"%m/%d/%Y\")\n row[\"product_quantity\"]= int(row[\"product_quantity\"])\n \n return rows","def add_from_file(category_label, fname):\n dirname = os.path.dirname(os.path.abspath(__file__))\n with codecs.open(os.path.join(dirname, fname), encoding='utf-8') as stops_file:\n for line in stops_file:\n if line.startswith('#'):\n continue\n val_name, val_surface_forms = preprocess_cl_line(line)\n for form in val_surface_forms:\n db_add(category_label, val_name, form)","def load_chems(self, file_name, update_mappings, chunksize=1000):\n\n logger.info( \"Loading chemicals from [{}]\".format(file_name) )\n\n csv.field_size_limit(10000000)\n input_file = codecs.open(file_name, 'rb', 'utf-8')\n tsvin = csv.reader(input_file, delimiter='\\t')\n\n sql_alc_conn = self.db.connect()\n db_api_conn = sql_alc_conn.connection\n\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)')\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (:1, :2, :3, :4)', self.chem_struc_types)\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = :1 and schembl_chem_id = :2 and field = :3 and (:4 > -1)')\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (:1, :2, :3, :4)')\n if (\"cx_oracle\" in str(self.db.dialect)):\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)')\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (:1, :2, :3, :4)', self.chem_struc_types)\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = :1 and schembl_chem_id = :2 and field = :3 and (:4 > -1)')\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (:1, :2, :3, :4)')\n else:\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)')\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (%s, %s, %s, %s)', self.chem_struc_types)\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = %s and schembl_chem_id = %s and field = %s and (%s > -1)')\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (%s, %s, %s, %s)')\n\n\n chunk = []\n\n # Process input records, in chunks\n for i, row in enumerate(tsvin):\n\n if (i == 0) and row[0] == 'SCPN':\n if row != self.CHEM_HEADER_ROW:\n raise RuntimeError(\"Malformed header detected in chemical data file\")\n continue\n\n if (i % chunksize == 0 and i > 0):\n logger.debug( \"Processing chem-mapping data to index {}\".format(i) )\n self._process_chem_rows(sql_alc_conn, update_mappings, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, chunk)\n del chunk[:]\n\n chunk.append(row)\n\n logger.debug( \"Processing chem-mapping data to index {} (final)\".format(i) )\n self._process_chem_rows(sql_alc_conn, update_mappings, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, chunk)\n\n # Clean up resources\n chem_ins.close()\n chem_struc_ins.close()\n chem_map_del.close()\n chem_map_ins.close()\n\n sql_alc_conn.close()\n input_file.close()\n\n logger.info(\"Chemical import completed\" )","def importItem(file_path):\n\n #Ouverture du fichier\n rb = open_workbook(file_path)\n r_sheet = rb.sheet_by_index(0)\n\n for row_index in range (1, r_sheet.nrows):\n #Hydratation or get Supplier Model\n item_supplier= r_sheet.cell(row_index, 4).value\n item_supplier, created = Supplier.objects.get_or_create(name=item_supplier)\n\n #Hydratation or get Category Model\n current_category = r_sheet.cell(row_index, 0).value\n item_category, created = Category.objects.get_or_create(name=current_category)\n\n #Hydratation Item\n item_name = r_sheet.cell(row_index, 1).value\n item_ref = current_supplier= r_sheet.cell(row_index, 3).value\n item_quantity = r_sheet.cell(row_index, 2).value\n item, created = Item.objects.get_or_create(ref=item_ref, name=item_name, category=item_category, supplier=item_supplier, quantity=item_quantity)","def importDatabase(self):\n db_conn.execute(\"INSERT INTO Fietsenstalling (Naam, Achternaam, Telefoon, FietsNr, PIN) VALUES \"\n \"(?, ?, ?, ?, ?);\", (naamInvoer.get(), achternaamInvoer.get(), telefoonnummerInvoer.get(), FietsNr, pincodeInvoer.get()))\n\n db_conn.commit()","def add_filters(fnames):\n with Database(writable=True) as base:\n for fname in fnames:\n with open(fname, 'r') as f_fname:\n filter_name = f_fname.readline().strip('# \\n\\t')\n filter_type = f_fname.readline().strip('# \\n\\t')\n filter_description = f_fname.readline().strip('# \\n\\t')\n filter_table = np.genfromtxt(fname)\n # The table is transposed to have table[0] containing the\n # wavelength and table[1] containing the transmission.\n filter_table = filter_table.transpose()\n # We convert the wavelength from Å to nm.\n filter_table[0] *= 0.1\n\n print(\"Importing {}... ({} points)\".format(filter_name,\n filter_table.shape[1]))\n\n new_filter = Filter(filter_name, filter_description, filter_type,\n filter_table)\n\n # We normalise the filter and compute the effective wavelength.\n # If the filter is a pseudo-filter used to compute line fluxes, it\n # should not be normalised.\n if not filter_name.startswith('PSEUDO'):\n new_filter.normalise()\n else:\n new_filter.effective_wavelength = np.mean(\n filter_table[0][filter_table[1] > 0]\n )\n\n base.add_filter(new_filter)","def load_products():\n\n print \"Loading Products\"\n\n for i, row in enumerate(open(\"data/mock_product_data.csv\")):\n row = row.rstrip()\n title, price, inventory = row.split(\",\")\n\n product = Product(title=title,\n price=price,\n available_inventory=inventory)\n\n db.session.add(product)\n\n db.session.commit()","def import_prices(self):\n temp = dict(self.currencies_and_regions)\n for index, row in self.df.iterrows():\n self.set_mini_bundle_name(row[\"Journal Name \"])\n self.set_issns(row[\"ISSN\"])\n self.set_currency(row[\"Currency\"])\n if not self.currency:\n continue\n cur = self.get_raw_currency(row[\"Currency\"])\n region = temp[cur]\n self.set_region(region)\n self.set_country(region)\n self.set_price(row[\"2021 rate\"])\n self.add_prices()\n\n # reset for next loop\n self.issns = []\n db.session.commit()","def import_file(some_genbank, collection):\n with open(some_genbank, 'r') as open_file:\n collection = kv.get_collection(collection)\n\n # Each \"record\" in genbank file is read, corresponds to individual contigs\n for record in SeqIO.parse(open_file, 'gb'):\n current_contig = record.name\n try:\n current_species = record.annotations['source']\n except KeyError:\n name = re.search(r'\\w+\\/(.+)\\.\\w+$', some_genbank)\n current_species = name.group(1)\n \n\n collection.insert_one({\n 'species':current_species,\n 'contig':current_contig,\n 'dna_seq':str(record.seq),\n 'type':'contig'\n })\n\n print \"Importing {}\".format(current_contig)\n ssu_gene = get_16S(record)\n if ssu_gene:\n try:\n locus_tag = ssu_gene[0].qualifiers['locus_tag'][0]\n except KeyError:\n locus_tag = None\n \n parsed_location = kv.get_gene_location(ssu_gene[0].location)\n gene_record = {\n 'species':current_species,\n 'location':{\n 'contig':current_contig,\n 'start':parsed_location[0],\n 'end':parsed_location[1],\n 'strand':parsed_location[2],\n },\n 'locus_tag':locus_tag,\n 'annotation':ssu_gene[0].qualifiers['product'][0],\n 'dna_seq':ssu_gene[1],\n 'type':'16S'\n }\n print \"adding 16S gene!\"\n collection.insert_one(gene_record)\n kv.get_collection('16S').insert_one(gene_record)\n\n for feature in record.features:\n if feature.type == 'CDS':\n parsed_location = kv.get_gene_location(feature.location)\n try:\n locus_tag = feature.qualifiers['locus_tag'][0]\n except KeyError:\n locus_tag = None\n\n gene_record = {\n 'species':current_species,\n 'location':{\n 'contig':current_contig,\n 'start':parsed_location[0],\n 'end':parsed_location[1],\n 'strand':parsed_location[2],\n 'index':None\n },\n 'locus_tag':locus_tag,\n 'annotation':feature.qualifiers['product'][0],\n 'dna_seq':get_dna_seq(feature, record),\n 'aa_seq':feature.qualifiers['translation'][0],\n 'type':'gene'\n }\n collection.insert_one(gene_record)","def add_to_cart(db, itemid, quantity):","def push_to_cartodb(f):\n print \"attempting to import into cartodb\"\n config = loadConfig()\n cl = CartoDBAPIKey(config[\"API_KEY\"],config[\"user\"])\n fi = FileImport(f,cl,table_name='python_table_test')\n fi.run()\n\n return fi.success","def load_inventory(file_name, table):\r\n try:\r\n with open(file_name, 'r') as objFile:\r\n for line in objFile:\r\n data = line.strip().split(',')\r\n cd = CD(int(data[0]),data[1],data[2])\r\n table.append(cd)\r\n print(\"{} successfully loaded!\".format(file_name))\r\n except FileNotFoundError:\r\n print(\"Could not load {}\".format(file_name))\r\n return table","def load_categories():\n\n Category.query.delete()\n\n with open(category_file) as f:\n for _ in range(1):\n next(f)\n \n for row in f:\n row = row.rstrip()\n categories_data = row.split(\",\")\n\n id = int(categories_data[0])\n category = categories_data[1]\n\n category_model = Category(id=id, category=category)\n db.session.add(category_model)\n db.session.commit()","def import_prices(self):\n temp = dict(self.currencies_and_regions)\n for index, row in self.df.iterrows():\n self.set_journal_name(row[\"Journal Name \"])\n self.set_issn(row[\"ISSN\"])\n self.set_journal()\n self.set_currency(row[\"Currency\"])\n if not self.currency:\n continue\n cur = self.get_raw_currency(row[\"Currency\"])\n region = temp[cur]\n self.set_region(region)\n self.set_country(region)\n self.process_fte(row[\"Price Group\"])\n self.set_price(row[\"2021 rate\"])\n self.add_price_to_db()\n\n db.session.commit()","def import_product_data(directory_name, product_file):\n\n start = time.time()\n\n mongo = MongoDBConnection()\n\n with mongo:\n LOGGER.info(\"Establishing MongoDB connection\")\n database = mongo.connection.storeDB\n\n LOGGER.info(\"Establishing databases\")\n products = database[\"products\"]\n initial_entries = database.products.count_documents({})\n\n #entry counts\n added_entries = 0\n\n with open(os.path.join(directory_name, product_file)) as csv_file:\n\n product_data = csv.reader(csv_file, delimiter=\",\")\n for entry in product_data:\n try:\n product_entry = {\"product_id\":entry[0],\n \"description\":entry[1],\n \"product_type\":entry[2],\n \"quantity_available\":entry[3]}\n products.insert_one(product_entry)\n added_entries += 1\n LOGGER.info(f\"Added {entry[0]} to product database\")\n except peewee.IntegrityError:\n LOGGER.info(f\"Error adding {entry[0]} to product database\")\n\n final_entries = database.products.count_documents({})\n\n return((initial_entries, added_entries, final_entries,\n (time.time() - start)))","def get_counties():\n\n for i, row in enumerate(open('data/counties_data.csv')):\n data = row.rstrip().split(\",\")\n county_name, latitude, longitude, county_name_lower = data\n\n county = County(county_name=county_name, latitude=latitude, longitude=longitude, county_name_lower=county_name_lower)\n\n db.session.add(county)\n\n if i % 100 == 0:\n print(i)\n\n db.session.commit()","def _pre_featurize(self, systems: Iterable[ProteinLigandComplex]) -> None:\n self._create_klifs_structure_db(retrieve_pocket_resids=True)\n self._create_klifs_kinase_db()\n self._create_ligand_smiles_dict()\n if self.shape_overlay:\n self._dowload_klifs_ligands()\n return","def insert_to_database(self, db):\n \n self.remove_bad_characters()\n print(\"Inserting \"+self.categorie_name+\" to database.\")\n db.query(\"INSERT INTO categorie (categorie_name) VALUES (:categorie_name)\", \\\n categorie_name=self.categorie_name)","def load_database(self, fsp='Species'):\n self.df_species = pd.read_csv(fsp + '.csv', header=0,\n index_col=0)","def load_data_to_db(self, path):\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\n for table_name in table_names:\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\n print(\"Loading table: \" + table_name)\n fn = os.path.join(path, table_name + '.csv')\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\n print(\"Loaded table \" + table_name)","def add_meta_f_to_db(meta_f, p, dbi):\n rism_attributes = sd.Water3DRISM.__dict__.keys()\n extra_attributes = sd.Water3DRISMExtra.__dict__.keys()\n with open(os.path.join(p, meta_f), 'rb') as f:\n txt = f.readlines()\n inchi_line = txt[0]\n if inchi_line.startswith('InChI'):\n print inchi_line\n _, inchi = inchi_line.split(', ')\n inchi = inchi.strip()\n dbmol = dbi.get_molecule(inchi)\n rism = sd.Water3DRISM()\n rism_extra = sd.Water3DRISMExtra()\n else:\n raise ValueError('dbf file must start with InChI, <inchi code>')\n for line in txt[1:]:\n if ',' in line:\n line_l = line.split(', ')\n name = line_l[0].strip()\n values = map(lambda x: x.strip(), line_l[1:])\n if len(line_l) == 2:\n if name in rism_attributes:\n rism.__setattr__(name, values[0])\n elif name in extra_attributes:\n if name == 'UCorrMult':\n rism_extra.__setattr__(name, values[0])\n else:\n with open(os.path.join(p, values[0]), 'rb') as f:\n value = f.read()\n rism_extra.__setattr__(name, value)\n elif len(line_l) == 4:\n rism_therm = sd.ThermodynamicOutput(Property=name)\n if values[0] != '-':\n rism_therm.TotalValue = values[0]\n if values[1] != '-':\n rism_therm.OContrib = values[1]\n if values[2] != '-':\n rism_therm.HContrib = values[2]\n rism.ThermOut.append(rism_therm)\n else:\n print 'Unknown attribute: {}'.format(name)\n rism.Extra = rism_extra\n dbmol.RISMCalcs.append(rism)\n dbi.add_molecule(dbmol)\n print 'Added molecule {}'.format(dbmol)","def import_fusion_archive(filename, name=\"import\"):\n import_options = app().importManager.createFusionArchiveImportOptions(filename)\n\n document = app().importManager.importToNewDocument(import_options)\n imported_root = document.products[0].rootComponent\n\n bodies = []\n\n for body in imported_root.bRepBodies:\n bodies.append(brep().copy(body))\n for occurrence in imported_root.allOccurrences:\n for body in occurrence.bRepBodies:\n bodies.append(brep().copy(body))\n\n document.close(saveChanges=False)\n\n return BRepComponent(*bodies, name=name)","def creatingItemSets(self, iFileName):\n # import pandas as pd\n # global Database\n self.Database = []\n lineNumber = 0\n # data = []\n if isinstance(iFileName, list):\n self.Database = iFileName\n if isinstance(iFileName, pd.DataFrame):\n if iFileName.empty:\n print(\"its empty..\")\n quit()\n i = iFileName.columns.values.tolist()\n if 'Transactions' in i:\n self.Database = iFileName['Transactions'].tolist()\n if 'Patterns' in i:\n self.Database = iFileName['Patterns'].tolist()\n\n if '.CSV' in iFileName:\n file1 = pd.read_csv(iFileName)\n columns = list(file1.head(0))\n if \"Patterns\" in columns:\n with open(iFileName, newline='') as csvFile:\n data = csv.DictReader(csvFile)\n for row in data:\n listValue = row['Patterns']\n l1 = listValue.replace(\"[\", \"\")\n l2 = l1.replace(\"]\", \"\")\n li = list(l2.split(\",\"))\n li1 = [int(i) for i in li]\n self.Database.append(li1)\n if \"Transactions\" in columns:\n with open(iFileName, newline='') as csvFile:\n data = csv.DictReader(csvFile)\n for row in data:\n listValue = row['Transactions']\n l1 = listValue.replace(\"[\", \"\")\n l2 = l1.replace(\"]\", \"\")\n li = list(l2.split(\",\"))\n li1 = [int(i) for i in li]\n self.Database.append(li1)\n else:\n try:\n with open(iFileName, 'r', encoding='utf-8') as f:\n for line in f:\n # line.strip()\n if lineNumber == 0:\n lineNumber += 1\n delimiter = self.findDelimiter([*line])\n # li=[lineNumber]\n li = line.split(delimiter)\n li1 = [i.rstrip() for i in li]\n self.Database.append([i.rstrip() for i in li1])\n # else:\n # self.Database.append(li)\n # data.append([lineNumber,li1])\n else:\n lineNumber += 1\n li = line.split(delimiter)\n # if delimiter==',':\n li1 = [i.rstrip() for i in li]\n self.Database.append(li1)\n except IOError:\n print(\"File Not Found\")\n quit()\n\n # else:\n # self.Database=iFileName['Transactions'].tolist()","def importFile(self):\n\n ## Backing up old CSV and JSON files before beginning import operations\n if os.path.isfile(\"text_files/customers.csv\") and os.path.isfile(\"text_files/customers.json\"):\n print(\"\\nCreating a backup of the existing customer .csv and .json files before overwriting\")\n shutil.copy2(\"text_files/customers.csv\", \"text_files/customers.csv.backup\" + str(time.time()))\n shutil.copy2(\"text_files/customers.json\", \"text_files/customers.json.backup\" + str(time.time()))\n\n ## Importing the text file for cleaning then converting to CSV\n input_file = open(\"text_files/customer_export.txt\", \"r\")\n output_file = open(\"text_files/customers.csv\", \"w\")\n\n ## A loop to clean and write the customer_export txt file to a CSV\n for line in input_file:\n clean_text = \"\"\n check_line = line.replace(\"#\", \"\").replace(\",,\",\"\").split(\"|\")\n for line in check_line:\n if line != check_line[10]:\n clean_text += line + \",\"\n elif line == check_line[10]:\n clean_text += line + \"\\n\"\n output_file.write(clean_text)\n\n ## Closing TXT file and CSV file after formatting\n input_file.close()\n output_file.close()\n\n ## Opening the cleaned CSV file for conversion to Json\n with open('text_files/customers.csv') as clean_csv:\n ## Converting CSV file to Json\n converted = csv.DictReader(clean_csv)\n rows = list(converted)\n\n ## Writing converted CSV to Json file\n with open('text_files/customers.json', 'w') as convert:\n json.dump(rows, convert)\n\n ## Deleting all data currently in database before importing new file\n db_connection.executeQuery(\"DELETE FROM CRM;DBCC CHECKIDENT ('CRM', RESEED, 0) DELETE FROM Mailings; DBCC CHECKIDENT ('Mailings', RESEED, 0) COMMIT\") \n\n ## Loading the newly created Json file\n with open(\"text_files/customers.json\") as customers_json:\n customers = json.load(customers_json)\n\n ## A loop to add the contents of the Json file to the database \n print(\"Writing imported file to database please wait...\")\n for key in customers:\n db_connection.executeQuery(\"INSERT INTO dbo.CRM (f_name, l_name, company, address, city, county, state, zip, primary_phone, secondary_phone, email_address) VALUES ('\" + key[\"first_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"last_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"company_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"address\"] + \"', '\" + key[\"city\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"county\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"state\"] + \"', '\" + str(key[\"zip\"]) + \"', '\" + key[\"phone1\"] + \"', '\" + key[\"phone2\"] + \"' , '\" + key[\"email\"] + \"'); COMMIT\")\n db_connection.executeQuery(\"INSERT INTO dbo.Mailings (name, company, address) VALUES ('\" + key[\"first_name\"].replace(\"\\'\", \"\\'\\'\") + \" \" + key[\"last_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"company_name\"].replace(\"\\'\", \"\\'\\'\") + \"','\" + key[\"address\"] + \" \" + key[\"city\"] + \" \" + key[\"county\"] + \" \" + key[\"state\"] + \" \" + str(key[\"zip\"]) + \"'); COMMIT\") \n\n print(\"\\nFinished writing to file. Returning to main menu...\")","def populate_t_database():\n with open('minerals.json') as file:\n file = json.loads(file.read())\n\n for mineral in file[:22]:\n mineral_entry = Mineral.objects.get_or_create(**mineral)","def add_imported(products):\n \n for product in products:\n add_product(product[\"product_name\"], product[\"product_quantity\"], product[\"product_price\"], product[\"date_updated\"])","def migrate_to_db(self, source, items_per_cat):\n data = self.fetch(source, items_per_cat)\n data = self.__attach_source(data, source)\n logger.debug('Migrating %d items to DB', len(data))\n self.repository.write(data)","def full_load_db_from_file(batch_size=10000):\n\n q_set = QuestionSet(load=True)\n with open('.config/config.json', 'r') as f:\n config = json.load(f)\n config = config['pg']\n\n conn = psycopg2.connect(\n host=config['host'],\n database=config['db'],\n user=config['user'],\n password=config['password'],\n )\n\n i, values = 0, []\n for q in q_set.questions_ordered:\n values.append((\n q.id,\n q.question,\n q.options,\n q.answer,\n q.category_id,\n ))\n i += 1\n\n cur = conn.cursor()\n cur.execute('TRUNCATE TABLE questions')\n query = \"\"\"\n INSERT INTO questions (id, question, options, answer, category_id)\n VALUES {}\n \"\"\"\n\n j = 0\n log.info(\"Writing {} questions to DB...\".format(i))\n for chunk in chunks(values, batch_size):\n log.info('Batch {}...'.format(j + 1))\n j += 1\n\n args = ','.join(cur.mogrify(\"(%s, %s, %s, %s, %s)\", v).decode(\"utf-8\") for v in chunk)\n cur.execute(query.format(args))\n conn.commit()\n\n log.info(\"Data transfer complete.\")\n cur.close()","def insert_into_solr(filepath):\n #filepath = '/vol1/mag/data/2018-07-19/dumps/PaperCitationContexts.txt'\n record_number = 0\n list_for_solr = []\n with open(filepath, \"r\") as file:\n # THERE ARE NULL BYTES WHICH MAKE CSV THROW AN ERROR. Replace them \n csv_reader = csv.reader((line.replace('\\0', '') for line in file), delimiter='\\t', quoting=csv.QUOTE_NONE)\n for paper_id, paper_reference_id, citation_context in csv_reader:\n #for record in csv_reader:\n #paper_id, paper_reference_id, citation_context = record\n record_number += 1\n solr_record = {}\n solr_record['paper_id'] = paper_id\n solr_record['paper_reference_id'] = paper_reference_id\n solr_record['citation_context'] = citation_context\n # Chunks of 500000\n if record_number % 25000 == 0:\n list_for_solr.append(solr_record)\n try:\n solr.add(list_for_solr)\n except Exception as e:\n print(e, record_number, filepath)\n list_for_solr = []\n print(record_number)\n else:\n list_for_solr.append(solr_record)\n #print(record_number)\n try:\n solr.add(list_for_solr)\n except Exception as e:\n print(e, record_number, filepath)","def insert_data_from_file(self, filename):\n self.get_cursor()\n ct = len([True for c in self.table.columns if c[1][0][:3] == \"ct-\"]) != 0\n if (([self.table.cleanup.function, self.table.delimiter,\n self.table.header_rows] == [no_cleanup, \",\", 1])\n and not self.table.fixed_width\n and not ct\n and (not hasattr(self.table, \"do_not_bulk_insert\") or not self.table.do_not_bulk_insert)):\n columns = self.table.get_insert_columns()\n filename = os.path.abspath(filename)\n statement = \"\"\"\nCOPY \"\"\" + self.table_name() + \" (\" + columns + \"\"\")\nFROM '\"\"\" + filename.replace(\"\\\\\", \"\\\\\\\\\") + \"\"\"'\nWITH DELIMITER ','\nCSV HEADER;\"\"\"\n try:\n self.execute(\"BEGIN\")\n self.execute(statement)\n self.execute(\"COMMIT\")\n except:\n self.connection.rollback()\n return Engine.insert_data_from_file(self, filename)\n else:\n return Engine.insert_data_from_file(self, filename)","def discogsImport (discogs_folder):\n\n # Set collection \n collection = user.collection_folders\n\n # Populate import table\n for album in collection[discogs_folder].releases:\n query = None\n\n # Concatenate notes\n hashing_note = None\n if album.notes != None:\n for idx in range(len(album.notes)):\n hashing_note = str(hashing_note) + str(album.notes[idx]['field_id']) + str(album.notes[idx]['value'])\n\n # Hash the notes\n notes_chksum = hashNotes(hashing_note)\n\n # Query instance table for instance\n db_instance = dbq.exec_db_query_dict(dbq.get_instance_info, album.instance_id)\n\n # New items\n if db_instance == None:\n\n # Build insert data\n query_data = {'instance_id': album.instance_id,\n 'rating': album.rating,\n 'title': album.release.title,\n 'folder_id': album.folder_id,\n 'discogs_date_added': album.date_added,\n 'notes': str(album.notes),\n 'notes_chksum': notes_chksum.hexdigest(),\n 'release_id': album.id, \n 'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n query = dbq.add_instance\n dbq.exec_db_query(query, query_data, query_type='insert')\n\n # Test for existing and changed\n elif db_instance['instance_id'] == album.instance_id and \\\n (db_instance['notes_chksum'] != notes_chksum.hexdigest() or \n db_instance['folder_id'] != album.folder_id or \n db_instance['release_id'] != album.id ):\n\n # Update notes if hash is different\n if db_instance['notes_chksum'] != notes_chksum.hexdigest():\n query_data = {'notes': str(album.notes),\n 'notes_chksum': notes_chksum.hexdigest(),\n 'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), \n 'instance_id': album.instance_id, \n 'release_id': album.id}\n query = dbq.update_instance_notes_chksum\n dbq.exec_db_query(query, query_data, query_type='insert')\n\n # Update folder id\n if db_instance['folder_id'] != album.folder_id:\n query_data = {'folder_id': album.folder_id,\n 'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), \n 'instance_id': album.instance_id}\n query = dbq.update_instance_folder_id\n dbq.exec_db_query(query, query_data, query_type='insert')\n \n if db_instance['release_id'] != album.id:\n query_data = {'release_id': album.id, \n 'instance_id': album.instance_id}\n query = dbq.update_instance_release_id\n dbq.exec_db_query(query, query_data, query_type='insert')","def load_categories():\n\n print('load_categories')\n\n Category.query.delete()\n\n for row in open(\"seed_data/categories.csv\"):\n name = row.rstrip()\n\n cat = Category(name=name)\n\n db.session.add(cat)\n\n db.session.commit()","def load_products():\n\n for i, row in enumerate(open(\"seed_data/category.product\")):\n row = row.rstrip()\n name = row.split(\"|\")\n product_category = ProductCategoryModel(name=name)\n db.session.add(product_category)\n\n for i, row in enumerate(open(\"seed_data/product.product\")):\n row = row.rstrip()\n name, short_description, long_description, product_category_id, img_path_xs, img_path_sm, img_path_md, img_path_lg = row.split(\"|\")\n product = ProductModel(name=name,\n short_description=short_description,\n long_description=long_description,\n product_category_id=product_category_id,\n img_path_xs=img_path_xs,\n img_path_sm=img_path_sm,\n img_path_md=img_path_md,\n img_path_lg=img_path_lg)\n db.session.add(product)\n\n for i, row in enumerate(open(\"seed_data/location.product\")):\n row = row.rstrip()\n name, description, address1, address2, city, state, zip_code, country, latitude, longitude, direction_url = row.split(\"|\")\n location = LocationModel(name=name,\n description=description,\n address1=address1,\n address2=address2,\n city=city,\n state=state,\n zip_code=zip_code,\n country=country,\n latitude=latitude,\n longitude=longitude,\n direction_url=direction_url)\n db.session.add(location)\n\n for i, row in enumerate(open(\"seed_data/location_product.product\")):\n row = row.rstrip()\n location_id, product_id, price, num_available = row.split(\"|\")\n location_product = LocationProductModel(location_id=location_id,\n product_id=product_id,\n price=price,\n num_available=num_available)\n db.session.add(location_product)\n\n db.session.commit()","def _pre_featurize(self, systems: Iterable[ProteinSystem]) -> None:\n self._create_klifs_structure_db()\n self._create_klifs_kinase_db()\n return","def update_database(path=None, **kwargs):\n mindf = pd.read_csv(pyrolite_datafolder(subfolder=\"mineral\") / \"mins.csv\")\n mindf = mindf.reindex(\n columns=mindf.columns.tolist()\n + [str(a) for a in pt.formula(\" \".join(list(mindf.formula.values))).atoms]\n )\n for ix in mindf.index: # add elemental compositions\n el = parse_composition(pt.formula(mindf.loc[ix, \"formula\"]))\n mindf.loc[ix, el.index] = el\n\n mindf = mindf.fillna(0.0)\n\n if path is None:\n path = __dbpath__\n\n path = Path(path).with_suffix(\".json\")\n\n # name group formula composition\n # needs write access\n with TinyDB(str(path)) as db:\n db.truncate()\n for k, v in mindf.T.to_dict().items():\n db.insert(v)","def create(cls, user, quant_process, water, plate_name, total_vol=3500,\n ng=5, min_vol=2.5, max_vol=3500, resolution=2.5,\n reformat=False):\n with sql_connection.TRN as TRN:\n # Add the row to the process table\n process_id = cls._common_creation_steps(user)\n\n # Add the row to the normalization_process tables\n sql = \"\"\"INSERT INTO qiita.normalization_process\n (process_id, quantitation_process_id, water_lot_id)\n VALUES (%s, %s, %s)\n RETURNING normalization_process_id\"\"\"\n TRN.add(sql, [process_id, quant_process.id, water.id])\n instance = cls(TRN.execute_fetchlast())\n\n # Retrieve all the concentration values\n concs = quant_process.concentrations\n # Transform the concentrations to a numpy array\n np_conc = np.asarray([raw_con for _, raw_con, _ in concs])\n dna_v = NormalizationProcess._calculate_norm_vol(\n np_conc, ng, min_vol, max_vol, resolution)\n water_v = total_vol - dna_v\n\n # Create the plate. 3 -> 384-well plate\n plate_config = plate_module.PlateConfiguration(3)\n plate = plate_module.Plate.create(plate_name, plate_config)\n for (comp, _, _), dna_vol, water_vol in zip(concs, dna_v, water_v):\n comp_well = comp.container\n row = comp_well.row\n column = comp_well.column\n\n if reformat:\n row = row - 1\n column = column - 1\n\n roffset = row % 2\n row = int(row - roffset + np.floor(column / 12)) + 1\n\n coffset = column % 2 + (row % 2) * 2\n column = int(coffset * 6 + (column / 2) % 6) + 1\n\n well = container_module.Well.create(\n plate, instance, total_vol, row, column)\n composition_module.NormalizedGDNAComposition.create(\n instance, well, total_vol, comp, dna_vol, water_vol)\n\n return instance","def load_stock(self):\n lines = []\n with Transaction().start(DBNAME, 1):\n stock_lines = self.Inventory.search([('state', '=', 'done'), ('location', '=', self.location.id)])\n if stock_lines:\n for i in stock_lines:\n batch = i.batch_number\n for j in i.lines:\n if j.quantity <= 0:\n continue\n dictionary = {}\n dictionary['code'] = j.product.code\n dictionary['item'] = j.product.template.name\n dictionary[\n 'category'] = j.product.template.category.name if j.product.template.category else None\n dictionary['quantity'] = Decimal(j.quantity).quantize(Decimal('0.11')).to_eng()\n dictionary['batch_number'] = batch\n dictionary['supplier'] = j.supplier.name if j.supplier else None\n dictionary['expiry_date'] = j.expiry_date.strftime('%d-%m-%Y') if j.expiry_date else None\n lines.append(dictionary)\n return lines","def load_expenditures():\n\n Expenditure.query.delete()\n\n with open(expenditure_file) as f:\n for _ in range(1):\n next(f)\n \n for row in f:\n row = row.rstrip()\n expenditure_data = row.split(\",\")\n print(expenditure_data)\n\n id = expenditure_data[0]\n category_id = expenditure_data[1]\n price = expenditure_data[2]\n date_of_expenditure = expenditure_data[3]\n expenditure_userid = expenditure_data[4]\n where_bought = expenditure_data[5]\n description = expenditure_data[6]\n\n expenditure = Expenditure(\n id = id,\n category_id = category_id,\n price = price,\n date_of_expenditure = get_datetime(date_of_expenditure),\n expenditure_userid = expenditure_userid,\n where_bought = where_bought,\n description = description\n )\n\n db.session.add(expenditure)\n\n db.session.commit()","def run(self):\n lineage_csv_gz = self.input_files_local[0][0]\n output_db = self.output_files_local()[0]\n log.write(f\"input: {lineage_csv_gz} output: {output_db}\")\n\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\n batch_list = {}\n with gzip.open(lineage_csv_gz, \"rt\") as gzf:\n for line in gzf:\n fields = line.rstrip().split(\",\")\n taxid = fields[0]\n species, genus, family = fields[-1:-4:-1]\n batch_list[taxid] = [species, genus, family]\n if len(batch_list) >= BATCH_INSERT_SIZE:\n lineage_dict.batch_inserts(batch_list.items())\n batch_list = {}\n lineage_dict.batch_inserts(batch_list.items())","def load_birds():\n\n for i, row in enumerate(open('seed_data/species.csv')):\n data = row.rstrip().split(\",\")\n common_name, species_code = data\n\n bird = Species(common_name=common_name,\n species_code=species_code)\n\n db.session.add(bird)\n\n # For testing, just to see it was happening\n if i % 100 == 0:\n print i\n\n db.session.commit()","def _from_catalog(self):\n if self.dbconn.version < 90100:\n return\n for ext in self.fetch():\n self[ext.key()] = ext","def create_table_country(db, f):\n # connect to the database and create a cursor\n\n # drop the table if it already exists; re-create it\n\n # Populate the StatelessCountByRegion Table\n # Loop through each line in the file:\n # for line in f:\n # Write the body of this loop yourself. Handle the whitespace around\n # each line, split each line on SEP, and insert the relevant values\n # into the table.\n # Hint: line.strip().split(SEP) will return you a list.\n\n # don't forget to close the cursor, commit the changes and close\n # the connection","def from_csv_to_database():\r\n for year, path in FileNamePath.items():\r\n # load csv files\r\n with open(path, encoding='cp1251') as dataset:\r\n print(f\"Download {year} data\")\r\n get_curr_data(dataset, year)","def read_extras(self, f):\n\n gb = f[\"base state\"]\n for name in gb:\n self.base[name] = Basestate(self.cc_data.grid.ny, ng=self.cc_data.grid.ng)\n self.base[name].d[:] = gb[name]","def __init__(self, species, qty, country_code):\n super(InternationalMelonOrder, self).__init__(species, qty, \"international\", 0.17, country_code)","def load_initial_packing_folding_rate(matrix: list):\n print(\"Start loading...\")\n\n # delete all existed records\n models.PackingFoldingRate.objects.all().delete()\n\n # row index\n index = len(matrix)\n for row in matrix[1:]:\n packing_type = row[0].strip()\n folding_rate = row[1]\n\n t = models.PackingFoldingRate(\n packing_type=packing_type.upper(),\n folding_rate=folding_rate # upper case\n )\n\n # save models\n t.save()\n\n # return loaded row number\n return index","def ingest_product_csv(csv_path):\n # Create a CSV import generator (next yields one db row)\n import_generator = import_csv_gen(csv_path)\n # Skip over the title row\n next(import_generator)\n # Iterate over all other rows\n while True:\n try:\n data = next(import_generator)\n if len(data) != 4:\n logger.error(f'Data with incorrect item count: {len(data)}')\n continue\n # extract items from list and add document to database\n with Connection():\n product = Product(\n product_id=data[PROD_ID],\n description=data[PROD_DESC],\n product_type=data[PROD_TYPE],\n quantity_available=data[PROD_QTY]\n )\n product.save() # This will perform an insert\n except StopIteration:\n break","def load_stock_symbol_fr_file(self):\n stock_list = pandas.read_csv(self.retrieval_type_input_file_dict[self.stock_retrieval_type])\n stock_list = list(stock_list['SYMBOL'])\n self.set_full_stocklist_to_retrieve(stock_list)","def open_file():\r\n\tr_ct = 0\r\n\t\r\n\twith open('flavors_of_cacao.csv', 'r') as csvfile:\r\n\t\tcacao_stream = csv.DictReader(csvfile)\r\n\t\tfor cacao_row in cacao_stream:\r\n\t\t\tr_ct += 1\r\n\t\t\t\r\n\t\t\t#quit after 100 records\r\n\t\t\tif r_ct > 100:\r\n\t\t\t\tbreak\r\n\t\t\t\t\r\n\t\t\t#pull the data out of the dictionary for sqlite3\r\n\t\t\tt_Company = cacao_row['Company']\r\n\t\t\tt_Specific_Bean_Origin = cacao_row['Specific_Bean_Origin']\r\n\t\t\tt_REF = cacao_row['REF']\r\n\t\t\tt_Review = cacao_row['Review']\r\n\t\t\tt_Cocoa = cacao_row['Cocoa']\r\n\t\t\tt_Location = cacao_row['Location']\r\n\t\t\tt_Rating = cacao_row['Rating']\r\n\t\t\tt_Bean = cacao_row['Bean']\r\n\t\t\tt_Broad_Bean_Origin = cacao_row['Broad_Bean_Origin']\r\n\t\t\t\r\n\t\t\t#print the first 15 lines\r\n\t\t\tif r_ct <= 15:\r\n\t\t\t\tprint (r_ct, t_Company, t_Bean, t_Cocoa, t_Review)\r\n\t\t\t\t\r\n\t\t\t#creates a sql cursor, formats the insert sql and executes it\r\n\t\t\tc = conn.cursor()\r\n\t\t\tstrsql = \"\"\"\r\n\t\t\t\tINSERT INTO cacao\r\n\t\t\t\t\t(Company, Specific_Bean_Origin, REF, Review, Cocoa, Location, Rating, Bean, Broad_Bean_Origin)\r\n\t\t\t\tvalues (\r\n\t\t\t\t\t'{t_Company}', '{t_Specific_Bean_Origin}', '{t_REF}', '{t_Review}', '{t_Cocoa}', '{t_Location}', '{t_Rating}', '{t_Bean}', '{t_Broad_Bean_Origin}');\r\n\t\t\t\t\"\"\".format(\r\n\t\t\t\t\tt_Company = t_Company,\r\n\t\t\t\t\tt_Specific_Bean_Origin = t_Specific_Bean_Origin,\r\n\t\t\t\t\tt_REF = t_REF,\r\n\t\t\t\t\tt_Review = t_Review,\r\n\t\t\t\t\tt_Cocoa = t_Cocoa,\r\n\t\t\t\t\tt_Location = t_Location,\r\n\t\t\t\t\tt_Rating = t_Rating,\r\n\t\t\t\t\tt_Bean = t_Bean,\r\n\t\t\t\t\tt_Broad_Bean_Origin = t_Broad_Bean_Origin\r\n\t\t\t\t\t)\r\n\t\t\tc.execute(strsql)\r\n\t\t\tconn.commit()","def merge_quantity(self, session, source_qty):\n qty_cls = source_qty.__class__\n try:\n target_qty = session.query(qty_cls).\\\n filter(and_(qty_cls.atom==self,\n qty_cls.data_source==source_qty.data_source)).one()\n target_qty.quantity = source_qty.quantity\n target_qty.std_dev = source_qty.std_dev\n\n except NoResultFound:\n\n self.quantities.append(source_qty)","def ingredient_used(self, item, quantity):\n logger.info('ReleaseDiscard ingredient used initiated')\n try:\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\n , order=[('batch_number', 'ASC')])\n product = self.Product.search([('name', '=', item),\n ('description', '=', 'Stock'),\n ('type', '=', 'goods')])[-1]\n done = False\n today = date.today()\n for i in inventory_list:\n for j in i.lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=quantity,\n batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=quantity, batch=i.batch_number)\n j.save()\n self.check_and_delete(i)\n done = True\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\n quantity=j.quantity, batch_number=i.batch_number)\n self.store_inventory(location=self.used, inventory_stock=j,\n quantity=j.quantity, batch=i.batch_number)\n j.quantity = 0\n j.save()\n self.check_and_delete(i)\n # transaction.cursor.commit()\n i.save()\n if done:\n return True\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False","def __addNuclideBases():\n with open(os.path.join(context.RES, \"nuclides.dat\")) as f:\n for line in f:\n # Skip header lines\n if line.startswith(\"#\") or line.startswith(\"Z\"):\n continue\n lineData = line.split()\n _z = int(lineData[0])\n _n = int(lineData[1])\n a = int(lineData[2])\n state = int(lineData[3])\n sym = lineData[4].upper()\n mass = float(lineData[5])\n abun = float(lineData[6])\n halflife = lineData[7]\n if halflife == \"inf\":\n halflife = numpy.inf\n else:\n halflife = float(halflife)\n nuSF = float(lineData[8])\n\n element = elements.bySymbol[sym]\n nb = NuclideBase(element, a, mass, abun, state, halflife)\n nb.nuSF = nuSF","def bulk_copy_to_db(self):\n database = PostgreSQLCommon()\n\n try:\n file = open(self.file_name_hash)\n database.bulk_copy(file, self.storage_table)\n\n m.info('Bulk insert from %s has been successfully completed!'\n % self.file_name_hash)\n except Exception as err:\n m.error('OOps! Bulk insert operation FAILED! Reason: %s' % str(err))\n finally:\n database.close()\n\n if os.path.exists(self.file_name_hash):\n os.remove(self.file_name_hash)","def add_cartons(db, cartons, tag):\n # stock cartons\n for key, value in cartons.iteritems():\n length, width, height = value.split('x')\n d = Box('box'+key, tags={tag}, length=int(float(length)), width=int(float(width)), height=int(float(height)))\n db.session.add(d)\n\n try:\n db.session.commit()\n except IntegrityError:\n return 1\n print(\"Duplicate boxes found!\")\n return 0","def ogrAppendFeatures(gpxFile, sourceLayer, destinationLayer):\r\n\r\n ##print \"Starting transaction for: {0}\".format(destinationLayer.GetName())\r\n print \" Importing {0}: {1} features\".format(sourceLayer.GetName(), sourceLayer.GetFeatureCount())\r\n fName = os.path.basename(gpxFile)\r\n destinationLayer.StartTransaction()\r\n for x in xrange(sourceLayer.GetFeatureCount()):\r\n sourceFeature = sourceLayer.GetNextFeature()\r\n ##print \"inserting record\"\r\n sourceFeature.SetFID(-1)\r\n sourceFeature.SetField(\"src\", fName)\r\n destinationLayer.CreateFeature(sourceFeature)\r\n\r\n #Commit the new features to the database\r\n ##print \" Committing transaction for: {0}\".format(destinationLayer.GetName())\r\n destinationLayer.CommitTransaction()","def _insert_data(self, query, columns):\n with open(self.file, encoding='utf8') as f:\n csvreader = csv.reader(f)\n next(csvreader) # skipping header\n for line in csvreader:\n line[5] = float(line[5])\n line[8] = int(line[8])\n line[3] = int(line[3])\n line[10] = int(line[10])\n self.session.execute(query, tuple(map(line.__getitem__, columns)))","def import_products(input_data):\n error_count = 0\n insert_count = 0\n LOGGER.info('Starting product import')\n for oneprod in input_data:\n try:\n Product(oneprod['product_id'], oneprod['description'], oneprod['product_type'],\n oneprod['quantity']).save(full_clean=True, force_insert=True)\n insert_count += 1\n except ValidationError as valerror:\n LOGGER.exception(\"Error importing data from csv: %s \", valerror.message)\n error_count += 1\n except (DuplicateKeyError) as duperror:\n LOGGER.exception(\"Error importing data from csv: %s \", duperror)\n error_count += 1\n\n return [insert_count, error_count]","def add_furniture():\n print(\"Attempting to seed the furniture collection.....\")\n print()\n\n chair_path = Path(\"chair.png\")\n\n couch = FurnitureItem(\n \"Comfy couch\",\n \"Well loved, but still in pretty good condition\",\n 60.00,\n 40,\n \"swiessle@stevens.edu\",\n \"Couch\",\n \"beige\",\n [50, 20, 10],\n )\n couch.set_image_filepath(chair_path)\n Database.add_item(couch)\n print(\"couch has been successfully added\")\n\n table = FurnitureItem(\n \"Dining room table\",\n \"Wooden dining room table. Has a few scuffs, but not bad!\",\n 30.00,\n 15,\n \"gracem730@gmail.com\",\n \"Table\",\n \"wood\",\n [40, 20, 40],\n )\n table.set_image_filepath(chair_path)\n Database.add_item(table)\n print(\"table has been successfully added\")\n\n bed = FurnitureItem(\n \"Bed Frame\",\n \"Just selling the bed frame, you'll have \\\n to get your own mattress\",\n 55.00,\n 50,\n \"erotside@stevens.edu\",\n \"Bed\",\n \"white\",\n [10, 20, 10],\n )\n bed.set_image_filepath(chair_path)\n Database.add_item(bed)\n print(\"bed has been successfully added\")\n\n desk = FurnitureItem(\n \"Ikea desk, no longer need it\",\n \"In great condition, this is truly a steal\",\n 60.00,\n 35,\n \"jlora@stevens.edu\",\n \"Ikea Desk\",\n \"navy\",\n [20, 20, 30],\n )\n desk.set_image_filepath(chair_path)\n Database.add_item(desk)\n print(\"desk has been successfully added\")\n\n shelf = FurnitureItem(\n \"Book shelf, never used\",\n \"Brand new\",\n 110.00,\n 25,\n \"dcarpent@stevens.edu\",\n \"Book Shelf\",\n \"black\",\n [10, 20, 100],\n )\n shelf.set_image_filepath(chair_path)\n Database.add_item(shelf)\n print(\"shelf has been successfully added\")\n\n print()\n print(\"Done seeding the furniture collection!\")\n print(\"----------------------------------------------\")","def populate_database(self):\n self.insert_products()\n self.insert_categories()\n self.insert_products_categories()\n self.insert_stores()\n self.insert_products_stores()","def read_stock(db, openfile):\n pass","def load_currencies_codes(data):\n currency_codes = [currency_code for currency_code in data.keys()]\n currency_code_objects = [Currency(data=currency_code)\n for currency_code\n in currency_codes]\n Currency.objects.bulk_create(currency_code_objects)","def connect_db_and_load_data(cls):\n db.connect()\n db.create_tables([Product], safe=True)\n load_data(transform_data('./inventory.csv'))","def start_cfm_jobs(file_dir, db, spec_type, job_template=None,\n job_comp_number=100, max_mass=1500):\n if not os.path.exists(file_dir):\n os.mkdir(file_dir)\n os.chdir(file_dir)\n\n out_file = open(db.name + \"_1.txt\", \"w\")\n i = 1\n j = 1\n inchi_set = set()\n if spec_type == 'pos':\n search = {\"_id\": {\"$regex\": \"^C\"}, \"Mass\": {\"$lt\": max_mass},\n \"Charge\": 0, \"Pos_CFM_spectra\": {\"$exists\": 0}}\n elif spec_type == 'neg':\n search = {\"_id\": {\"$regex\": \"^C\"}, \"Mass\": {\"$lt\": max_mass},\n \"Charge\": 0, \"Neg_CFM_spectra\": {\"$exists\": 0}}\n elif spec_type == 'ei':\n search = {\"_id\": {\"$regex\": \"^C\"}, \"Mass\": {\"$lt\": max_mass},\n \"Charge\": 0, \"EI_CFM_spectra\": {\"$exists\": 0}}\n else:\n raise ValueError('invalid spectrum spec_type')\n\n for compound in db.compounds.find(search, {\"SMILES\": 1, \"Inchikey\": 1}):\n con_block = compound['Inchikey'].split('-')[0]\n if con_block not in inchi_set:\n out_file.write(\"%s %s\\n\" % (con_block, compound['SMILES']))\n i += 1\n inchi_set.add(con_block)\n if not i % job_comp_number:\n out_file.close()\n j += 1\n out_file = open(db_name + \"_\" + str(j) + \".txt\", 'w')\n out_file.close()\n\n if job_template:\n # for Quest?\n # fetch the information from the job template\n try:\n infile = open(job_template)\n except IOError:\n sys.exit(\"Job template file not found\")\n temp_data = infile.readlines()\n infile.close()\n\n for comp_file in os.listdir(\".\"):\n if \".txt\" not in comp_file:\n continue\n job_data = deepcopy(temp_data)\n # edit the job template data for the specific job\n job_data[1] = \"#$ -e logs/cfm_%s.err\\n\" % (comp_file.strip('.txt'))\n job_data[2] = \"#$ -o logs/cfm_%s.log\\n\" % (comp_file.strip('.txt'))\n new_file = file_dir + \"/\" + comp_file.strip()\n job_data[11] = job_data[11].replace(\"{smile_file}\", new_file)\n\n # write the specific job file\n job_file = \"cfm_%s.job\" % comp_file.strip('.txt')\n outfile = open(job_file, 'w')\n outfile.writelines(job_data)\n outfile.close()\n rc = call([\"qsub\", job_file], shell=True)\n if not rc:\n os.remove(job_file)","def process_products_file(products_df: pd.DataFrame):\n products = []\n file_size = len(products_df)\n logging.info(f\"Processing PRODUCTS.csv file... {file_size} rows\")\n for index, row in products_df.iterrows():\n if not pd.isnull(row[\"NAME\"]):\n product = Product(sku=row[\"SKU\"], store=\"Richart's\")\n product.brand = row[\"BRAND\"]\n product.barcodes = row[\"BARCODES\"]\n product.description = cleanhtml(row[\"DESCRIPTION\"])\n product.category = row[\"CATEGORY\"]\n product.image_url = row[\"IMAGE_URL\"]\n product.package = row[\"BUY_UNIT\"]\n product.name = row[\"NAME\"]\n products.append(product)\n else:\n logging.warning(f\"PRODUCTS | Product without name! will not be included - index: {index}\")\n\n bulk_size = len(products)\n if bulk_size == BATCH_SIZE:\n try:\n session.bulk_save_objects(products)\n session.commit()\n logging.info(f\"Inserted {bulk_size} rows to PRODUCTS table\")\n products = []\n except Exception as e:\n logging.exception(f\"PRODUCTS error. msg: {e}\")\n session.rollback()","def import_data(directory_name, product_file, customer_file, rentals_file):\n with MongoDBConnection() as mongo:\n database = mongo.connection[DATABASE]\n\n product_error_count = 0\n try:\n product_collection = database[PRODUCT_COLLECTION]\n product_count = 0\n with open(directory_name + '/' + product_file, 'r') as csv_file:\n product_reader = csv.DictReader(csv_file) # return an ordered dictionary\n for row in product_reader:\n product_collection.insert_one(row)\n product_count += 1\n except (FileNotFoundError, TypeError):\n product_error_count += 1\n\n customer_error_count = 0\n try:\n customer_collection = database[CUSTOMER_COLLECTION]\n customer_count = 0\n with open(directory_name + '/' + customer_file, 'r') as csv_file:\n customer_reader = csv.DictReader(csv_file)\n for row in customer_reader:\n customer_collection.insert_one(row)\n customer_count += 1\n except (FileNotFoundError, TypeError):\n customer_error_count += 1\n\n rentals_error_count = 0\n try:\n rentals_collection = database[RENTALS_COLLECTION]\n rentals_count = 0\n with open(directory_name + '/' + rentals_file, 'r') as csv_file:\n rentals_reader = csv.DictReader(csv_file)\n for row in rentals_reader:\n rentals_collection.insert_one(row)\n rentals_count += 1\n except (FileNotFoundError, TypeError):\n rentals_error_count += 1\n\n return product_count + customer_count + rentals_count","def readClumpcat(self):\n\t\tf = open('%s/raw_clumpcat_%s' %(self.wd,self.file))\n\t\tdata = []\n\t\tfor line in f.readlines()[1:]:\n\t\t\tdata.append(map(float, line.split()))\n\t\tself.clumpcat = data","def import_warehouse_stock_qty_batch(session, model_name, backend_id, filters=None):\n if filters is None:\n filters = {'skus': 'ALL'}\n env = get_environment(session, model_name, backend_id)\n importer = env.get_connector_unit(WarehouseImport)\n importer.run(filters['skus'])","def import_clean_process():\n # loading the co2 emissions data for the Earth, I'm only interested in the\n # total emissions and the year\n global_co2 = pd.read_csv(\n \"datasets/Global CO2 Emissions.csv\",\n usecols=[\n \"Year\",\n \"Total\"\n ],\n parse_dates=[\"Year\"],\n index_col=\"Year\"\n )\n # creating the global temperature dataframe\n global_temp_data = open(\n \"datasets/CRUTEM.4.6.0.0.global_n+s\",\n \"r\"\n )\n global_temp = pd.DataFrame(\n {\n \"global_temp\": [],\n }\n )\n for line in global_temp_data:\n # each line in the file is an observation for the year, the first\n # column being the year, the second being the temperature measurement\n data = line.split()\n global_temp.at[pd.to_datetime(data[0]), \"global_temp\"] = float(data[1])\n global_temp_data.close()\n # loading the co2 emissions data for the UK\n uk_co2 = pd.read_csv(\n \"datasets/UK carbon dioxide emissions between 1858 to 2017 .csv\",\n parse_dates=[\"Date\"],\n index_col=\"Date\"\n )\n # creating the dataframe for the UK temperature data\n uk_temp = pd.DataFrame(\n {\n \"uk_temp\": [],\n }\n )\n # this file consists of monthly and seasonal averages for the UK surface\n # temperature\n uk_tmean = open(\n \"datasets/UK Mean Temperature (Degrees C)\",\n \"r\"\n )\n for index, line in enumerate(uk_tmean):\n # the data begins on the eigth line in the file\n if index > 7:\n data = line.split()\n # the monthly temperatures are from the 2nd and 13th columns\n month_temps = np.array(data[1:13]).astype(float)\n # the first reading is the year, I've taken the average of all the\n # months to get an annual average\n uk_temp.at[pd.to_datetime(data[0]), \"uk_temp\"] = month_temps.mean()\n uk_tmean.close()\n # removing the temperature reading for 2019 as it isn't averaged over the\n # whole year (this program was written in 06/2019)\n uk_temp = uk_temp[:-1]\n # merging the temperature and co2 emissions dataframes for the Earth\n global_data = pd.merge(\n global_temp,\n global_co2,\n left_index=True,\n right_index=True,\n how=\"outer\"\n )\n # merging the temperature and co2 emissions dataframes for the UK\n uk_data = pd.merge(\n uk_temp,\n uk_co2,\n left_index=True,\n right_index=True,\n how=\"outer\"\n )\n # merging the global and UK dataframes\n df_data = pd.merge(\n global_data,\n uk_data,\n left_index=True,\n right_index=True,\n how=\"outer\"\n )\n # rename some of the columns to make them more clear\n df_data = df_data.rename(\n columns={\n \"Total\": \"global_co2\",\n \"CO2 Emissions\": \"uk_co2\"\n }\n )\n return df_data","def load_products_data(connection, csvfile):\n insert_sql = 'insert into products (id, description, genres) ' \\\n 'values (%s, %s, %s)'\n load_data(connection, insert_sql, get_data_from_file(csvfile))","def _importInDjango(self):\n\n with open(settings.DATA_PATH, 'r', encoding='latin-1') as csv_file:\n reader = csv.DictReader(csv_file, delimiter=';')\n for raw in reader:\n\n # Créer ou mettre à jour la division\n division, created = Division.objects.get_or_create(\n nom=raw['Division']\n )\n if created:\n self.stdout.write(\n 'Divion {} ajoutée'.format(division.nom)\n )\n\n # Créer ou mettre à jour les équipes\n equipeDom, created = Equipe.objects.get_or_create(\n nom=raw['Equipe 1'],\n division=division\n )\n if created:\n self.stdout.write(\n 'Equipe {} ajoutée'.format(equipeDom.nom)\n )\n\n equipeExt, created = Equipe.objects.get_or_create(\n nom=raw['Equipe 2'],\n division=division\n )\n if created:\n self.stdout.write(\n 'Equipe {} ajoutée'.format(equipeExt.nom)\n )\n\n # Créer ou mettre à jour la rencontre\n scoreDom = 0 if raw['Score 1'] == '' else int(raw['Score 1'])\n scoreExt = 0 if raw['Score 2'] == '' else int(raw['Score 2'])\n forfaitDom = True if raw['Forfait 1'] == 'true' else False\n forfaitExt = True if raw['Forfait 2'] == 'true' else False\n date = datetime.datetime.strptime(raw['Date de rencontre'], '%d/%m/%Y')\n heure = datetime.datetime.strptime(raw['Heure'], '%H:%M')\n rencontre, created = Rencontre.objects.update_or_create(\n numero=int(raw['N° de match']),\n equipeDom=equipeDom,\n equipeExt=equipeExt,\n defaults={\n 'date': date,\n 'heure': heure,\n 'scoreDom': scoreDom,\n 'scoreExt': scoreExt,\n 'forfaitDom': forfaitDom,\n 'forfaitExt': forfaitExt,\n }\n )\n if created:\n self.stdout.write(\n 'Rencontre {} / {} ajoutée'.format(\n rencontre.equipeDom,\n rencontre.equipeExt\n )\n )","def _create_db_entries(self, qa):\n\n def _package_description(raw):\n return raw[2:].replace(' - ', ' - ')\n\n log.debug('Creating database entries')\n\n\n # Parse component and section from field in changes\n component, section = parse_section(self.changes['files'][0]['section'])\n\n # Check whether package is already in the database\n package_query = meta.session.query(Package).filter_by(name=self.changes['Source'])\n if package_query.count() == 1:\n log.debug('Package %s already exists in the database' % self.changes['Source'])\n package = package_query.one()\n # Update description to make sure it reflects the latest upload\n package.description = _package_description(self.changes['Description'])\n else:\n log.debug('Package %s is new to the system' % self.changes['Source'])\n package = Package(name=self.changes['Source'], user=self.user)\n package.description = _package_description(self.changes['Description'])\n package.needs_sponsor = 0\n meta.session.add(package)\n\n # No need to check whether there is the same source name and same version as an existing\n # entry in the database as the upload controller tested whether similar filenames existed\n # in the repository. The only way this would be wrong is if the filename had a different\n # version in than the Version field in changes..\n\n\n try:\n closes = self.changes['Closes']\n except KeyError:\n closes = None\n\n # TODO: fix these magic numbers\n if qa.stop():\n qa_status = 1\n else:\n qa_status = 0\n\n maintainer_matches = re.compile(r'(.*) <(.*)>').match(self.changes['Changed-By'])\n maintainer = maintainer_matches.group(2)\n\n package_version = PackageVersion(package=package, version=self.changes['Version'],\n section=section, distribution=self.changes['Distribution'], qa_status=qa_status,\n component=component, priority=self.changes.get_priority(), closes=closes,\n uploaded=datetime.now(), maintainer=maintainer)\n meta.session.add(package_version)\n\n source_package = SourcePackage(package_version=package_version)\n meta.session.add(source_package)\n\n binary_package = None\n\n # Add PackageFile objects to the database for each uploaded file\n for file in self.files:\n filename = os.path.join(self.changes.get_pool_path(), file)\n # This exception should be never caught.\n # It implies something went wrong before, as we expect a file which does not exist\n try:\n sum = md5sum(os.path.join(pylons.config['debexpo.repository'], filename))\n except AttributeError as e:\n self._fail(\"Could not calculate MD5 sum: %s\" % (e))\n\n size = os.stat(os.path.join(pylons.config['debexpo.repository'], filename))[ST_SIZE]\n\n # Check for binary or source package file\n if file.endswith('.deb'):\n # Only create a BinaryPackage if there actually binary package files\n if binary_package is None:\n binary_package = BinaryPackage(package_version=package_version, arch=file[:-4].split('_')[-1])\n meta.session.add(binary_package)\n\n meta.session.add(PackageFile(filename=filename, binary_package=binary_package, size=size, md5sum=sum))\n else:\n meta.session.add(PackageFile(filename=filename, source_package=source_package, size=size, md5sum=sum))\n\n meta.session.commit()\n log.warning(\"Finished adding PackageFile objects.\")\n\n # Add PackageInfo objects to the database for the package_version\n for result in qa.result:\n meta.session.add(PackageInfo(package_version=package_version, from_plugin=result.from_plugin,\n outcome=result.outcome, rich_data=result.data, severity=result.severity))\n\n # Commit all changes to the database\n meta.session.commit()\n log.debug('Committed package data to the database')\n\n subscribers = meta.session.query(PackageSubscription).filter_by(package=self.changes['Source']).filter(\\\n PackageSubscription.level <= constants.SUBSCRIPTION_LEVEL_UPLOADS).all()\n\n if len(subscribers) > 0:\n email = Email('package_uploaded')\n self.send_email(email, [s.user.email for s in subscribers], package=self.changes['Source'],\n version=self.changes['Version'], user=self.user)\n\n log.debug('Sent out package subscription emails')\n\n # Send success email to uploader\n email = Email('successful_upload')\n dsc_url = pylons.config[\n 'debexpo.server'] + '/debian/' + self.changes.get_pool_path() + '/' + self.changes.get_dsc()\n rfs_url = pylons.config['debexpo.server'] + url('rfs', packagename=self.changes['Source'])\n self.send_email(email, [self.user.email], package=self.changes['Source'],\n dsc_url=dsc_url, rfs_url=rfs_url)","def load_equipment():\n\n for row in open(\"static/equipment.csv\"):\n row = row.rstrip()\n \n gear_name, category, brand, lender_email, zipcode, gear_photo, gear_photo_url = row.split(\",\")\n\n equipment = Equipment(\n gear_name=gear_name,\n category=category,\n brand=brand,\n lender_email=lender_email,\n zipcode=zipcode,\n gear_photo=gear_photo,\n gear_photo_url=gear_photo_url)\n\n db.session.add(equipment)\n \n\n db.session.commit()","def repopulate(self, scale_factor):\n \n # drop db if exists, this isn't terribly expensive\n print('dropping db...')\n if self.tpch_cxn:\n self.tpch_cxn.close()\n with self.cxn.cursor() as cur:\n cur.execute('DROP DATABASE tpch')\n \n # create db, connection to db\n print('creating db... connecting to db...')\n with self.cxn.cursor() as cur:\n cur.execute('CREATE DATABASE tpch')\n self.tpch_cxn = self.__connect(TPCH_DSN)\n\n # generate data\n print('running dbgen... repopulating db...')\n tic=time.time()\n subprocess.run(['./dbgen.sh', str(scale_factor)]) # TODO whoops put absolute path\n\n # create tables, copy data into tables\n with open(os.path.join(TPCH_DIR, 'build-tpch-tables.sql'), 'r') as f, \\\n self.tpch_cxn.cursor() as cur:\n\n cur.execute(f.read())\n \n toc = time.time()\n print('...took {} seconds'.format(round(toc-tic)))\n\n # rm generated data\n print('cleaning up...')\n subprocess.run(['rm', '-rf', DATA_DIR])","def cfInsert(self, key, items, capacity=None, nocreate=None):\n params = [key]\n self.appendCapacity(params, capacity)\n self.appendNoCreate(params, nocreate)\n self.appendItems(params, items)\n\n return self.execute_command(self.CF_INSERT, *params)","def process_database(self):\n self.DBDict = self.data_df.to_dict(orient=\"index\")\n\n # calculate weight ratio\n self.DBDict = {k: self.calc_compound_weight_ratio(\n self.DBDict[k]) for k in self.DBDict}\n\n # export as dataframe\n self.converted_df = pd.DataFrame(self.DBDict).T\n\n unnest_list = [\"SMILES_wt_list\", \"structureList\",\n \"wt_ratio\", \"fp_list\", \"MWList\"]\n self.converted_df = unnest_dataframe(\n self.converted_df, unnest_list, axis=0)\n\n # unnest FP\n unNest_FP_list = list(self.converted_df.columns[[True if re.match(\n \"fp_list\", i) else False for i in self.converted_df.columns]])\n rename_dict = {k: k+\"_\" for k in unNest_FP_list}\n self.converted_df = self.converted_df.rename(columns=rename_dict)\n\n self.converted_df = unnest_dataframe(\n self.converted_df, rename_dict.values(), axis=0)","def coal_saved_benefits(self, coal_import_price):\n baseline = self.plant.mainfuel_used\n reduction = self.coal_saved\n relative = reduction / baseline\n benefit = reduction * coal_import_price\n display_as(benefit, \"MUSD\")\n return DataFrame(\n [baseline, reduction, relative, benefit],\n index=[\"Baseline\", \"Reduction\", \"Relative reduction\", \"Value\"],\n )","def convert_to_s3db(f_name, df):\n if '[CHECKED]' in f_name:\n db_name = f_name.split('[CHECKED]')[0] + '.s3db'\n else:\n db_name = f_name.split('.')[0] + '.s3db'\n con = sqlite3.connect(db_name)\n cur = con.cursor()\n cur.execute(\"\"\"CREATE TABLE IF NOT EXISTS convoy (\n vehicle_id INTEGER PRIMARY KEY,\n engine_capacity INTEGER NOT NULL,\n fuel_consumption INTEGER NOT NULL,\n maximum_load INTEGER NOT NULL,\n score INTEGER NOT NULL)\n \"\"\")\n con.commit()\n rows_count = df.shape[0]\n # making data for 'score' column\n scores = [scoring(row) for row in df[column_names].to_numpy()]\n # add 'score' column to data frame\n df['score'] = scores\n df.to_sql('convoy', con=con, if_exists='append', index=False)\n print(f\"{rows_count} {'records were' if rows_count > 1 else 'record was'} inserted to {db_name}\")\n con.commit()\n con.close()","def preprocessing(self):\n print(\"This may take a while, please grab a coffee. Average wait time: 2 - 6 mins.\")\n print(\"Loading data... \")\n df = ExternalDataRetrieval().get_data()\n\n print(\"Preprocessing data... \")\n\n amino_df = pd.DataFrame()\n # Set column names for zinc content dataframe\n zcolumns = ['value', 'group']\n # Set column names for food groups dataframe\n fcolumns = ['ID', 'food', 'group', 'manufacturer']\n # Declare zinc content dataframe\n zinc_df = pd.DataFrame(columns=zcolumns)\n # Declare food group dataframe\n food_df = pd.DataFrame(columns=fcolumns)\n # Doing this one amino acids type at a time.\n for n in AMINO_LIST:\n food = []\n # nutrients components of the food type is further nested in 'nutrients', which its components are further\n # nested\n for i, items in enumerate(df['nutrients']):\n # Iterate through the nutrient type to obtain necessary info.\n # For this project, there are many redundant data in there.\n f_flag = False\n # Only need to set the flag to activate the zinc check for one amino acid loop\n if n == AMINO_LIST[0]:\n z_flag = False\n for item in items:\n # Check to see if this nutrient type is one of the amino acids\n if item.get(\"name\") == n and item.get(\"value\") > 0:\n # If so, add the food type to the amino acid type array\n food.append(df['name'][i]['long'])\n f_flag = True\n # Check to see if this nutrient type is Zinc, only need to do this for one amino acid loop.\n if item.get(\"name\") == Z and n == AMINO_LIST[0]:\n # If so, gets its zinc content value and the food group it is in.\n zinc_df.loc[i] = [item.get(\"value\"), df['group'][i]]\n z_flag = True\n if f_flag and z_flag:\n break\n\n # Build the food group data dataframe one food at a time, only need to do this for one amino acid loop.\n if n == AMINO_LIST[0]:\n food_df.loc[i] = [df['meta'][i]['ndb_no'], df['name']\n [i]['long'], df['group'][i], df['manufacturer'][i]]\n\n # Assemble the amino acid type array in to nutrient dataframe\n fd = pd.DataFrame({n: food})\n # Since the length of each columns varies (amino acid food types appearance in food types varies),\n # there are many NaN in the dataframe as a result. We need to drop the NaN\n fd = fd.dropna()\n amino_df = pd.concat([amino_df, fd], axis=1, ignore_index=True)\n # Add column names to the nutrient dataframe\n amino_df.columns = AMINO_LIST\n print(\"Good news, preprocessing completed successfully! \")\n return amino_df, zinc_df, food_df","def insert_data(cf, n):\n for r in xrange(n):\n print r\n for c1 in xrange(ord('a'), ord('z') + 1):\n for c2 in xrange(0, 100):\n cf.insert(r, { (chr(c1), c2) : normalvariate(0, 1)})","def keep_generated_quantity(fba, **_):\n fba = fba[fba['Description'] == 'Generated'].reset_index(drop=True)\n # if no mapping performed, still update units\n if 'tons' in fba['Unit'].values:\n fba = standardize_units(fba)\n return fba","def quantity(self, value):\n self._quantity = Decimal(value)","def gbk_upload(self):\n t_count = 0\n os.chdir(self.path)\n print(os.getcwd())\n if os.path.isdir(self.path + '/Databases') is False:\n os.mkdir('Databases')\n for tier in os.listdir(os.getcwd()):\n if tier == 'Databases':\n continue\n db_name = str(tier) + '.db'\n if os.path.isfile(self.path + '/Databases/' + db_name) is False:\n print('Copying Template BioSQL Database... '\n 'This may take a few minutes...')\n shutil.copy2(where.Templates + '/Template_BioSQL_DB.db',\n self.path + '/Databases/%s' % db_name)\n else:\n os.remove(self.path + '/Databases/' + db_name)\n print('Copying Template BioSQL Database... '\n 'This may take a few minutes...')\n shutil.copy2(where.Templates + '/Template_BioSQL_DB.db',\n self.path + '/Databases/%s' % db_name)\n\n server = BioSeqDatabase.open_database(\n driver='sqlite3', db=(\n self.path + '/Databases/' + db_name))\n os.chdir(tier)\n for gene in os.listdir(os.getcwd()):\n os.chdir(gene)\n sub_db_name = gene\n for file in os.listdir(os.getcwd()):\n try:\n if sub_db_name not in server.keys():\n server.new_database(sub_db_name)\n db = server[sub_db_name]\n count = db.load(SeqIO.parse(file, 'genbank'))\n server.commit()\n print('Server Commited %s' % sub_db_name)\n print('%s database loaded with %s.' % (db.dbid, file))\n print(\n \"That file contains %s genbank records.\" %\n str(count))\n t_count = t_count + count\n print(\n 'The total number of files loaded so far is %i.' %\n t_count)\n except BaseException:\n server.rollback()\n try:\n del server[sub_db_name]\n server.commit()\n except BaseException:\n raise\n raise\n os.chdir('..')\n os.chdir('..')","def __init__(self):\n self.file_name = 'data.csv'\n # Column of interest\n self._col = ['product_name', 'url', 'quantity', 'packaging']\n self._col += ['brands', 'origins', 'countries_fr', 'allergens']\n self._col += ['traces_fr', 'additives_n', 'additives_fr']\n self._col += ['nutrition_grade_fr', 'categories_fr']\n self._col += ['main_category_fr']\n\n # Check if the csv is already in the file\n try:\n with open(self.file_name, 'r'):\n pass\n except FileNotFoundError:\n CsvAnalysis.download_file()\n finally:\n # Read the csv file, and create a dataframe\n self.food_cat = pandas.read_csv(self.file_name,\n sep=\"\\t\",\n low_memory=False,\n usecols=self._col,\n encoding=\"utf8\")\n\n # Remove countries which aren't France\n mask = self.food_cat['countries_fr']\n self.food_cat = self.food_cat[mask == 'France']\n\n # Delete column countries_fr\n del self.food_cat['countries_fr']\n\n # Remove empty row countries_fr from dataframe\n columns = ['main_category_fr', 'product_name', 'nutrition_grade_fr']\n for column in columns:\n self.food_cat = self.food_cat[~self.food_cat[column].isnull()]\n\n # Remove empty row from product_name\n self.food_cat.sort_values(by='categories_fr')\n\n # Select the last value from categories_fr\n # to use it as a subcategory\n col = 'categories_fr'\n self.food_cat[col] = self.food_cat[col].str.split(',').str.get(-1)\n self.food_cat.sort_values(by='categories_fr')","def insert_into_sql(chunk):\n bulk_list = []\n for row in chunk:\n bulk_list.append(StockData(\n date=str(row[0])[0:4] + '-' + str(row[0])[4:6] + '-' + str(row[0])[6:8],\n code=row[1],\n code_name=row[2],\n d1_diff_rate=row[3],\n close=row[4],\n open=row[5],\n high=row[6],\n low=row[7],\n volume=row[8],\n clo5=row[9],\n clo10=row[10],\n clo20=row[11],\n clo40=row[12],\n clo60=row[13],\n clo80=row[14],\n clo100=row[15],\n clo120=row[16],\n clo5_diff_rate=row[17],\n clo10_diff_rate=row[18],\n clo20_diff_rate=row[19],\n clo40_diff_rate=row[20],\n clo60_diff_rate=row[21],\n clo80_diff_rate=row[22],\n clo100_diff_rate=row[23],\n clo120_diff_rate=row[24],\n yes_clo_5=row[25],\n yes_clo_10=row[26],\n yes_clo_20=row[27],\n yes_clo_40=row[28],\n yes_clo_60=row[29],\n yes_clo_80=row[30],\n yes_clo_100=row[31],\n yes_clo_120=row[32],\n vol5=row[33],\n vol10=row[34],\n vol20=row[35],\n vol40=row[36],\n vol60=row[37],\n vol80=row[38],\n vol100=row[39],\n vol120=row[40],\n ))\n StockData.objects.bulk_create(bulk_list)\n return bulk_list","def _process_chem_rows(self, sql_alc_conn, update, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, rows):\n\n logger.debug( \"Building set of unknown chemical IDs ({} known)\".format(len(self.existing_chemicals)) )\n\n # Identify chemicals from the batch that we haven't seen before\n unknown_chem_ids = set()\n for row in rows:\n chem_id = int(row[1])\n if chem_id in self.existing_chemicals:\n continue\n unknown_chem_ids.add( chem_id )\n\n # Search the DB to see if any of those chemicals are known\n if (len(unknown_chem_ids) > 0):\n\n logger.debug( \"Searching DB for {} unknown chemical IDs\".format(len(unknown_chem_ids)) )\n sel = select(\n [self.chemicals.c.id])\\\n .where(\n (self.chemicals.c.id.in_(unknown_chem_ids) ))\n\n # Add known chemicals to the set of existing chemicals\n result = sql_alc_conn.execute(sel)\n found_chems = result.fetchall()\n for found_chem in found_chems:\n self.existing_chemicals.add( found_chem[0] )\n\n logger.debug( \"Known chemical IDs now at: {}\".format(len(self.existing_chemicals)) )\n\n # Now process all input rows, generating new data records where needed\n new_chems = []\n new_chem_structs = []\n new_mappings = []\n\n new_chem_ids = set()\n\n logger.debug( \"Processing chemical mappings / building insert list\" )\n\n for i, row in enumerate(rows):\n\n if len(row) != self.CHEM_RECORD_COLS:\n raise RuntimeError(\"Incorrect number of columns detected in chemical data file\")\n\n if row[0] not in self.doc_id_map:\n logger.warn(\"Document ID not found for scpn [{}]; skipping record\".format(row[0]))\n continue\n\n doc_id = self.doc_id_map[ row[0] ]\n chem_id = int(row[1])\n\n # Add the chemical - if it's new\n if chem_id not in self.existing_chemicals and\\\n chem_id not in new_chem_ids:\n\n new_chems.append( (chem_id, float(row[6]), float(row[10]), int(row[8]), int(row[9]), int(row[11]), int(row[12]), int(row[13]), int(row[14]), int(row[7])) )\n new_chem_structs.append( ( chem_id, row[2], row[3], row[4]) )\n new_chem_ids.add(chem_id)\n\n # Add the document / chemical mappings\n new_mappings.append( (doc_id, chem_id, DocumentField.TITLE, int(row[15]) ) )\n new_mappings.append( (doc_id, chem_id, DocumentField.ABSTRACT, int(row[16]) ) )\n new_mappings.append( (doc_id, chem_id, DocumentField.CLAIMS, int(row[17]) ) )\n new_mappings.append( (doc_id, chem_id, DocumentField.DESCRIPTION, int(row[18]) ) )\n new_mappings.append( (doc_id, chem_id, DocumentField.IMAGES, int(row[19]) ) )\n new_mappings.append( (doc_id, chem_id, DocumentField.ATTACHMENTS, int(row[20]) ) )\n\n # Bulk insertions\n logger.debug(\"Performing {} chemical inserts\".format(len(new_chems)) )\n chem_ins.execute(new_chems)\n\n self.existing_chemicals.update( new_chem_ids )\n\n logger.debug(\"Performing {} chemical structure inserts\".format(len(new_chem_structs)) )\n chem_struc_ins.execute( new_chem_structs)\n \n if (update):\n logger.debug(\"Performing {} mapping deletions (for update)\".format(len(new_chem_structs)) )\n chem_map_del.execute( new_mappings)\n\n logger.debug(\"Performing {} mapping inserts\".format(len(new_mappings)) )\n chem_map_ins.execute( new_mappings)","def import_thousand_data(dir_name, product_file, customer_file, rentals_file):\n counter = Counter()\n client = MongoDBConnection()\n with client:\n hp_norton_db = client.connection.rental\n products = hp_norton_db['products']\n customers = hp_norton_db['customers']\n rentals = hp_norton_db['rentals']\n exist_products = products.count()\n exist_customers = customers.count()\n exist_rentals = rentals.count()\n\n # 1. load the products collection\n start = time.time()\n LOGGER.info('Load the products collection')\n processed_records = read_thousand_csv_file(dir_name, product_file,\n products, counter)\n product_tuple = (processed_records, exist_products, products.count(),\n time.time() - start)\n # 2. load the customers collection\n start = time.time()\n LOGGER.info('Load the customers collection')\n processed_records = read_thousand_csv_file(dir_name, customer_file,\n customers, counter)\n customer_tuple = (processed_records, exist_customers, customers.count(),\n time.time() - start)\n # 3. load the rentals collection\n start = time.time()\n LOGGER.info('Load the rentals collection')\n processed_records = read_thousand_csv_file(dir_name, rentals_file,\n rentals, counter)\n rental_tuple = (processed_records, exist_rentals, rentals.count(),\n time.time() - start)\n LOGGER.info(f'Return product tuple {product_tuple}')\n LOGGER.info(f'Return customer tuple {customer_tuple}')\n LOGGER.info(f'Return rental tuple {rental_tuple}')\n LOGGER.info('Total record prcessed for all three files:'\n f'{counter.value}')\n return [product_tuple, customer_tuple]","def read_formations():\n\n with resource_stream('component_contribution',\n FullTrainingData.FORMATION_ENERGY_FNAME) as fp:\n formation_df = pd.read_csv(gzip.GzipFile(fileobj=fp))\n\n cids_that_dont_decompose = set(\n formation_df.loc[formation_df['decompose'] == 0, 'cid'])\n\n for col in [\"dG'0\", \"T\", \"I\", \"pH\", \"pMg\"]:\n formation_df[col] = formation_df[col].apply(float)\n\n formation_df = formation_df[~pd.isnull(formation_df[\"dG'0\"])]\n formation_df['reaction'] = formation_df['cid'].apply(\n lambda c: Reaction({c: 1}))\n\n formation_df['balance'] = False\n formation_df['description'] = formation_df['name'] + ' formation'\n formation_df.rename(columns={'compound_ref': 'reference'},\n inplace=True)\n formation_df.drop(['name', 'cid', 'remark', 'decompose'],\n axis=1, inplace=True)\n\n logger.debug('Successfully added %d formation energies' %\n formation_df.shape[0])\n return formation_df, cids_that_dont_decompose","def ingredient_db():\n # type: () -> List[Text]\n return [\"abricot\",\n \"banane\",\n \"cassis\",\n \"cerise\",\n \"citron\",\n \"clémentine\",\n \"coing\",\n \"fraise\",\n \"framboise\",\n \"groseille\",\n \"mirabelle\",\n \"mûre\",\n \"myrtille\",\n \"nectarine\",\n \"orange\",\n \"pamplemousse\",\n \"pomelo\",\n \"pêche\",\n \"poire\",\n \"pomme\",\n \"prune\",\n \"pruneau\",\n \"raisin\",\n \"rhubarbe\",\n \"ananas\",\n \"figue\",\n \"fruit de la passion\",\n \"goyave\",\n \"grenade\",\n \"kaki\",\n \"kiwi\",\n \"kumquat\",\n \"litchi\",\n \"mangue\",\n \"melon\",\n \"papaye\",\n \"pastèque\",\n \"vanille\",\n \"amande\",\n \"datte\",\n \"noisette\",\n \"artichaut\",\n \"aubergine\",\n \"asperge\",\n \"avocat\",\n \"betterave\",\n \"blette\",\n \"brocoli\",\n \"banane plantain\",\n \"carotte\",\n \"cardon\",\n \"céleri rave\",\n \"céleri branche\",\n \"champignon\",\n \"champignon de paris\",\n \"chou blanc\",\n \"chou rouge\",\n \"chou de bruxelles\",\n \"chou-fleur\",\n \"citrouille\",\n \"concombre\",\n \"courge\",\n \"courgette\",\n \"crosne\",\n \"echalote\",\n \"epinard\",\n \"endive\",\n \"fenouil\",\n \"haricot vert\",\n \"haricot\",\n \"navet\",\n \"oignon\",\n \"oseille\",\n \"panais\",\n \"pâtisson\",\n \"petit pois\",\n \"poireau\",\n \"poivron\",\n \"potiron\",\n \"radis rouge\",\n \"rutabaga\",\n \"navet\",\n \"salade \",\n \"salsifis\",\n \"tomate\",\n \"topinambour\",\n \"maïs\"]","def insert(item, quantity, price):\n\n conn = sqlite3.connect(\"lite.db\")\n\n # Point to the cursor object\n cursor = conn.cursor()\n\n # Inserting a quantity\n cursor.execute(\"INSERT INTO store VALUES (?, ?, ?)\", (item, quantity, price))\n\n # Commit\n conn.commit()\n\n # Close connection\n conn.close()","def prequantize(self, linestrings, quant_factor=1e6):\n\n x0, y0, x1, y1 = geometry.MultiLineString(linestrings).bounds\n kx = 1 / ((quant_factor - 1) / (x1 - x0))\n ky = 1 / ((quant_factor - 1) / (y1 - y0))\n\n for ls in linestrings:\n ls_xy = np.array(ls.xy)\n ls_xy = (\n np.array([(ls_xy[0] - x0) / kx, (ls_xy[1] - y0) / ky])\n .T.round()\n .astype(int)\n )\n ls.coords = ls_xy[\n np.insert(np.absolute(np.diff(ls_xy, 1, axis=0)).sum(axis=1), 0, 1) != 0\n ]\n\n return kx, ky, x0, y0","def buildCurrencyDict(filename): \n currencies = {}\n with open(os.path.join(\"input\", filename), \"rt\", encoding=\"utf8\") as f:\n reader = csv.reader(f)\n for line in reader:\n currencies[line[1]] = Currency(line[1], line[0], float(line[2]))\n return currencies","def kosdaq_to_db(chunk):\n bulk_list = []\n for row in chunk:\n bulk_list.append(Kosdaq(\n date=row[0],\n close=float(row[1]),\n open=float(row[2]),\n high=float(row[3]),\n low=float(row[4]),\n volume=float(row[5]),\n d1_diff_rate=float(row[6])\n ))\n Kosdaq.objects.bulk_create(bulk_list)\n return bulk_list","def mass_fraction_conversion(cfitfile):\n # extracting the cfit file name prefix \n file_prefix = cfitfile.split('_model_fits.cfit')[0]\n\n # assigning the prefix to new files to import the normalization files corresponding to our cfit file\n gal_norm_file = file_prefix+'_off_axis_normal_fact.dat'\n model_norm_file = file_prefix+'_model_normal_fact.dat'\n masstable_file = file_prefix+'_masstable.tab'\n \n \n G = np.genfromtxt(gal_norm_file)\n all_model_norms = np.genfromtxt(model_norm_file)\n\n # Only select the normalization factors corresponding to solar metallicities ~ 0.2 \n solar_met = 0.02\n met_mask = (all_model_norms.transpose()[0,:] == solar_met) #Takes first column and selects metallicity = 0.02\n \n N_i = all_model_norms[met_mask].T[-1]\n \n # Stellar Mass Formed for each population: a_i = b_i*G/N_i , where b_i are the cfit values\n normalization_factors = G/N_i\n \n return normalization_factors","def collect_batch(self, item, quantity, kitchen=None):\n try:\n with Transaction().start(DBNAME, 1):\n item = item\n quantity = quantity\n if kitchen:\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\n , order=[('batch_number', 'ASC')])\n else:\n inventory_list = self.Inventory.search([('location', '=', self.inventory.id)]\n , order=[('batch_number', 'ASC')])\n batch_list = []\n today = date.today()\n for i in inventory_list:\n lines = i.lines\n for j in lines:\n if j.product.template.name == item:\n expiry = j.expiry_date\n if expiry:\n if expiry >= today:\n if Decimal(j.quantity) >= Decimal(quantity):\n batch_list.append([str(i.batch_number), str(quantity)])\n print [str(i.batch_number), str(quantity)]\n return batch_list\n else:\n quantity = Decimal(quantity) - Decimal(j.quantity)\n batch_list.append([str(i.batch_number), str(j.quantity)])\n print [str(i.batch_number), str(j.quantity)]\n return False\n except Exception:\n if settings.level == 10:\n logger.exception('raised exception')\n return False","def load_budgets():\n\n Budget.query.delete()\n\n with open(budget_file) as f:\n for _ in range(1):\n next(f)\n \n for row in f:\n row = row.rstrip()\n budget_data = row.split(\",\")\n id = int(budget_data[0])\n budget = budget_data[1]\n category_id = budget_data[2]\n budget_userid = budget_data[3]\n budget_start_date = budget_data[4]\n budget_end_date = budget_data[5]\n\n budget = Budget(\n id = id,\n budget = budget,\n category_id = category_id,\n budget_userid = budget_userid,\n budget_start_date = get_datetime(budget_start_date),\n budget_end_date = get_datetime(budget_end_date)\n )\n\n db.session.add(budget)\n\n db.session.commit()","def importer():\n\n #Lager liste der eg legg transaksjonar som blir henta og ikkje laga:\n get_list = []\n\n #Gjer txt-fila i mappen om til csv-fil\n file_fixer()\n\n with open(out_path) as file:\n reader = csv.reader(file)\n r_0 = next(reader)\n r_0.append(\"type\")\n r_0.append('amount')\n r_0.append('category')\n r_0.append('account')\n r_0.append('project')\n\n\n for row in reader:\n #Legger til dei fire kollonenne (amount, account, subaacount, project), tomme.\n row.append(\"\")\n row.append(\"\")\n\n #Omformatterer rader:\n row = format_fix(row)\n row.append(\"\")\n row.append(\"\")\n row.append(\"\")\n print(row)\n\n\n try:\n obj, created = Transaction.objects.get_or_create(\n date=row[0],\n transaction_type=row[1],\n description=row[2],\n amount=row[3]\n )\n\n except Transaction.MultipleObjectsReturned:\n continue\n\n if not created:\n get_list.append(obj.pk)\n\n return get_list","def fill_db(qty):\n qty = int(qty)\n click.echo('Wiping old db')\n init_db()\n click.echo('Initialized the db.')\n click.echo('Inserting {} random tasks into db.'.format(qty))\n conn = get_db()\n c = conn.cursor()\n for t in create_n_tasks(qty):\n c.execute('''\n INSERT INTO task (task_title, task_description, task_complete, task_archived)\n VALUES ('{title}', '{desc}', {complete}, {archived})'''.format(\n title=t[\"task_title\"],\n desc=t[\"task_description\"],\n complete=t[\"task_complete\"],\n archived=t[\"task_archived\"])\n )\n conn.commit()\n click.echo('Tasks inserted.')","def handle_quantity(self, line):\n #ok\n\n if line in [\"#c\", \"#C\"]:\n self.cancel_operation()\n return\n try:\n if line:\n new_qty = self.op_data['qty']\n #aqui tengo que escribir la nueva cantidad\n\n self.state = \"scan_location\"\n message = u\"Scan correcto. Scanee la ubicacion\\n\"\n message += self.get_operation_str(mode='scan_location')\n\n except Exception, e:\n str_error = u\"Error al cambiar la cantidad %s\\n\" % line\n self._snd(str_error + e.message)"],"string":"[\n \"def import_counties():\\n\\n query = 'INSERT INTO texas_counties(county, region) VALUES(%s,%s)'\\n with persistence() as db:\\n # create new cursor instance\\n cursor = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\\n\\n for council, counties in COUNCIL_DATA.items():\\n for county in counties:\\n cursor.execute(query, (county, council))\\n db.commit()\",\n \"def import_in_db(self):\\n\\n super().new_entry()\\n\\n if Categories.objects.all().count() > 0:\\n try:\\n category_compare = Categories.objects.get(\\n name=self.product_infos['compare_to']\\n )\\n except:\\n category_compare = None\\n else:\\n category_compare = None\\n\\n product_object = Products.objects.create(\\n code=self.code,\\n name=self.name,\\n url=self.product_infos['product_url'],\\n quantity=self.product_infos['quantity'],\\n country=self.product_infos['countries'],\\n ingredients=self.product_infos['ingredients'],\\n energy=self.product_infos['energy-kcal_100g'],\\n fat=self.product_infos['fat_100g'],\\n satured_fat=self.product_infos['saturated-fat_100g'],\\n carbohydrates=self.product_infos['carbohydrates_100g'],\\n sugar=self.product_infos['sugars_100g'],\\n fibers=self.product_infos['fiber_100g'],\\n proteins=self.product_infos['proteins_100g'],\\n salt=self.product_infos['salt_100g'],\\n sodium=self.product_infos['sodium_100g'],\\n nutriscore=self.product_infos['nutriscore'],\\n image_url=self.product_infos['image_url'],\\n compare_to_category=category_compare\\n )\\n\\n ProductImportation.count += 1\\n\\n return product_object\",\n \"def import_and_clean():\\n \\n with open(\\\"inventory.csv\\\", newline=\\\"\\\") as csvfile:\\n inventory = csv.DictReader(csvfile)\\n rows = list(inventory)\\n\\n for row in rows:\\n row[\\\"product_price\\\"] = row[\\\"product_price\\\"].replace(\\\"$\\\", \\\"\\\")\\n row[\\\"product_price\\\"] = row[\\\"product_price\\\"].replace(\\\".\\\", \\\"\\\")\\n row[\\\"product_price\\\"] = int(float(row[\\\"product_price\\\"]))\\n row[\\\"date_updated\\\"] = datetime.datetime.strptime(row[\\\"date_updated\\\"], \\\"%m/%d/%Y\\\")\\n row[\\\"product_quantity\\\"]= int(row[\\\"product_quantity\\\"])\\n \\n return rows\",\n \"def add_from_file(category_label, fname):\\n dirname = os.path.dirname(os.path.abspath(__file__))\\n with codecs.open(os.path.join(dirname, fname), encoding='utf-8') as stops_file:\\n for line in stops_file:\\n if line.startswith('#'):\\n continue\\n val_name, val_surface_forms = preprocess_cl_line(line)\\n for form in val_surface_forms:\\n db_add(category_label, val_name, form)\",\n \"def load_chems(self, file_name, update_mappings, chunksize=1000):\\n\\n logger.info( \\\"Loading chemicals from [{}]\\\".format(file_name) )\\n\\n csv.field_size_limit(10000000)\\n input_file = codecs.open(file_name, 'rb', 'utf-8')\\n tsvin = csv.reader(input_file, delimiter='\\\\t')\\n\\n sql_alc_conn = self.db.connect()\\n db_api_conn = sql_alc_conn.connection\\n\\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)')\\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (:1, :2, :3, :4)', self.chem_struc_types)\\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = :1 and schembl_chem_id = :2 and field = :3 and (:4 > -1)')\\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (:1, :2, :3, :4)')\\n if (\\\"cx_oracle\\\" in str(self.db.dialect)):\\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)')\\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (:1, :2, :3, :4)', self.chem_struc_types)\\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = :1 and schembl_chem_id = :2 and field = :3 and (:4 > -1)')\\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (:1, :2, :3, :4)')\\n else:\\n chem_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical (id, mol_weight, logp, med_chem_alert, is_relevant, donor_count, acceptor_count, ring_count, rot_bond_count, corpus_count) values (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)')\\n chem_struc_ins = DBBatcher(db_api_conn, 'insert into schembl_chemical_structure (schembl_chem_id, smiles, std_inchi, std_inchikey) values (%s, %s, %s, %s)', self.chem_struc_types)\\n chem_map_del = DBBatcher(db_api_conn, 'delete from schembl_document_chemistry where schembl_doc_id = %s and schembl_chem_id = %s and field = %s and (%s > -1)')\\n chem_map_ins = DBBatcher(db_api_conn, 'insert into schembl_document_chemistry (schembl_doc_id, schembl_chem_id, field, frequency) values (%s, %s, %s, %s)')\\n\\n\\n chunk = []\\n\\n # Process input records, in chunks\\n for i, row in enumerate(tsvin):\\n\\n if (i == 0) and row[0] == 'SCPN':\\n if row != self.CHEM_HEADER_ROW:\\n raise RuntimeError(\\\"Malformed header detected in chemical data file\\\")\\n continue\\n\\n if (i % chunksize == 0 and i > 0):\\n logger.debug( \\\"Processing chem-mapping data to index {}\\\".format(i) )\\n self._process_chem_rows(sql_alc_conn, update_mappings, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, chunk)\\n del chunk[:]\\n\\n chunk.append(row)\\n\\n logger.debug( \\\"Processing chem-mapping data to index {} (final)\\\".format(i) )\\n self._process_chem_rows(sql_alc_conn, update_mappings, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, chunk)\\n\\n # Clean up resources\\n chem_ins.close()\\n chem_struc_ins.close()\\n chem_map_del.close()\\n chem_map_ins.close()\\n\\n sql_alc_conn.close()\\n input_file.close()\\n\\n logger.info(\\\"Chemical import completed\\\" )\",\n \"def importItem(file_path):\\n\\n #Ouverture du fichier\\n rb = open_workbook(file_path)\\n r_sheet = rb.sheet_by_index(0)\\n\\n for row_index in range (1, r_sheet.nrows):\\n #Hydratation or get Supplier Model\\n item_supplier= r_sheet.cell(row_index, 4).value\\n item_supplier, created = Supplier.objects.get_or_create(name=item_supplier)\\n\\n #Hydratation or get Category Model\\n current_category = r_sheet.cell(row_index, 0).value\\n item_category, created = Category.objects.get_or_create(name=current_category)\\n\\n #Hydratation Item\\n item_name = r_sheet.cell(row_index, 1).value\\n item_ref = current_supplier= r_sheet.cell(row_index, 3).value\\n item_quantity = r_sheet.cell(row_index, 2).value\\n item, created = Item.objects.get_or_create(ref=item_ref, name=item_name, category=item_category, supplier=item_supplier, quantity=item_quantity)\",\n \"def importDatabase(self):\\n db_conn.execute(\\\"INSERT INTO Fietsenstalling (Naam, Achternaam, Telefoon, FietsNr, PIN) VALUES \\\"\\n \\\"(?, ?, ?, ?, ?);\\\", (naamInvoer.get(), achternaamInvoer.get(), telefoonnummerInvoer.get(), FietsNr, pincodeInvoer.get()))\\n\\n db_conn.commit()\",\n \"def add_filters(fnames):\\n with Database(writable=True) as base:\\n for fname in fnames:\\n with open(fname, 'r') as f_fname:\\n filter_name = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_type = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_description = f_fname.readline().strip('# \\\\n\\\\t')\\n filter_table = np.genfromtxt(fname)\\n # The table is transposed to have table[0] containing the\\n # wavelength and table[1] containing the transmission.\\n filter_table = filter_table.transpose()\\n # We convert the wavelength from Å to nm.\\n filter_table[0] *= 0.1\\n\\n print(\\\"Importing {}... ({} points)\\\".format(filter_name,\\n filter_table.shape[1]))\\n\\n new_filter = Filter(filter_name, filter_description, filter_type,\\n filter_table)\\n\\n # We normalise the filter and compute the effective wavelength.\\n # If the filter is a pseudo-filter used to compute line fluxes, it\\n # should not be normalised.\\n if not filter_name.startswith('PSEUDO'):\\n new_filter.normalise()\\n else:\\n new_filter.effective_wavelength = np.mean(\\n filter_table[0][filter_table[1] > 0]\\n )\\n\\n base.add_filter(new_filter)\",\n \"def load_products():\\n\\n print \\\"Loading Products\\\"\\n\\n for i, row in enumerate(open(\\\"data/mock_product_data.csv\\\")):\\n row = row.rstrip()\\n title, price, inventory = row.split(\\\",\\\")\\n\\n product = Product(title=title,\\n price=price,\\n available_inventory=inventory)\\n\\n db.session.add(product)\\n\\n db.session.commit()\",\n \"def import_prices(self):\\n temp = dict(self.currencies_and_regions)\\n for index, row in self.df.iterrows():\\n self.set_mini_bundle_name(row[\\\"Journal Name \\\"])\\n self.set_issns(row[\\\"ISSN\\\"])\\n self.set_currency(row[\\\"Currency\\\"])\\n if not self.currency:\\n continue\\n cur = self.get_raw_currency(row[\\\"Currency\\\"])\\n region = temp[cur]\\n self.set_region(region)\\n self.set_country(region)\\n self.set_price(row[\\\"2021 rate\\\"])\\n self.add_prices()\\n\\n # reset for next loop\\n self.issns = []\\n db.session.commit()\",\n \"def import_file(some_genbank, collection):\\n with open(some_genbank, 'r') as open_file:\\n collection = kv.get_collection(collection)\\n\\n # Each \\\"record\\\" in genbank file is read, corresponds to individual contigs\\n for record in SeqIO.parse(open_file, 'gb'):\\n current_contig = record.name\\n try:\\n current_species = record.annotations['source']\\n except KeyError:\\n name = re.search(r'\\\\w+\\\\/(.+)\\\\.\\\\w+$', some_genbank)\\n current_species = name.group(1)\\n \\n\\n collection.insert_one({\\n 'species':current_species,\\n 'contig':current_contig,\\n 'dna_seq':str(record.seq),\\n 'type':'contig'\\n })\\n\\n print \\\"Importing {}\\\".format(current_contig)\\n ssu_gene = get_16S(record)\\n if ssu_gene:\\n try:\\n locus_tag = ssu_gene[0].qualifiers['locus_tag'][0]\\n except KeyError:\\n locus_tag = None\\n \\n parsed_location = kv.get_gene_location(ssu_gene[0].location)\\n gene_record = {\\n 'species':current_species,\\n 'location':{\\n 'contig':current_contig,\\n 'start':parsed_location[0],\\n 'end':parsed_location[1],\\n 'strand':parsed_location[2],\\n },\\n 'locus_tag':locus_tag,\\n 'annotation':ssu_gene[0].qualifiers['product'][0],\\n 'dna_seq':ssu_gene[1],\\n 'type':'16S'\\n }\\n print \\\"adding 16S gene!\\\"\\n collection.insert_one(gene_record)\\n kv.get_collection('16S').insert_one(gene_record)\\n\\n for feature in record.features:\\n if feature.type == 'CDS':\\n parsed_location = kv.get_gene_location(feature.location)\\n try:\\n locus_tag = feature.qualifiers['locus_tag'][0]\\n except KeyError:\\n locus_tag = None\\n\\n gene_record = {\\n 'species':current_species,\\n 'location':{\\n 'contig':current_contig,\\n 'start':parsed_location[0],\\n 'end':parsed_location[1],\\n 'strand':parsed_location[2],\\n 'index':None\\n },\\n 'locus_tag':locus_tag,\\n 'annotation':feature.qualifiers['product'][0],\\n 'dna_seq':get_dna_seq(feature, record),\\n 'aa_seq':feature.qualifiers['translation'][0],\\n 'type':'gene'\\n }\\n collection.insert_one(gene_record)\",\n \"def add_to_cart(db, itemid, quantity):\",\n \"def push_to_cartodb(f):\\n print \\\"attempting to import into cartodb\\\"\\n config = loadConfig()\\n cl = CartoDBAPIKey(config[\\\"API_KEY\\\"],config[\\\"user\\\"])\\n fi = FileImport(f,cl,table_name='python_table_test')\\n fi.run()\\n\\n return fi.success\",\n \"def load_inventory(file_name, table):\\r\\n try:\\r\\n with open(file_name, 'r') as objFile:\\r\\n for line in objFile:\\r\\n data = line.strip().split(',')\\r\\n cd = CD(int(data[0]),data[1],data[2])\\r\\n table.append(cd)\\r\\n print(\\\"{} successfully loaded!\\\".format(file_name))\\r\\n except FileNotFoundError:\\r\\n print(\\\"Could not load {}\\\".format(file_name))\\r\\n return table\",\n \"def load_categories():\\n\\n Category.query.delete()\\n\\n with open(category_file) as f:\\n for _ in range(1):\\n next(f)\\n \\n for row in f:\\n row = row.rstrip()\\n categories_data = row.split(\\\",\\\")\\n\\n id = int(categories_data[0])\\n category = categories_data[1]\\n\\n category_model = Category(id=id, category=category)\\n db.session.add(category_model)\\n db.session.commit()\",\n \"def import_prices(self):\\n temp = dict(self.currencies_and_regions)\\n for index, row in self.df.iterrows():\\n self.set_journal_name(row[\\\"Journal Name \\\"])\\n self.set_issn(row[\\\"ISSN\\\"])\\n self.set_journal()\\n self.set_currency(row[\\\"Currency\\\"])\\n if not self.currency:\\n continue\\n cur = self.get_raw_currency(row[\\\"Currency\\\"])\\n region = temp[cur]\\n self.set_region(region)\\n self.set_country(region)\\n self.process_fte(row[\\\"Price Group\\\"])\\n self.set_price(row[\\\"2021 rate\\\"])\\n self.add_price_to_db()\\n\\n db.session.commit()\",\n \"def import_product_data(directory_name, product_file):\\n\\n start = time.time()\\n\\n mongo = MongoDBConnection()\\n\\n with mongo:\\n LOGGER.info(\\\"Establishing MongoDB connection\\\")\\n database = mongo.connection.storeDB\\n\\n LOGGER.info(\\\"Establishing databases\\\")\\n products = database[\\\"products\\\"]\\n initial_entries = database.products.count_documents({})\\n\\n #entry counts\\n added_entries = 0\\n\\n with open(os.path.join(directory_name, product_file)) as csv_file:\\n\\n product_data = csv.reader(csv_file, delimiter=\\\",\\\")\\n for entry in product_data:\\n try:\\n product_entry = {\\\"product_id\\\":entry[0],\\n \\\"description\\\":entry[1],\\n \\\"product_type\\\":entry[2],\\n \\\"quantity_available\\\":entry[3]}\\n products.insert_one(product_entry)\\n added_entries += 1\\n LOGGER.info(f\\\"Added {entry[0]} to product database\\\")\\n except peewee.IntegrityError:\\n LOGGER.info(f\\\"Error adding {entry[0]} to product database\\\")\\n\\n final_entries = database.products.count_documents({})\\n\\n return((initial_entries, added_entries, final_entries,\\n (time.time() - start)))\",\n \"def get_counties():\\n\\n for i, row in enumerate(open('data/counties_data.csv')):\\n data = row.rstrip().split(\\\",\\\")\\n county_name, latitude, longitude, county_name_lower = data\\n\\n county = County(county_name=county_name, latitude=latitude, longitude=longitude, county_name_lower=county_name_lower)\\n\\n db.session.add(county)\\n\\n if i % 100 == 0:\\n print(i)\\n\\n db.session.commit()\",\n \"def _pre_featurize(self, systems: Iterable[ProteinLigandComplex]) -> None:\\n self._create_klifs_structure_db(retrieve_pocket_resids=True)\\n self._create_klifs_kinase_db()\\n self._create_ligand_smiles_dict()\\n if self.shape_overlay:\\n self._dowload_klifs_ligands()\\n return\",\n \"def insert_to_database(self, db):\\n \\n self.remove_bad_characters()\\n print(\\\"Inserting \\\"+self.categorie_name+\\\" to database.\\\")\\n db.query(\\\"INSERT INTO categorie (categorie_name) VALUES (:categorie_name)\\\", \\\\\\n categorie_name=self.categorie_name)\",\n \"def load_database(self, fsp='Species'):\\n self.df_species = pd.read_csv(fsp + '.csv', header=0,\\n index_col=0)\",\n \"def load_data_to_db(self, path):\\n table_names = ['train_transaction', 'train_identity', 'test_transaction', 'test_identity']\\n for table_name in table_names:\\n pat = self.TRANSACTION_NON_NUMBER_PATTERN if 'transaction' in table_name else self.IDENTITY_NON_NUMBER_PATTERN\\n print(\\\"Loading table: \\\" + table_name)\\n fn = os.path.join(path, table_name + '.csv')\\n self.dbinstance.build_table_from_csv(fn, pat, table_name)\\n print(\\\"Loaded table \\\" + table_name)\",\n \"def add_meta_f_to_db(meta_f, p, dbi):\\n rism_attributes = sd.Water3DRISM.__dict__.keys()\\n extra_attributes = sd.Water3DRISMExtra.__dict__.keys()\\n with open(os.path.join(p, meta_f), 'rb') as f:\\n txt = f.readlines()\\n inchi_line = txt[0]\\n if inchi_line.startswith('InChI'):\\n print inchi_line\\n _, inchi = inchi_line.split(', ')\\n inchi = inchi.strip()\\n dbmol = dbi.get_molecule(inchi)\\n rism = sd.Water3DRISM()\\n rism_extra = sd.Water3DRISMExtra()\\n else:\\n raise ValueError('dbf file must start with InChI, <inchi code>')\\n for line in txt[1:]:\\n if ',' in line:\\n line_l = line.split(', ')\\n name = line_l[0].strip()\\n values = map(lambda x: x.strip(), line_l[1:])\\n if len(line_l) == 2:\\n if name in rism_attributes:\\n rism.__setattr__(name, values[0])\\n elif name in extra_attributes:\\n if name == 'UCorrMult':\\n rism_extra.__setattr__(name, values[0])\\n else:\\n with open(os.path.join(p, values[0]), 'rb') as f:\\n value = f.read()\\n rism_extra.__setattr__(name, value)\\n elif len(line_l) == 4:\\n rism_therm = sd.ThermodynamicOutput(Property=name)\\n if values[0] != '-':\\n rism_therm.TotalValue = values[0]\\n if values[1] != '-':\\n rism_therm.OContrib = values[1]\\n if values[2] != '-':\\n rism_therm.HContrib = values[2]\\n rism.ThermOut.append(rism_therm)\\n else:\\n print 'Unknown attribute: {}'.format(name)\\n rism.Extra = rism_extra\\n dbmol.RISMCalcs.append(rism)\\n dbi.add_molecule(dbmol)\\n print 'Added molecule {}'.format(dbmol)\",\n \"def import_fusion_archive(filename, name=\\\"import\\\"):\\n import_options = app().importManager.createFusionArchiveImportOptions(filename)\\n\\n document = app().importManager.importToNewDocument(import_options)\\n imported_root = document.products[0].rootComponent\\n\\n bodies = []\\n\\n for body in imported_root.bRepBodies:\\n bodies.append(brep().copy(body))\\n for occurrence in imported_root.allOccurrences:\\n for body in occurrence.bRepBodies:\\n bodies.append(brep().copy(body))\\n\\n document.close(saveChanges=False)\\n\\n return BRepComponent(*bodies, name=name)\",\n \"def creatingItemSets(self, iFileName):\\n # import pandas as pd\\n # global Database\\n self.Database = []\\n lineNumber = 0\\n # data = []\\n if isinstance(iFileName, list):\\n self.Database = iFileName\\n if isinstance(iFileName, pd.DataFrame):\\n if iFileName.empty:\\n print(\\\"its empty..\\\")\\n quit()\\n i = iFileName.columns.values.tolist()\\n if 'Transactions' in i:\\n self.Database = iFileName['Transactions'].tolist()\\n if 'Patterns' in i:\\n self.Database = iFileName['Patterns'].tolist()\\n\\n if '.CSV' in iFileName:\\n file1 = pd.read_csv(iFileName)\\n columns = list(file1.head(0))\\n if \\\"Patterns\\\" in columns:\\n with open(iFileName, newline='') as csvFile:\\n data = csv.DictReader(csvFile)\\n for row in data:\\n listValue = row['Patterns']\\n l1 = listValue.replace(\\\"[\\\", \\\"\\\")\\n l2 = l1.replace(\\\"]\\\", \\\"\\\")\\n li = list(l2.split(\\\",\\\"))\\n li1 = [int(i) for i in li]\\n self.Database.append(li1)\\n if \\\"Transactions\\\" in columns:\\n with open(iFileName, newline='') as csvFile:\\n data = csv.DictReader(csvFile)\\n for row in data:\\n listValue = row['Transactions']\\n l1 = listValue.replace(\\\"[\\\", \\\"\\\")\\n l2 = l1.replace(\\\"]\\\", \\\"\\\")\\n li = list(l2.split(\\\",\\\"))\\n li1 = [int(i) for i in li]\\n self.Database.append(li1)\\n else:\\n try:\\n with open(iFileName, 'r', encoding='utf-8') as f:\\n for line in f:\\n # line.strip()\\n if lineNumber == 0:\\n lineNumber += 1\\n delimiter = self.findDelimiter([*line])\\n # li=[lineNumber]\\n li = line.split(delimiter)\\n li1 = [i.rstrip() for i in li]\\n self.Database.append([i.rstrip() for i in li1])\\n # else:\\n # self.Database.append(li)\\n # data.append([lineNumber,li1])\\n else:\\n lineNumber += 1\\n li = line.split(delimiter)\\n # if delimiter==',':\\n li1 = [i.rstrip() for i in li]\\n self.Database.append(li1)\\n except IOError:\\n print(\\\"File Not Found\\\")\\n quit()\\n\\n # else:\\n # self.Database=iFileName['Transactions'].tolist()\",\n \"def importFile(self):\\n\\n ## Backing up old CSV and JSON files before beginning import operations\\n if os.path.isfile(\\\"text_files/customers.csv\\\") and os.path.isfile(\\\"text_files/customers.json\\\"):\\n print(\\\"\\\\nCreating a backup of the existing customer .csv and .json files before overwriting\\\")\\n shutil.copy2(\\\"text_files/customers.csv\\\", \\\"text_files/customers.csv.backup\\\" + str(time.time()))\\n shutil.copy2(\\\"text_files/customers.json\\\", \\\"text_files/customers.json.backup\\\" + str(time.time()))\\n\\n ## Importing the text file for cleaning then converting to CSV\\n input_file = open(\\\"text_files/customer_export.txt\\\", \\\"r\\\")\\n output_file = open(\\\"text_files/customers.csv\\\", \\\"w\\\")\\n\\n ## A loop to clean and write the customer_export txt file to a CSV\\n for line in input_file:\\n clean_text = \\\"\\\"\\n check_line = line.replace(\\\"#\\\", \\\"\\\").replace(\\\",,\\\",\\\"\\\").split(\\\"|\\\")\\n for line in check_line:\\n if line != check_line[10]:\\n clean_text += line + \\\",\\\"\\n elif line == check_line[10]:\\n clean_text += line + \\\"\\\\n\\\"\\n output_file.write(clean_text)\\n\\n ## Closing TXT file and CSV file after formatting\\n input_file.close()\\n output_file.close()\\n\\n ## Opening the cleaned CSV file for conversion to Json\\n with open('text_files/customers.csv') as clean_csv:\\n ## Converting CSV file to Json\\n converted = csv.DictReader(clean_csv)\\n rows = list(converted)\\n\\n ## Writing converted CSV to Json file\\n with open('text_files/customers.json', 'w') as convert:\\n json.dump(rows, convert)\\n\\n ## Deleting all data currently in database before importing new file\\n db_connection.executeQuery(\\\"DELETE FROM CRM;DBCC CHECKIDENT ('CRM', RESEED, 0) DELETE FROM Mailings; DBCC CHECKIDENT ('Mailings', RESEED, 0) COMMIT\\\") \\n\\n ## Loading the newly created Json file\\n with open(\\\"text_files/customers.json\\\") as customers_json:\\n customers = json.load(customers_json)\\n\\n ## A loop to add the contents of the Json file to the database \\n print(\\\"Writing imported file to database please wait...\\\")\\n for key in customers:\\n db_connection.executeQuery(\\\"INSERT INTO dbo.CRM (f_name, l_name, company, address, city, county, state, zip, primary_phone, secondary_phone, email_address) VALUES ('\\\" + key[\\\"first_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"last_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"company_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"address\\\"] + \\\"', '\\\" + key[\\\"city\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"county\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"state\\\"] + \\\"', '\\\" + str(key[\\\"zip\\\"]) + \\\"', '\\\" + key[\\\"phone1\\\"] + \\\"', '\\\" + key[\\\"phone2\\\"] + \\\"' , '\\\" + key[\\\"email\\\"] + \\\"'); COMMIT\\\")\\n db_connection.executeQuery(\\\"INSERT INTO dbo.Mailings (name, company, address) VALUES ('\\\" + key[\\\"first_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\" \\\" + key[\\\"last_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"company_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"','\\\" + key[\\\"address\\\"] + \\\" \\\" + key[\\\"city\\\"] + \\\" \\\" + key[\\\"county\\\"] + \\\" \\\" + key[\\\"state\\\"] + \\\" \\\" + str(key[\\\"zip\\\"]) + \\\"'); COMMIT\\\") \\n\\n print(\\\"\\\\nFinished writing to file. Returning to main menu...\\\")\",\n \"def populate_t_database():\\n with open('minerals.json') as file:\\n file = json.loads(file.read())\\n\\n for mineral in file[:22]:\\n mineral_entry = Mineral.objects.get_or_create(**mineral)\",\n \"def add_imported(products):\\n \\n for product in products:\\n add_product(product[\\\"product_name\\\"], product[\\\"product_quantity\\\"], product[\\\"product_price\\\"], product[\\\"date_updated\\\"])\",\n \"def migrate_to_db(self, source, items_per_cat):\\n data = self.fetch(source, items_per_cat)\\n data = self.__attach_source(data, source)\\n logger.debug('Migrating %d items to DB', len(data))\\n self.repository.write(data)\",\n \"def full_load_db_from_file(batch_size=10000):\\n\\n q_set = QuestionSet(load=True)\\n with open('.config/config.json', 'r') as f:\\n config = json.load(f)\\n config = config['pg']\\n\\n conn = psycopg2.connect(\\n host=config['host'],\\n database=config['db'],\\n user=config['user'],\\n password=config['password'],\\n )\\n\\n i, values = 0, []\\n for q in q_set.questions_ordered:\\n values.append((\\n q.id,\\n q.question,\\n q.options,\\n q.answer,\\n q.category_id,\\n ))\\n i += 1\\n\\n cur = conn.cursor()\\n cur.execute('TRUNCATE TABLE questions')\\n query = \\\"\\\"\\\"\\n INSERT INTO questions (id, question, options, answer, category_id)\\n VALUES {}\\n \\\"\\\"\\\"\\n\\n j = 0\\n log.info(\\\"Writing {} questions to DB...\\\".format(i))\\n for chunk in chunks(values, batch_size):\\n log.info('Batch {}...'.format(j + 1))\\n j += 1\\n\\n args = ','.join(cur.mogrify(\\\"(%s, %s, %s, %s, %s)\\\", v).decode(\\\"utf-8\\\") for v in chunk)\\n cur.execute(query.format(args))\\n conn.commit()\\n\\n log.info(\\\"Data transfer complete.\\\")\\n cur.close()\",\n \"def insert_into_solr(filepath):\\n #filepath = '/vol1/mag/data/2018-07-19/dumps/PaperCitationContexts.txt'\\n record_number = 0\\n list_for_solr = []\\n with open(filepath, \\\"r\\\") as file:\\n # THERE ARE NULL BYTES WHICH MAKE CSV THROW AN ERROR. Replace them \\n csv_reader = csv.reader((line.replace('\\\\0', '') for line in file), delimiter='\\\\t', quoting=csv.QUOTE_NONE)\\n for paper_id, paper_reference_id, citation_context in csv_reader:\\n #for record in csv_reader:\\n #paper_id, paper_reference_id, citation_context = record\\n record_number += 1\\n solr_record = {}\\n solr_record['paper_id'] = paper_id\\n solr_record['paper_reference_id'] = paper_reference_id\\n solr_record['citation_context'] = citation_context\\n # Chunks of 500000\\n if record_number % 25000 == 0:\\n list_for_solr.append(solr_record)\\n try:\\n solr.add(list_for_solr)\\n except Exception as e:\\n print(e, record_number, filepath)\\n list_for_solr = []\\n print(record_number)\\n else:\\n list_for_solr.append(solr_record)\\n #print(record_number)\\n try:\\n solr.add(list_for_solr)\\n except Exception as e:\\n print(e, record_number, filepath)\",\n \"def insert_data_from_file(self, filename):\\n self.get_cursor()\\n ct = len([True for c in self.table.columns if c[1][0][:3] == \\\"ct-\\\"]) != 0\\n if (([self.table.cleanup.function, self.table.delimiter,\\n self.table.header_rows] == [no_cleanup, \\\",\\\", 1])\\n and not self.table.fixed_width\\n and not ct\\n and (not hasattr(self.table, \\\"do_not_bulk_insert\\\") or not self.table.do_not_bulk_insert)):\\n columns = self.table.get_insert_columns()\\n filename = os.path.abspath(filename)\\n statement = \\\"\\\"\\\"\\nCOPY \\\"\\\"\\\" + self.table_name() + \\\" (\\\" + columns + \\\"\\\"\\\")\\nFROM '\\\"\\\"\\\" + filename.replace(\\\"\\\\\\\\\\\", \\\"\\\\\\\\\\\\\\\\\\\") + \\\"\\\"\\\"'\\nWITH DELIMITER ','\\nCSV HEADER;\\\"\\\"\\\"\\n try:\\n self.execute(\\\"BEGIN\\\")\\n self.execute(statement)\\n self.execute(\\\"COMMIT\\\")\\n except:\\n self.connection.rollback()\\n return Engine.insert_data_from_file(self, filename)\\n else:\\n return Engine.insert_data_from_file(self, filename)\",\n \"def discogsImport (discogs_folder):\\n\\n # Set collection \\n collection = user.collection_folders\\n\\n # Populate import table\\n for album in collection[discogs_folder].releases:\\n query = None\\n\\n # Concatenate notes\\n hashing_note = None\\n if album.notes != None:\\n for idx in range(len(album.notes)):\\n hashing_note = str(hashing_note) + str(album.notes[idx]['field_id']) + str(album.notes[idx]['value'])\\n\\n # Hash the notes\\n notes_chksum = hashNotes(hashing_note)\\n\\n # Query instance table for instance\\n db_instance = dbq.exec_db_query_dict(dbq.get_instance_info, album.instance_id)\\n\\n # New items\\n if db_instance == None:\\n\\n # Build insert data\\n query_data = {'instance_id': album.instance_id,\\n 'rating': album.rating,\\n 'title': album.release.title,\\n 'folder_id': album.folder_id,\\n 'discogs_date_added': album.date_added,\\n 'notes': str(album.notes),\\n 'notes_chksum': notes_chksum.hexdigest(),\\n 'release_id': album.id, \\n 'insert_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\\n query = dbq.add_instance\\n dbq.exec_db_query(query, query_data, query_type='insert')\\n\\n # Test for existing and changed\\n elif db_instance['instance_id'] == album.instance_id and \\\\\\n (db_instance['notes_chksum'] != notes_chksum.hexdigest() or \\n db_instance['folder_id'] != album.folder_id or \\n db_instance['release_id'] != album.id ):\\n\\n # Update notes if hash is different\\n if db_instance['notes_chksum'] != notes_chksum.hexdigest():\\n query_data = {'notes': str(album.notes),\\n 'notes_chksum': notes_chksum.hexdigest(),\\n 'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), \\n 'instance_id': album.instance_id, \\n 'release_id': album.id}\\n query = dbq.update_instance_notes_chksum\\n dbq.exec_db_query(query, query_data, query_type='insert')\\n\\n # Update folder id\\n if db_instance['folder_id'] != album.folder_id:\\n query_data = {'folder_id': album.folder_id,\\n 'update_date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), \\n 'instance_id': album.instance_id}\\n query = dbq.update_instance_folder_id\\n dbq.exec_db_query(query, query_data, query_type='insert')\\n \\n if db_instance['release_id'] != album.id:\\n query_data = {'release_id': album.id, \\n 'instance_id': album.instance_id}\\n query = dbq.update_instance_release_id\\n dbq.exec_db_query(query, query_data, query_type='insert')\",\n \"def load_categories():\\n\\n print('load_categories')\\n\\n Category.query.delete()\\n\\n for row in open(\\\"seed_data/categories.csv\\\"):\\n name = row.rstrip()\\n\\n cat = Category(name=name)\\n\\n db.session.add(cat)\\n\\n db.session.commit()\",\n \"def load_products():\\n\\n for i, row in enumerate(open(\\\"seed_data/category.product\\\")):\\n row = row.rstrip()\\n name = row.split(\\\"|\\\")\\n product_category = ProductCategoryModel(name=name)\\n db.session.add(product_category)\\n\\n for i, row in enumerate(open(\\\"seed_data/product.product\\\")):\\n row = row.rstrip()\\n name, short_description, long_description, product_category_id, img_path_xs, img_path_sm, img_path_md, img_path_lg = row.split(\\\"|\\\")\\n product = ProductModel(name=name,\\n short_description=short_description,\\n long_description=long_description,\\n product_category_id=product_category_id,\\n img_path_xs=img_path_xs,\\n img_path_sm=img_path_sm,\\n img_path_md=img_path_md,\\n img_path_lg=img_path_lg)\\n db.session.add(product)\\n\\n for i, row in enumerate(open(\\\"seed_data/location.product\\\")):\\n row = row.rstrip()\\n name, description, address1, address2, city, state, zip_code, country, latitude, longitude, direction_url = row.split(\\\"|\\\")\\n location = LocationModel(name=name,\\n description=description,\\n address1=address1,\\n address2=address2,\\n city=city,\\n state=state,\\n zip_code=zip_code,\\n country=country,\\n latitude=latitude,\\n longitude=longitude,\\n direction_url=direction_url)\\n db.session.add(location)\\n\\n for i, row in enumerate(open(\\\"seed_data/location_product.product\\\")):\\n row = row.rstrip()\\n location_id, product_id, price, num_available = row.split(\\\"|\\\")\\n location_product = LocationProductModel(location_id=location_id,\\n product_id=product_id,\\n price=price,\\n num_available=num_available)\\n db.session.add(location_product)\\n\\n db.session.commit()\",\n \"def _pre_featurize(self, systems: Iterable[ProteinSystem]) -> None:\\n self._create_klifs_structure_db()\\n self._create_klifs_kinase_db()\\n return\",\n \"def update_database(path=None, **kwargs):\\n mindf = pd.read_csv(pyrolite_datafolder(subfolder=\\\"mineral\\\") / \\\"mins.csv\\\")\\n mindf = mindf.reindex(\\n columns=mindf.columns.tolist()\\n + [str(a) for a in pt.formula(\\\" \\\".join(list(mindf.formula.values))).atoms]\\n )\\n for ix in mindf.index: # add elemental compositions\\n el = parse_composition(pt.formula(mindf.loc[ix, \\\"formula\\\"]))\\n mindf.loc[ix, el.index] = el\\n\\n mindf = mindf.fillna(0.0)\\n\\n if path is None:\\n path = __dbpath__\\n\\n path = Path(path).with_suffix(\\\".json\\\")\\n\\n # name group formula composition\\n # needs write access\\n with TinyDB(str(path)) as db:\\n db.truncate()\\n for k, v in mindf.T.to_dict().items():\\n db.insert(v)\",\n \"def create(cls, user, quant_process, water, plate_name, total_vol=3500,\\n ng=5, min_vol=2.5, max_vol=3500, resolution=2.5,\\n reformat=False):\\n with sql_connection.TRN as TRN:\\n # Add the row to the process table\\n process_id = cls._common_creation_steps(user)\\n\\n # Add the row to the normalization_process tables\\n sql = \\\"\\\"\\\"INSERT INTO qiita.normalization_process\\n (process_id, quantitation_process_id, water_lot_id)\\n VALUES (%s, %s, %s)\\n RETURNING normalization_process_id\\\"\\\"\\\"\\n TRN.add(sql, [process_id, quant_process.id, water.id])\\n instance = cls(TRN.execute_fetchlast())\\n\\n # Retrieve all the concentration values\\n concs = quant_process.concentrations\\n # Transform the concentrations to a numpy array\\n np_conc = np.asarray([raw_con for _, raw_con, _ in concs])\\n dna_v = NormalizationProcess._calculate_norm_vol(\\n np_conc, ng, min_vol, max_vol, resolution)\\n water_v = total_vol - dna_v\\n\\n # Create the plate. 3 -> 384-well plate\\n plate_config = plate_module.PlateConfiguration(3)\\n plate = plate_module.Plate.create(plate_name, plate_config)\\n for (comp, _, _), dna_vol, water_vol in zip(concs, dna_v, water_v):\\n comp_well = comp.container\\n row = comp_well.row\\n column = comp_well.column\\n\\n if reformat:\\n row = row - 1\\n column = column - 1\\n\\n roffset = row % 2\\n row = int(row - roffset + np.floor(column / 12)) + 1\\n\\n coffset = column % 2 + (row % 2) * 2\\n column = int(coffset * 6 + (column / 2) % 6) + 1\\n\\n well = container_module.Well.create(\\n plate, instance, total_vol, row, column)\\n composition_module.NormalizedGDNAComposition.create(\\n instance, well, total_vol, comp, dna_vol, water_vol)\\n\\n return instance\",\n \"def load_stock(self):\\n lines = []\\n with Transaction().start(DBNAME, 1):\\n stock_lines = self.Inventory.search([('state', '=', 'done'), ('location', '=', self.location.id)])\\n if stock_lines:\\n for i in stock_lines:\\n batch = i.batch_number\\n for j in i.lines:\\n if j.quantity <= 0:\\n continue\\n dictionary = {}\\n dictionary['code'] = j.product.code\\n dictionary['item'] = j.product.template.name\\n dictionary[\\n 'category'] = j.product.template.category.name if j.product.template.category else None\\n dictionary['quantity'] = Decimal(j.quantity).quantize(Decimal('0.11')).to_eng()\\n dictionary['batch_number'] = batch\\n dictionary['supplier'] = j.supplier.name if j.supplier else None\\n dictionary['expiry_date'] = j.expiry_date.strftime('%d-%m-%Y') if j.expiry_date else None\\n lines.append(dictionary)\\n return lines\",\n \"def load_expenditures():\\n\\n Expenditure.query.delete()\\n\\n with open(expenditure_file) as f:\\n for _ in range(1):\\n next(f)\\n \\n for row in f:\\n row = row.rstrip()\\n expenditure_data = row.split(\\\",\\\")\\n print(expenditure_data)\\n\\n id = expenditure_data[0]\\n category_id = expenditure_data[1]\\n price = expenditure_data[2]\\n date_of_expenditure = expenditure_data[3]\\n expenditure_userid = expenditure_data[4]\\n where_bought = expenditure_data[5]\\n description = expenditure_data[6]\\n\\n expenditure = Expenditure(\\n id = id,\\n category_id = category_id,\\n price = price,\\n date_of_expenditure = get_datetime(date_of_expenditure),\\n expenditure_userid = expenditure_userid,\\n where_bought = where_bought,\\n description = description\\n )\\n\\n db.session.add(expenditure)\\n\\n db.session.commit()\",\n \"def run(self):\\n lineage_csv_gz = self.input_files_local[0][0]\\n output_db = self.output_files_local()[0]\\n log.write(f\\\"input: {lineage_csv_gz} output: {output_db}\\\")\\n\\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\\n batch_list = {}\\n with gzip.open(lineage_csv_gz, \\\"rt\\\") as gzf:\\n for line in gzf:\\n fields = line.rstrip().split(\\\",\\\")\\n taxid = fields[0]\\n species, genus, family = fields[-1:-4:-1]\\n batch_list[taxid] = [species, genus, family]\\n if len(batch_list) >= BATCH_INSERT_SIZE:\\n lineage_dict.batch_inserts(batch_list.items())\\n batch_list = {}\\n lineage_dict.batch_inserts(batch_list.items())\",\n \"def load_birds():\\n\\n for i, row in enumerate(open('seed_data/species.csv')):\\n data = row.rstrip().split(\\\",\\\")\\n common_name, species_code = data\\n\\n bird = Species(common_name=common_name,\\n species_code=species_code)\\n\\n db.session.add(bird)\\n\\n # For testing, just to see it was happening\\n if i % 100 == 0:\\n print i\\n\\n db.session.commit()\",\n \"def _from_catalog(self):\\n if self.dbconn.version < 90100:\\n return\\n for ext in self.fetch():\\n self[ext.key()] = ext\",\n \"def create_table_country(db, f):\\n # connect to the database and create a cursor\\n\\n # drop the table if it already exists; re-create it\\n\\n # Populate the StatelessCountByRegion Table\\n # Loop through each line in the file:\\n # for line in f:\\n # Write the body of this loop yourself. Handle the whitespace around\\n # each line, split each line on SEP, and insert the relevant values\\n # into the table.\\n # Hint: line.strip().split(SEP) will return you a list.\\n\\n # don't forget to close the cursor, commit the changes and close\\n # the connection\",\n \"def from_csv_to_database():\\r\\n for year, path in FileNamePath.items():\\r\\n # load csv files\\r\\n with open(path, encoding='cp1251') as dataset:\\r\\n print(f\\\"Download {year} data\\\")\\r\\n get_curr_data(dataset, year)\",\n \"def read_extras(self, f):\\n\\n gb = f[\\\"base state\\\"]\\n for name in gb:\\n self.base[name] = Basestate(self.cc_data.grid.ny, ng=self.cc_data.grid.ng)\\n self.base[name].d[:] = gb[name]\",\n \"def __init__(self, species, qty, country_code):\\n super(InternationalMelonOrder, self).__init__(species, qty, \\\"international\\\", 0.17, country_code)\",\n \"def load_initial_packing_folding_rate(matrix: list):\\n print(\\\"Start loading...\\\")\\n\\n # delete all existed records\\n models.PackingFoldingRate.objects.all().delete()\\n\\n # row index\\n index = len(matrix)\\n for row in matrix[1:]:\\n packing_type = row[0].strip()\\n folding_rate = row[1]\\n\\n t = models.PackingFoldingRate(\\n packing_type=packing_type.upper(),\\n folding_rate=folding_rate # upper case\\n )\\n\\n # save models\\n t.save()\\n\\n # return loaded row number\\n return index\",\n \"def ingest_product_csv(csv_path):\\n # Create a CSV import generator (next yields one db row)\\n import_generator = import_csv_gen(csv_path)\\n # Skip over the title row\\n next(import_generator)\\n # Iterate over all other rows\\n while True:\\n try:\\n data = next(import_generator)\\n if len(data) != 4:\\n logger.error(f'Data with incorrect item count: {len(data)}')\\n continue\\n # extract items from list and add document to database\\n with Connection():\\n product = Product(\\n product_id=data[PROD_ID],\\n description=data[PROD_DESC],\\n product_type=data[PROD_TYPE],\\n quantity_available=data[PROD_QTY]\\n )\\n product.save() # This will perform an insert\\n except StopIteration:\\n break\",\n \"def load_stock_symbol_fr_file(self):\\n stock_list = pandas.read_csv(self.retrieval_type_input_file_dict[self.stock_retrieval_type])\\n stock_list = list(stock_list['SYMBOL'])\\n self.set_full_stocklist_to_retrieve(stock_list)\",\n \"def open_file():\\r\\n\\tr_ct = 0\\r\\n\\t\\r\\n\\twith open('flavors_of_cacao.csv', 'r') as csvfile:\\r\\n\\t\\tcacao_stream = csv.DictReader(csvfile)\\r\\n\\t\\tfor cacao_row in cacao_stream:\\r\\n\\t\\t\\tr_ct += 1\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t#quit after 100 records\\r\\n\\t\\t\\tif r_ct > 100:\\r\\n\\t\\t\\t\\tbreak\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t#pull the data out of the dictionary for sqlite3\\r\\n\\t\\t\\tt_Company = cacao_row['Company']\\r\\n\\t\\t\\tt_Specific_Bean_Origin = cacao_row['Specific_Bean_Origin']\\r\\n\\t\\t\\tt_REF = cacao_row['REF']\\r\\n\\t\\t\\tt_Review = cacao_row['Review']\\r\\n\\t\\t\\tt_Cocoa = cacao_row['Cocoa']\\r\\n\\t\\t\\tt_Location = cacao_row['Location']\\r\\n\\t\\t\\tt_Rating = cacao_row['Rating']\\r\\n\\t\\t\\tt_Bean = cacao_row['Bean']\\r\\n\\t\\t\\tt_Broad_Bean_Origin = cacao_row['Broad_Bean_Origin']\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t#print the first 15 lines\\r\\n\\t\\t\\tif r_ct <= 15:\\r\\n\\t\\t\\t\\tprint (r_ct, t_Company, t_Bean, t_Cocoa, t_Review)\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t#creates a sql cursor, formats the insert sql and executes it\\r\\n\\t\\t\\tc = conn.cursor()\\r\\n\\t\\t\\tstrsql = \\\"\\\"\\\"\\r\\n\\t\\t\\t\\tINSERT INTO cacao\\r\\n\\t\\t\\t\\t\\t(Company, Specific_Bean_Origin, REF, Review, Cocoa, Location, Rating, Bean, Broad_Bean_Origin)\\r\\n\\t\\t\\t\\tvalues (\\r\\n\\t\\t\\t\\t\\t'{t_Company}', '{t_Specific_Bean_Origin}', '{t_REF}', '{t_Review}', '{t_Cocoa}', '{t_Location}', '{t_Rating}', '{t_Bean}', '{t_Broad_Bean_Origin}');\\r\\n\\t\\t\\t\\t\\\"\\\"\\\".format(\\r\\n\\t\\t\\t\\t\\tt_Company = t_Company,\\r\\n\\t\\t\\t\\t\\tt_Specific_Bean_Origin = t_Specific_Bean_Origin,\\r\\n\\t\\t\\t\\t\\tt_REF = t_REF,\\r\\n\\t\\t\\t\\t\\tt_Review = t_Review,\\r\\n\\t\\t\\t\\t\\tt_Cocoa = t_Cocoa,\\r\\n\\t\\t\\t\\t\\tt_Location = t_Location,\\r\\n\\t\\t\\t\\t\\tt_Rating = t_Rating,\\r\\n\\t\\t\\t\\t\\tt_Bean = t_Bean,\\r\\n\\t\\t\\t\\t\\tt_Broad_Bean_Origin = t_Broad_Bean_Origin\\r\\n\\t\\t\\t\\t\\t)\\r\\n\\t\\t\\tc.execute(strsql)\\r\\n\\t\\t\\tconn.commit()\",\n \"def merge_quantity(self, session, source_qty):\\n qty_cls = source_qty.__class__\\n try:\\n target_qty = session.query(qty_cls).\\\\\\n filter(and_(qty_cls.atom==self,\\n qty_cls.data_source==source_qty.data_source)).one()\\n target_qty.quantity = source_qty.quantity\\n target_qty.std_dev = source_qty.std_dev\\n\\n except NoResultFound:\\n\\n self.quantities.append(source_qty)\",\n \"def ingredient_used(self, item, quantity):\\n logger.info('ReleaseDiscard ingredient used initiated')\\n try:\\n quantity = Decimal(quantity).quantize(Decimal('0.11'))\\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\\n , order=[('batch_number', 'ASC')])\\n product = self.Product.search([('name', '=', item),\\n ('description', '=', 'Stock'),\\n ('type', '=', 'goods')])[-1]\\n done = False\\n today = date.today()\\n for i in inventory_list:\\n for j in i.lines:\\n if j.product.template.name == item:\\n expiry = j.expiry_date\\n if expiry:\\n if expiry >= today:\\n if Decimal(j.quantity) >= Decimal(quantity):\\n j.quantity = Decimal(j.quantity) - Decimal(quantity)\\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\\n quantity=quantity,\\n batch_number=i.batch_number)\\n self.store_inventory(location=self.used, inventory_stock=j,\\n quantity=quantity, batch=i.batch_number)\\n j.save()\\n self.check_and_delete(i)\\n done = True\\n else:\\n quantity = Decimal(quantity) - Decimal(j.quantity)\\n self.move(from_location=self.kitchen, to_location=self.used, item=product,\\n quantity=j.quantity, batch_number=i.batch_number)\\n self.store_inventory(location=self.used, inventory_stock=j,\\n quantity=j.quantity, batch=i.batch_number)\\n j.quantity = 0\\n j.save()\\n self.check_and_delete(i)\\n # transaction.cursor.commit()\\n i.save()\\n if done:\\n return True\\n except Exception:\\n if settings.level == 10:\\n logger.exception('raised exception')\\n return False\",\n \"def __addNuclideBases():\\n with open(os.path.join(context.RES, \\\"nuclides.dat\\\")) as f:\\n for line in f:\\n # Skip header lines\\n if line.startswith(\\\"#\\\") or line.startswith(\\\"Z\\\"):\\n continue\\n lineData = line.split()\\n _z = int(lineData[0])\\n _n = int(lineData[1])\\n a = int(lineData[2])\\n state = int(lineData[3])\\n sym = lineData[4].upper()\\n mass = float(lineData[5])\\n abun = float(lineData[6])\\n halflife = lineData[7]\\n if halflife == \\\"inf\\\":\\n halflife = numpy.inf\\n else:\\n halflife = float(halflife)\\n nuSF = float(lineData[8])\\n\\n element = elements.bySymbol[sym]\\n nb = NuclideBase(element, a, mass, abun, state, halflife)\\n nb.nuSF = nuSF\",\n \"def bulk_copy_to_db(self):\\n database = PostgreSQLCommon()\\n\\n try:\\n file = open(self.file_name_hash)\\n database.bulk_copy(file, self.storage_table)\\n\\n m.info('Bulk insert from %s has been successfully completed!'\\n % self.file_name_hash)\\n except Exception as err:\\n m.error('OOps! Bulk insert operation FAILED! Reason: %s' % str(err))\\n finally:\\n database.close()\\n\\n if os.path.exists(self.file_name_hash):\\n os.remove(self.file_name_hash)\",\n \"def add_cartons(db, cartons, tag):\\n # stock cartons\\n for key, value in cartons.iteritems():\\n length, width, height = value.split('x')\\n d = Box('box'+key, tags={tag}, length=int(float(length)), width=int(float(width)), height=int(float(height)))\\n db.session.add(d)\\n\\n try:\\n db.session.commit()\\n except IntegrityError:\\n return 1\\n print(\\\"Duplicate boxes found!\\\")\\n return 0\",\n \"def ogrAppendFeatures(gpxFile, sourceLayer, destinationLayer):\\r\\n\\r\\n ##print \\\"Starting transaction for: {0}\\\".format(destinationLayer.GetName())\\r\\n print \\\" Importing {0}: {1} features\\\".format(sourceLayer.GetName(), sourceLayer.GetFeatureCount())\\r\\n fName = os.path.basename(gpxFile)\\r\\n destinationLayer.StartTransaction()\\r\\n for x in xrange(sourceLayer.GetFeatureCount()):\\r\\n sourceFeature = sourceLayer.GetNextFeature()\\r\\n ##print \\\"inserting record\\\"\\r\\n sourceFeature.SetFID(-1)\\r\\n sourceFeature.SetField(\\\"src\\\", fName)\\r\\n destinationLayer.CreateFeature(sourceFeature)\\r\\n\\r\\n #Commit the new features to the database\\r\\n ##print \\\" Committing transaction for: {0}\\\".format(destinationLayer.GetName())\\r\\n destinationLayer.CommitTransaction()\",\n \"def _insert_data(self, query, columns):\\n with open(self.file, encoding='utf8') as f:\\n csvreader = csv.reader(f)\\n next(csvreader) # skipping header\\n for line in csvreader:\\n line[5] = float(line[5])\\n line[8] = int(line[8])\\n line[3] = int(line[3])\\n line[10] = int(line[10])\\n self.session.execute(query, tuple(map(line.__getitem__, columns)))\",\n \"def import_products(input_data):\\n error_count = 0\\n insert_count = 0\\n LOGGER.info('Starting product import')\\n for oneprod in input_data:\\n try:\\n Product(oneprod['product_id'], oneprod['description'], oneprod['product_type'],\\n oneprod['quantity']).save(full_clean=True, force_insert=True)\\n insert_count += 1\\n except ValidationError as valerror:\\n LOGGER.exception(\\\"Error importing data from csv: %s \\\", valerror.message)\\n error_count += 1\\n except (DuplicateKeyError) as duperror:\\n LOGGER.exception(\\\"Error importing data from csv: %s \\\", duperror)\\n error_count += 1\\n\\n return [insert_count, error_count]\",\n \"def add_furniture():\\n print(\\\"Attempting to seed the furniture collection.....\\\")\\n print()\\n\\n chair_path = Path(\\\"chair.png\\\")\\n\\n couch = FurnitureItem(\\n \\\"Comfy couch\\\",\\n \\\"Well loved, but still in pretty good condition\\\",\\n 60.00,\\n 40,\\n \\\"swiessle@stevens.edu\\\",\\n \\\"Couch\\\",\\n \\\"beige\\\",\\n [50, 20, 10],\\n )\\n couch.set_image_filepath(chair_path)\\n Database.add_item(couch)\\n print(\\\"couch has been successfully added\\\")\\n\\n table = FurnitureItem(\\n \\\"Dining room table\\\",\\n \\\"Wooden dining room table. Has a few scuffs, but not bad!\\\",\\n 30.00,\\n 15,\\n \\\"gracem730@gmail.com\\\",\\n \\\"Table\\\",\\n \\\"wood\\\",\\n [40, 20, 40],\\n )\\n table.set_image_filepath(chair_path)\\n Database.add_item(table)\\n print(\\\"table has been successfully added\\\")\\n\\n bed = FurnitureItem(\\n \\\"Bed Frame\\\",\\n \\\"Just selling the bed frame, you'll have \\\\\\n to get your own mattress\\\",\\n 55.00,\\n 50,\\n \\\"erotside@stevens.edu\\\",\\n \\\"Bed\\\",\\n \\\"white\\\",\\n [10, 20, 10],\\n )\\n bed.set_image_filepath(chair_path)\\n Database.add_item(bed)\\n print(\\\"bed has been successfully added\\\")\\n\\n desk = FurnitureItem(\\n \\\"Ikea desk, no longer need it\\\",\\n \\\"In great condition, this is truly a steal\\\",\\n 60.00,\\n 35,\\n \\\"jlora@stevens.edu\\\",\\n \\\"Ikea Desk\\\",\\n \\\"navy\\\",\\n [20, 20, 30],\\n )\\n desk.set_image_filepath(chair_path)\\n Database.add_item(desk)\\n print(\\\"desk has been successfully added\\\")\\n\\n shelf = FurnitureItem(\\n \\\"Book shelf, never used\\\",\\n \\\"Brand new\\\",\\n 110.00,\\n 25,\\n \\\"dcarpent@stevens.edu\\\",\\n \\\"Book Shelf\\\",\\n \\\"black\\\",\\n [10, 20, 100],\\n )\\n shelf.set_image_filepath(chair_path)\\n Database.add_item(shelf)\\n print(\\\"shelf has been successfully added\\\")\\n\\n print()\\n print(\\\"Done seeding the furniture collection!\\\")\\n print(\\\"----------------------------------------------\\\")\",\n \"def populate_database(self):\\n self.insert_products()\\n self.insert_categories()\\n self.insert_products_categories()\\n self.insert_stores()\\n self.insert_products_stores()\",\n \"def read_stock(db, openfile):\\n pass\",\n \"def load_currencies_codes(data):\\n currency_codes = [currency_code for currency_code in data.keys()]\\n currency_code_objects = [Currency(data=currency_code)\\n for currency_code\\n in currency_codes]\\n Currency.objects.bulk_create(currency_code_objects)\",\n \"def connect_db_and_load_data(cls):\\n db.connect()\\n db.create_tables([Product], safe=True)\\n load_data(transform_data('./inventory.csv'))\",\n \"def start_cfm_jobs(file_dir, db, spec_type, job_template=None,\\n job_comp_number=100, max_mass=1500):\\n if not os.path.exists(file_dir):\\n os.mkdir(file_dir)\\n os.chdir(file_dir)\\n\\n out_file = open(db.name + \\\"_1.txt\\\", \\\"w\\\")\\n i = 1\\n j = 1\\n inchi_set = set()\\n if spec_type == 'pos':\\n search = {\\\"_id\\\": {\\\"$regex\\\": \\\"^C\\\"}, \\\"Mass\\\": {\\\"$lt\\\": max_mass},\\n \\\"Charge\\\": 0, \\\"Pos_CFM_spectra\\\": {\\\"$exists\\\": 0}}\\n elif spec_type == 'neg':\\n search = {\\\"_id\\\": {\\\"$regex\\\": \\\"^C\\\"}, \\\"Mass\\\": {\\\"$lt\\\": max_mass},\\n \\\"Charge\\\": 0, \\\"Neg_CFM_spectra\\\": {\\\"$exists\\\": 0}}\\n elif spec_type == 'ei':\\n search = {\\\"_id\\\": {\\\"$regex\\\": \\\"^C\\\"}, \\\"Mass\\\": {\\\"$lt\\\": max_mass},\\n \\\"Charge\\\": 0, \\\"EI_CFM_spectra\\\": {\\\"$exists\\\": 0}}\\n else:\\n raise ValueError('invalid spectrum spec_type')\\n\\n for compound in db.compounds.find(search, {\\\"SMILES\\\": 1, \\\"Inchikey\\\": 1}):\\n con_block = compound['Inchikey'].split('-')[0]\\n if con_block not in inchi_set:\\n out_file.write(\\\"%s %s\\\\n\\\" % (con_block, compound['SMILES']))\\n i += 1\\n inchi_set.add(con_block)\\n if not i % job_comp_number:\\n out_file.close()\\n j += 1\\n out_file = open(db_name + \\\"_\\\" + str(j) + \\\".txt\\\", 'w')\\n out_file.close()\\n\\n if job_template:\\n # for Quest?\\n # fetch the information from the job template\\n try:\\n infile = open(job_template)\\n except IOError:\\n sys.exit(\\\"Job template file not found\\\")\\n temp_data = infile.readlines()\\n infile.close()\\n\\n for comp_file in os.listdir(\\\".\\\"):\\n if \\\".txt\\\" not in comp_file:\\n continue\\n job_data = deepcopy(temp_data)\\n # edit the job template data for the specific job\\n job_data[1] = \\\"#$ -e logs/cfm_%s.err\\\\n\\\" % (comp_file.strip('.txt'))\\n job_data[2] = \\\"#$ -o logs/cfm_%s.log\\\\n\\\" % (comp_file.strip('.txt'))\\n new_file = file_dir + \\\"/\\\" + comp_file.strip()\\n job_data[11] = job_data[11].replace(\\\"{smile_file}\\\", new_file)\\n\\n # write the specific job file\\n job_file = \\\"cfm_%s.job\\\" % comp_file.strip('.txt')\\n outfile = open(job_file, 'w')\\n outfile.writelines(job_data)\\n outfile.close()\\n rc = call([\\\"qsub\\\", job_file], shell=True)\\n if not rc:\\n os.remove(job_file)\",\n \"def process_products_file(products_df: pd.DataFrame):\\n products = []\\n file_size = len(products_df)\\n logging.info(f\\\"Processing PRODUCTS.csv file... {file_size} rows\\\")\\n for index, row in products_df.iterrows():\\n if not pd.isnull(row[\\\"NAME\\\"]):\\n product = Product(sku=row[\\\"SKU\\\"], store=\\\"Richart's\\\")\\n product.brand = row[\\\"BRAND\\\"]\\n product.barcodes = row[\\\"BARCODES\\\"]\\n product.description = cleanhtml(row[\\\"DESCRIPTION\\\"])\\n product.category = row[\\\"CATEGORY\\\"]\\n product.image_url = row[\\\"IMAGE_URL\\\"]\\n product.package = row[\\\"BUY_UNIT\\\"]\\n product.name = row[\\\"NAME\\\"]\\n products.append(product)\\n else:\\n logging.warning(f\\\"PRODUCTS | Product without name! will not be included - index: {index}\\\")\\n\\n bulk_size = len(products)\\n if bulk_size == BATCH_SIZE:\\n try:\\n session.bulk_save_objects(products)\\n session.commit()\\n logging.info(f\\\"Inserted {bulk_size} rows to PRODUCTS table\\\")\\n products = []\\n except Exception as e:\\n logging.exception(f\\\"PRODUCTS error. msg: {e}\\\")\\n session.rollback()\",\n \"def import_data(directory_name, product_file, customer_file, rentals_file):\\n with MongoDBConnection() as mongo:\\n database = mongo.connection[DATABASE]\\n\\n product_error_count = 0\\n try:\\n product_collection = database[PRODUCT_COLLECTION]\\n product_count = 0\\n with open(directory_name + '/' + product_file, 'r') as csv_file:\\n product_reader = csv.DictReader(csv_file) # return an ordered dictionary\\n for row in product_reader:\\n product_collection.insert_one(row)\\n product_count += 1\\n except (FileNotFoundError, TypeError):\\n product_error_count += 1\\n\\n customer_error_count = 0\\n try:\\n customer_collection = database[CUSTOMER_COLLECTION]\\n customer_count = 0\\n with open(directory_name + '/' + customer_file, 'r') as csv_file:\\n customer_reader = csv.DictReader(csv_file)\\n for row in customer_reader:\\n customer_collection.insert_one(row)\\n customer_count += 1\\n except (FileNotFoundError, TypeError):\\n customer_error_count += 1\\n\\n rentals_error_count = 0\\n try:\\n rentals_collection = database[RENTALS_COLLECTION]\\n rentals_count = 0\\n with open(directory_name + '/' + rentals_file, 'r') as csv_file:\\n rentals_reader = csv.DictReader(csv_file)\\n for row in rentals_reader:\\n rentals_collection.insert_one(row)\\n rentals_count += 1\\n except (FileNotFoundError, TypeError):\\n rentals_error_count += 1\\n\\n return product_count + customer_count + rentals_count\",\n \"def readClumpcat(self):\\n\\t\\tf = open('%s/raw_clumpcat_%s' %(self.wd,self.file))\\n\\t\\tdata = []\\n\\t\\tfor line in f.readlines()[1:]:\\n\\t\\t\\tdata.append(map(float, line.split()))\\n\\t\\tself.clumpcat = data\",\n \"def import_warehouse_stock_qty_batch(session, model_name, backend_id, filters=None):\\n if filters is None:\\n filters = {'skus': 'ALL'}\\n env = get_environment(session, model_name, backend_id)\\n importer = env.get_connector_unit(WarehouseImport)\\n importer.run(filters['skus'])\",\n \"def import_clean_process():\\n # loading the co2 emissions data for the Earth, I'm only interested in the\\n # total emissions and the year\\n global_co2 = pd.read_csv(\\n \\\"datasets/Global CO2 Emissions.csv\\\",\\n usecols=[\\n \\\"Year\\\",\\n \\\"Total\\\"\\n ],\\n parse_dates=[\\\"Year\\\"],\\n index_col=\\\"Year\\\"\\n )\\n # creating the global temperature dataframe\\n global_temp_data = open(\\n \\\"datasets/CRUTEM.4.6.0.0.global_n+s\\\",\\n \\\"r\\\"\\n )\\n global_temp = pd.DataFrame(\\n {\\n \\\"global_temp\\\": [],\\n }\\n )\\n for line in global_temp_data:\\n # each line in the file is an observation for the year, the first\\n # column being the year, the second being the temperature measurement\\n data = line.split()\\n global_temp.at[pd.to_datetime(data[0]), \\\"global_temp\\\"] = float(data[1])\\n global_temp_data.close()\\n # loading the co2 emissions data for the UK\\n uk_co2 = pd.read_csv(\\n \\\"datasets/UK carbon dioxide emissions between 1858 to 2017 .csv\\\",\\n parse_dates=[\\\"Date\\\"],\\n index_col=\\\"Date\\\"\\n )\\n # creating the dataframe for the UK temperature data\\n uk_temp = pd.DataFrame(\\n {\\n \\\"uk_temp\\\": [],\\n }\\n )\\n # this file consists of monthly and seasonal averages for the UK surface\\n # temperature\\n uk_tmean = open(\\n \\\"datasets/UK Mean Temperature (Degrees C)\\\",\\n \\\"r\\\"\\n )\\n for index, line in enumerate(uk_tmean):\\n # the data begins on the eigth line in the file\\n if index > 7:\\n data = line.split()\\n # the monthly temperatures are from the 2nd and 13th columns\\n month_temps = np.array(data[1:13]).astype(float)\\n # the first reading is the year, I've taken the average of all the\\n # months to get an annual average\\n uk_temp.at[pd.to_datetime(data[0]), \\\"uk_temp\\\"] = month_temps.mean()\\n uk_tmean.close()\\n # removing the temperature reading for 2019 as it isn't averaged over the\\n # whole year (this program was written in 06/2019)\\n uk_temp = uk_temp[:-1]\\n # merging the temperature and co2 emissions dataframes for the Earth\\n global_data = pd.merge(\\n global_temp,\\n global_co2,\\n left_index=True,\\n right_index=True,\\n how=\\\"outer\\\"\\n )\\n # merging the temperature and co2 emissions dataframes for the UK\\n uk_data = pd.merge(\\n uk_temp,\\n uk_co2,\\n left_index=True,\\n right_index=True,\\n how=\\\"outer\\\"\\n )\\n # merging the global and UK dataframes\\n df_data = pd.merge(\\n global_data,\\n uk_data,\\n left_index=True,\\n right_index=True,\\n how=\\\"outer\\\"\\n )\\n # rename some of the columns to make them more clear\\n df_data = df_data.rename(\\n columns={\\n \\\"Total\\\": \\\"global_co2\\\",\\n \\\"CO2 Emissions\\\": \\\"uk_co2\\\"\\n }\\n )\\n return df_data\",\n \"def load_products_data(connection, csvfile):\\n insert_sql = 'insert into products (id, description, genres) ' \\\\\\n 'values (%s, %s, %s)'\\n load_data(connection, insert_sql, get_data_from_file(csvfile))\",\n \"def _importInDjango(self):\\n\\n with open(settings.DATA_PATH, 'r', encoding='latin-1') as csv_file:\\n reader = csv.DictReader(csv_file, delimiter=';')\\n for raw in reader:\\n\\n # Créer ou mettre à jour la division\\n division, created = Division.objects.get_or_create(\\n nom=raw['Division']\\n )\\n if created:\\n self.stdout.write(\\n 'Divion {} ajoutée'.format(division.nom)\\n )\\n\\n # Créer ou mettre à jour les équipes\\n equipeDom, created = Equipe.objects.get_or_create(\\n nom=raw['Equipe 1'],\\n division=division\\n )\\n if created:\\n self.stdout.write(\\n 'Equipe {} ajoutée'.format(equipeDom.nom)\\n )\\n\\n equipeExt, created = Equipe.objects.get_or_create(\\n nom=raw['Equipe 2'],\\n division=division\\n )\\n if created:\\n self.stdout.write(\\n 'Equipe {} ajoutée'.format(equipeExt.nom)\\n )\\n\\n # Créer ou mettre à jour la rencontre\\n scoreDom = 0 if raw['Score 1'] == '' else int(raw['Score 1'])\\n scoreExt = 0 if raw['Score 2'] == '' else int(raw['Score 2'])\\n forfaitDom = True if raw['Forfait 1'] == 'true' else False\\n forfaitExt = True if raw['Forfait 2'] == 'true' else False\\n date = datetime.datetime.strptime(raw['Date de rencontre'], '%d/%m/%Y')\\n heure = datetime.datetime.strptime(raw['Heure'], '%H:%M')\\n rencontre, created = Rencontre.objects.update_or_create(\\n numero=int(raw['N° de match']),\\n equipeDom=equipeDom,\\n equipeExt=equipeExt,\\n defaults={\\n 'date': date,\\n 'heure': heure,\\n 'scoreDom': scoreDom,\\n 'scoreExt': scoreExt,\\n 'forfaitDom': forfaitDom,\\n 'forfaitExt': forfaitExt,\\n }\\n )\\n if created:\\n self.stdout.write(\\n 'Rencontre {} / {} ajoutée'.format(\\n rencontre.equipeDom,\\n rencontre.equipeExt\\n )\\n )\",\n \"def _create_db_entries(self, qa):\\n\\n def _package_description(raw):\\n return raw[2:].replace(' - ', ' - ')\\n\\n log.debug('Creating database entries')\\n\\n\\n # Parse component and section from field in changes\\n component, section = parse_section(self.changes['files'][0]['section'])\\n\\n # Check whether package is already in the database\\n package_query = meta.session.query(Package).filter_by(name=self.changes['Source'])\\n if package_query.count() == 1:\\n log.debug('Package %s already exists in the database' % self.changes['Source'])\\n package = package_query.one()\\n # Update description to make sure it reflects the latest upload\\n package.description = _package_description(self.changes['Description'])\\n else:\\n log.debug('Package %s is new to the system' % self.changes['Source'])\\n package = Package(name=self.changes['Source'], user=self.user)\\n package.description = _package_description(self.changes['Description'])\\n package.needs_sponsor = 0\\n meta.session.add(package)\\n\\n # No need to check whether there is the same source name and same version as an existing\\n # entry in the database as the upload controller tested whether similar filenames existed\\n # in the repository. The only way this would be wrong is if the filename had a different\\n # version in than the Version field in changes..\\n\\n\\n try:\\n closes = self.changes['Closes']\\n except KeyError:\\n closes = None\\n\\n # TODO: fix these magic numbers\\n if qa.stop():\\n qa_status = 1\\n else:\\n qa_status = 0\\n\\n maintainer_matches = re.compile(r'(.*) <(.*)>').match(self.changes['Changed-By'])\\n maintainer = maintainer_matches.group(2)\\n\\n package_version = PackageVersion(package=package, version=self.changes['Version'],\\n section=section, distribution=self.changes['Distribution'], qa_status=qa_status,\\n component=component, priority=self.changes.get_priority(), closes=closes,\\n uploaded=datetime.now(), maintainer=maintainer)\\n meta.session.add(package_version)\\n\\n source_package = SourcePackage(package_version=package_version)\\n meta.session.add(source_package)\\n\\n binary_package = None\\n\\n # Add PackageFile objects to the database for each uploaded file\\n for file in self.files:\\n filename = os.path.join(self.changes.get_pool_path(), file)\\n # This exception should be never caught.\\n # It implies something went wrong before, as we expect a file which does not exist\\n try:\\n sum = md5sum(os.path.join(pylons.config['debexpo.repository'], filename))\\n except AttributeError as e:\\n self._fail(\\\"Could not calculate MD5 sum: %s\\\" % (e))\\n\\n size = os.stat(os.path.join(pylons.config['debexpo.repository'], filename))[ST_SIZE]\\n\\n # Check for binary or source package file\\n if file.endswith('.deb'):\\n # Only create a BinaryPackage if there actually binary package files\\n if binary_package is None:\\n binary_package = BinaryPackage(package_version=package_version, arch=file[:-4].split('_')[-1])\\n meta.session.add(binary_package)\\n\\n meta.session.add(PackageFile(filename=filename, binary_package=binary_package, size=size, md5sum=sum))\\n else:\\n meta.session.add(PackageFile(filename=filename, source_package=source_package, size=size, md5sum=sum))\\n\\n meta.session.commit()\\n log.warning(\\\"Finished adding PackageFile objects.\\\")\\n\\n # Add PackageInfo objects to the database for the package_version\\n for result in qa.result:\\n meta.session.add(PackageInfo(package_version=package_version, from_plugin=result.from_plugin,\\n outcome=result.outcome, rich_data=result.data, severity=result.severity))\\n\\n # Commit all changes to the database\\n meta.session.commit()\\n log.debug('Committed package data to the database')\\n\\n subscribers = meta.session.query(PackageSubscription).filter_by(package=self.changes['Source']).filter(\\\\\\n PackageSubscription.level <= constants.SUBSCRIPTION_LEVEL_UPLOADS).all()\\n\\n if len(subscribers) > 0:\\n email = Email('package_uploaded')\\n self.send_email(email, [s.user.email for s in subscribers], package=self.changes['Source'],\\n version=self.changes['Version'], user=self.user)\\n\\n log.debug('Sent out package subscription emails')\\n\\n # Send success email to uploader\\n email = Email('successful_upload')\\n dsc_url = pylons.config[\\n 'debexpo.server'] + '/debian/' + self.changes.get_pool_path() + '/' + self.changes.get_dsc()\\n rfs_url = pylons.config['debexpo.server'] + url('rfs', packagename=self.changes['Source'])\\n self.send_email(email, [self.user.email], package=self.changes['Source'],\\n dsc_url=dsc_url, rfs_url=rfs_url)\",\n \"def load_equipment():\\n\\n for row in open(\\\"static/equipment.csv\\\"):\\n row = row.rstrip()\\n \\n gear_name, category, brand, lender_email, zipcode, gear_photo, gear_photo_url = row.split(\\\",\\\")\\n\\n equipment = Equipment(\\n gear_name=gear_name,\\n category=category,\\n brand=brand,\\n lender_email=lender_email,\\n zipcode=zipcode,\\n gear_photo=gear_photo,\\n gear_photo_url=gear_photo_url)\\n\\n db.session.add(equipment)\\n \\n\\n db.session.commit()\",\n \"def repopulate(self, scale_factor):\\n \\n # drop db if exists, this isn't terribly expensive\\n print('dropping db...')\\n if self.tpch_cxn:\\n self.tpch_cxn.close()\\n with self.cxn.cursor() as cur:\\n cur.execute('DROP DATABASE tpch')\\n \\n # create db, connection to db\\n print('creating db... connecting to db...')\\n with self.cxn.cursor() as cur:\\n cur.execute('CREATE DATABASE tpch')\\n self.tpch_cxn = self.__connect(TPCH_DSN)\\n\\n # generate data\\n print('running dbgen... repopulating db...')\\n tic=time.time()\\n subprocess.run(['./dbgen.sh', str(scale_factor)]) # TODO whoops put absolute path\\n\\n # create tables, copy data into tables\\n with open(os.path.join(TPCH_DIR, 'build-tpch-tables.sql'), 'r') as f, \\\\\\n self.tpch_cxn.cursor() as cur:\\n\\n cur.execute(f.read())\\n \\n toc = time.time()\\n print('...took {} seconds'.format(round(toc-tic)))\\n\\n # rm generated data\\n print('cleaning up...')\\n subprocess.run(['rm', '-rf', DATA_DIR])\",\n \"def cfInsert(self, key, items, capacity=None, nocreate=None):\\n params = [key]\\n self.appendCapacity(params, capacity)\\n self.appendNoCreate(params, nocreate)\\n self.appendItems(params, items)\\n\\n return self.execute_command(self.CF_INSERT, *params)\",\n \"def process_database(self):\\n self.DBDict = self.data_df.to_dict(orient=\\\"index\\\")\\n\\n # calculate weight ratio\\n self.DBDict = {k: self.calc_compound_weight_ratio(\\n self.DBDict[k]) for k in self.DBDict}\\n\\n # export as dataframe\\n self.converted_df = pd.DataFrame(self.DBDict).T\\n\\n unnest_list = [\\\"SMILES_wt_list\\\", \\\"structureList\\\",\\n \\\"wt_ratio\\\", \\\"fp_list\\\", \\\"MWList\\\"]\\n self.converted_df = unnest_dataframe(\\n self.converted_df, unnest_list, axis=0)\\n\\n # unnest FP\\n unNest_FP_list = list(self.converted_df.columns[[True if re.match(\\n \\\"fp_list\\\", i) else False for i in self.converted_df.columns]])\\n rename_dict = {k: k+\\\"_\\\" for k in unNest_FP_list}\\n self.converted_df = self.converted_df.rename(columns=rename_dict)\\n\\n self.converted_df = unnest_dataframe(\\n self.converted_df, rename_dict.values(), axis=0)\",\n \"def coal_saved_benefits(self, coal_import_price):\\n baseline = self.plant.mainfuel_used\\n reduction = self.coal_saved\\n relative = reduction / baseline\\n benefit = reduction * coal_import_price\\n display_as(benefit, \\\"MUSD\\\")\\n return DataFrame(\\n [baseline, reduction, relative, benefit],\\n index=[\\\"Baseline\\\", \\\"Reduction\\\", \\\"Relative reduction\\\", \\\"Value\\\"],\\n )\",\n \"def convert_to_s3db(f_name, df):\\n if '[CHECKED]' in f_name:\\n db_name = f_name.split('[CHECKED]')[0] + '.s3db'\\n else:\\n db_name = f_name.split('.')[0] + '.s3db'\\n con = sqlite3.connect(db_name)\\n cur = con.cursor()\\n cur.execute(\\\"\\\"\\\"CREATE TABLE IF NOT EXISTS convoy (\\n vehicle_id INTEGER PRIMARY KEY,\\n engine_capacity INTEGER NOT NULL,\\n fuel_consumption INTEGER NOT NULL,\\n maximum_load INTEGER NOT NULL,\\n score INTEGER NOT NULL)\\n \\\"\\\"\\\")\\n con.commit()\\n rows_count = df.shape[0]\\n # making data for 'score' column\\n scores = [scoring(row) for row in df[column_names].to_numpy()]\\n # add 'score' column to data frame\\n df['score'] = scores\\n df.to_sql('convoy', con=con, if_exists='append', index=False)\\n print(f\\\"{rows_count} {'records were' if rows_count > 1 else 'record was'} inserted to {db_name}\\\")\\n con.commit()\\n con.close()\",\n \"def preprocessing(self):\\n print(\\\"This may take a while, please grab a coffee. Average wait time: 2 - 6 mins.\\\")\\n print(\\\"Loading data... \\\")\\n df = ExternalDataRetrieval().get_data()\\n\\n print(\\\"Preprocessing data... \\\")\\n\\n amino_df = pd.DataFrame()\\n # Set column names for zinc content dataframe\\n zcolumns = ['value', 'group']\\n # Set column names for food groups dataframe\\n fcolumns = ['ID', 'food', 'group', 'manufacturer']\\n # Declare zinc content dataframe\\n zinc_df = pd.DataFrame(columns=zcolumns)\\n # Declare food group dataframe\\n food_df = pd.DataFrame(columns=fcolumns)\\n # Doing this one amino acids type at a time.\\n for n in AMINO_LIST:\\n food = []\\n # nutrients components of the food type is further nested in 'nutrients', which its components are further\\n # nested\\n for i, items in enumerate(df['nutrients']):\\n # Iterate through the nutrient type to obtain necessary info.\\n # For this project, there are many redundant data in there.\\n f_flag = False\\n # Only need to set the flag to activate the zinc check for one amino acid loop\\n if n == AMINO_LIST[0]:\\n z_flag = False\\n for item in items:\\n # Check to see if this nutrient type is one of the amino acids\\n if item.get(\\\"name\\\") == n and item.get(\\\"value\\\") > 0:\\n # If so, add the food type to the amino acid type array\\n food.append(df['name'][i]['long'])\\n f_flag = True\\n # Check to see if this nutrient type is Zinc, only need to do this for one amino acid loop.\\n if item.get(\\\"name\\\") == Z and n == AMINO_LIST[0]:\\n # If so, gets its zinc content value and the food group it is in.\\n zinc_df.loc[i] = [item.get(\\\"value\\\"), df['group'][i]]\\n z_flag = True\\n if f_flag and z_flag:\\n break\\n\\n # Build the food group data dataframe one food at a time, only need to do this for one amino acid loop.\\n if n == AMINO_LIST[0]:\\n food_df.loc[i] = [df['meta'][i]['ndb_no'], df['name']\\n [i]['long'], df['group'][i], df['manufacturer'][i]]\\n\\n # Assemble the amino acid type array in to nutrient dataframe\\n fd = pd.DataFrame({n: food})\\n # Since the length of each columns varies (amino acid food types appearance in food types varies),\\n # there are many NaN in the dataframe as a result. We need to drop the NaN\\n fd = fd.dropna()\\n amino_df = pd.concat([amino_df, fd], axis=1, ignore_index=True)\\n # Add column names to the nutrient dataframe\\n amino_df.columns = AMINO_LIST\\n print(\\\"Good news, preprocessing completed successfully! \\\")\\n return amino_df, zinc_df, food_df\",\n \"def insert_data(cf, n):\\n for r in xrange(n):\\n print r\\n for c1 in xrange(ord('a'), ord('z') + 1):\\n for c2 in xrange(0, 100):\\n cf.insert(r, { (chr(c1), c2) : normalvariate(0, 1)})\",\n \"def keep_generated_quantity(fba, **_):\\n fba = fba[fba['Description'] == 'Generated'].reset_index(drop=True)\\n # if no mapping performed, still update units\\n if 'tons' in fba['Unit'].values:\\n fba = standardize_units(fba)\\n return fba\",\n \"def quantity(self, value):\\n self._quantity = Decimal(value)\",\n \"def gbk_upload(self):\\n t_count = 0\\n os.chdir(self.path)\\n print(os.getcwd())\\n if os.path.isdir(self.path + '/Databases') is False:\\n os.mkdir('Databases')\\n for tier in os.listdir(os.getcwd()):\\n if tier == 'Databases':\\n continue\\n db_name = str(tier) + '.db'\\n if os.path.isfile(self.path + '/Databases/' + db_name) is False:\\n print('Copying Template BioSQL Database... '\\n 'This may take a few minutes...')\\n shutil.copy2(where.Templates + '/Template_BioSQL_DB.db',\\n self.path + '/Databases/%s' % db_name)\\n else:\\n os.remove(self.path + '/Databases/' + db_name)\\n print('Copying Template BioSQL Database... '\\n 'This may take a few minutes...')\\n shutil.copy2(where.Templates + '/Template_BioSQL_DB.db',\\n self.path + '/Databases/%s' % db_name)\\n\\n server = BioSeqDatabase.open_database(\\n driver='sqlite3', db=(\\n self.path + '/Databases/' + db_name))\\n os.chdir(tier)\\n for gene in os.listdir(os.getcwd()):\\n os.chdir(gene)\\n sub_db_name = gene\\n for file in os.listdir(os.getcwd()):\\n try:\\n if sub_db_name not in server.keys():\\n server.new_database(sub_db_name)\\n db = server[sub_db_name]\\n count = db.load(SeqIO.parse(file, 'genbank'))\\n server.commit()\\n print('Server Commited %s' % sub_db_name)\\n print('%s database loaded with %s.' % (db.dbid, file))\\n print(\\n \\\"That file contains %s genbank records.\\\" %\\n str(count))\\n t_count = t_count + count\\n print(\\n 'The total number of files loaded so far is %i.' %\\n t_count)\\n except BaseException:\\n server.rollback()\\n try:\\n del server[sub_db_name]\\n server.commit()\\n except BaseException:\\n raise\\n raise\\n os.chdir('..')\\n os.chdir('..')\",\n \"def __init__(self):\\n self.file_name = 'data.csv'\\n # Column of interest\\n self._col = ['product_name', 'url', 'quantity', 'packaging']\\n self._col += ['brands', 'origins', 'countries_fr', 'allergens']\\n self._col += ['traces_fr', 'additives_n', 'additives_fr']\\n self._col += ['nutrition_grade_fr', 'categories_fr']\\n self._col += ['main_category_fr']\\n\\n # Check if the csv is already in the file\\n try:\\n with open(self.file_name, 'r'):\\n pass\\n except FileNotFoundError:\\n CsvAnalysis.download_file()\\n finally:\\n # Read the csv file, and create a dataframe\\n self.food_cat = pandas.read_csv(self.file_name,\\n sep=\\\"\\\\t\\\",\\n low_memory=False,\\n usecols=self._col,\\n encoding=\\\"utf8\\\")\\n\\n # Remove countries which aren't France\\n mask = self.food_cat['countries_fr']\\n self.food_cat = self.food_cat[mask == 'France']\\n\\n # Delete column countries_fr\\n del self.food_cat['countries_fr']\\n\\n # Remove empty row countries_fr from dataframe\\n columns = ['main_category_fr', 'product_name', 'nutrition_grade_fr']\\n for column in columns:\\n self.food_cat = self.food_cat[~self.food_cat[column].isnull()]\\n\\n # Remove empty row from product_name\\n self.food_cat.sort_values(by='categories_fr')\\n\\n # Select the last value from categories_fr\\n # to use it as a subcategory\\n col = 'categories_fr'\\n self.food_cat[col] = self.food_cat[col].str.split(',').str.get(-1)\\n self.food_cat.sort_values(by='categories_fr')\",\n \"def insert_into_sql(chunk):\\n bulk_list = []\\n for row in chunk:\\n bulk_list.append(StockData(\\n date=str(row[0])[0:4] + '-' + str(row[0])[4:6] + '-' + str(row[0])[6:8],\\n code=row[1],\\n code_name=row[2],\\n d1_diff_rate=row[3],\\n close=row[4],\\n open=row[5],\\n high=row[6],\\n low=row[7],\\n volume=row[8],\\n clo5=row[9],\\n clo10=row[10],\\n clo20=row[11],\\n clo40=row[12],\\n clo60=row[13],\\n clo80=row[14],\\n clo100=row[15],\\n clo120=row[16],\\n clo5_diff_rate=row[17],\\n clo10_diff_rate=row[18],\\n clo20_diff_rate=row[19],\\n clo40_diff_rate=row[20],\\n clo60_diff_rate=row[21],\\n clo80_diff_rate=row[22],\\n clo100_diff_rate=row[23],\\n clo120_diff_rate=row[24],\\n yes_clo_5=row[25],\\n yes_clo_10=row[26],\\n yes_clo_20=row[27],\\n yes_clo_40=row[28],\\n yes_clo_60=row[29],\\n yes_clo_80=row[30],\\n yes_clo_100=row[31],\\n yes_clo_120=row[32],\\n vol5=row[33],\\n vol10=row[34],\\n vol20=row[35],\\n vol40=row[36],\\n vol60=row[37],\\n vol80=row[38],\\n vol100=row[39],\\n vol120=row[40],\\n ))\\n StockData.objects.bulk_create(bulk_list)\\n return bulk_list\",\n \"def _process_chem_rows(self, sql_alc_conn, update, chem_ins, chem_struc_ins, chem_map_del, chem_map_ins, rows):\\n\\n logger.debug( \\\"Building set of unknown chemical IDs ({} known)\\\".format(len(self.existing_chemicals)) )\\n\\n # Identify chemicals from the batch that we haven't seen before\\n unknown_chem_ids = set()\\n for row in rows:\\n chem_id = int(row[1])\\n if chem_id in self.existing_chemicals:\\n continue\\n unknown_chem_ids.add( chem_id )\\n\\n # Search the DB to see if any of those chemicals are known\\n if (len(unknown_chem_ids) > 0):\\n\\n logger.debug( \\\"Searching DB for {} unknown chemical IDs\\\".format(len(unknown_chem_ids)) )\\n sel = select(\\n [self.chemicals.c.id])\\\\\\n .where(\\n (self.chemicals.c.id.in_(unknown_chem_ids) ))\\n\\n # Add known chemicals to the set of existing chemicals\\n result = sql_alc_conn.execute(sel)\\n found_chems = result.fetchall()\\n for found_chem in found_chems:\\n self.existing_chemicals.add( found_chem[0] )\\n\\n logger.debug( \\\"Known chemical IDs now at: {}\\\".format(len(self.existing_chemicals)) )\\n\\n # Now process all input rows, generating new data records where needed\\n new_chems = []\\n new_chem_structs = []\\n new_mappings = []\\n\\n new_chem_ids = set()\\n\\n logger.debug( \\\"Processing chemical mappings / building insert list\\\" )\\n\\n for i, row in enumerate(rows):\\n\\n if len(row) != self.CHEM_RECORD_COLS:\\n raise RuntimeError(\\\"Incorrect number of columns detected in chemical data file\\\")\\n\\n if row[0] not in self.doc_id_map:\\n logger.warn(\\\"Document ID not found for scpn [{}]; skipping record\\\".format(row[0]))\\n continue\\n\\n doc_id = self.doc_id_map[ row[0] ]\\n chem_id = int(row[1])\\n\\n # Add the chemical - if it's new\\n if chem_id not in self.existing_chemicals and\\\\\\n chem_id not in new_chem_ids:\\n\\n new_chems.append( (chem_id, float(row[6]), float(row[10]), int(row[8]), int(row[9]), int(row[11]), int(row[12]), int(row[13]), int(row[14]), int(row[7])) )\\n new_chem_structs.append( ( chem_id, row[2], row[3], row[4]) )\\n new_chem_ids.add(chem_id)\\n\\n # Add the document / chemical mappings\\n new_mappings.append( (doc_id, chem_id, DocumentField.TITLE, int(row[15]) ) )\\n new_mappings.append( (doc_id, chem_id, DocumentField.ABSTRACT, int(row[16]) ) )\\n new_mappings.append( (doc_id, chem_id, DocumentField.CLAIMS, int(row[17]) ) )\\n new_mappings.append( (doc_id, chem_id, DocumentField.DESCRIPTION, int(row[18]) ) )\\n new_mappings.append( (doc_id, chem_id, DocumentField.IMAGES, int(row[19]) ) )\\n new_mappings.append( (doc_id, chem_id, DocumentField.ATTACHMENTS, int(row[20]) ) )\\n\\n # Bulk insertions\\n logger.debug(\\\"Performing {} chemical inserts\\\".format(len(new_chems)) )\\n chem_ins.execute(new_chems)\\n\\n self.existing_chemicals.update( new_chem_ids )\\n\\n logger.debug(\\\"Performing {} chemical structure inserts\\\".format(len(new_chem_structs)) )\\n chem_struc_ins.execute( new_chem_structs)\\n \\n if (update):\\n logger.debug(\\\"Performing {} mapping deletions (for update)\\\".format(len(new_chem_structs)) )\\n chem_map_del.execute( new_mappings)\\n\\n logger.debug(\\\"Performing {} mapping inserts\\\".format(len(new_mappings)) )\\n chem_map_ins.execute( new_mappings)\",\n \"def import_thousand_data(dir_name, product_file, customer_file, rentals_file):\\n counter = Counter()\\n client = MongoDBConnection()\\n with client:\\n hp_norton_db = client.connection.rental\\n products = hp_norton_db['products']\\n customers = hp_norton_db['customers']\\n rentals = hp_norton_db['rentals']\\n exist_products = products.count()\\n exist_customers = customers.count()\\n exist_rentals = rentals.count()\\n\\n # 1. load the products collection\\n start = time.time()\\n LOGGER.info('Load the products collection')\\n processed_records = read_thousand_csv_file(dir_name, product_file,\\n products, counter)\\n product_tuple = (processed_records, exist_products, products.count(),\\n time.time() - start)\\n # 2. load the customers collection\\n start = time.time()\\n LOGGER.info('Load the customers collection')\\n processed_records = read_thousand_csv_file(dir_name, customer_file,\\n customers, counter)\\n customer_tuple = (processed_records, exist_customers, customers.count(),\\n time.time() - start)\\n # 3. load the rentals collection\\n start = time.time()\\n LOGGER.info('Load the rentals collection')\\n processed_records = read_thousand_csv_file(dir_name, rentals_file,\\n rentals, counter)\\n rental_tuple = (processed_records, exist_rentals, rentals.count(),\\n time.time() - start)\\n LOGGER.info(f'Return product tuple {product_tuple}')\\n LOGGER.info(f'Return customer tuple {customer_tuple}')\\n LOGGER.info(f'Return rental tuple {rental_tuple}')\\n LOGGER.info('Total record prcessed for all three files:'\\n f'{counter.value}')\\n return [product_tuple, customer_tuple]\",\n \"def read_formations():\\n\\n with resource_stream('component_contribution',\\n FullTrainingData.FORMATION_ENERGY_FNAME) as fp:\\n formation_df = pd.read_csv(gzip.GzipFile(fileobj=fp))\\n\\n cids_that_dont_decompose = set(\\n formation_df.loc[formation_df['decompose'] == 0, 'cid'])\\n\\n for col in [\\\"dG'0\\\", \\\"T\\\", \\\"I\\\", \\\"pH\\\", \\\"pMg\\\"]:\\n formation_df[col] = formation_df[col].apply(float)\\n\\n formation_df = formation_df[~pd.isnull(formation_df[\\\"dG'0\\\"])]\\n formation_df['reaction'] = formation_df['cid'].apply(\\n lambda c: Reaction({c: 1}))\\n\\n formation_df['balance'] = False\\n formation_df['description'] = formation_df['name'] + ' formation'\\n formation_df.rename(columns={'compound_ref': 'reference'},\\n inplace=True)\\n formation_df.drop(['name', 'cid', 'remark', 'decompose'],\\n axis=1, inplace=True)\\n\\n logger.debug('Successfully added %d formation energies' %\\n formation_df.shape[0])\\n return formation_df, cids_that_dont_decompose\",\n \"def ingredient_db():\\n # type: () -> List[Text]\\n return [\\\"abricot\\\",\\n \\\"banane\\\",\\n \\\"cassis\\\",\\n \\\"cerise\\\",\\n \\\"citron\\\",\\n \\\"clémentine\\\",\\n \\\"coing\\\",\\n \\\"fraise\\\",\\n \\\"framboise\\\",\\n \\\"groseille\\\",\\n \\\"mirabelle\\\",\\n \\\"mûre\\\",\\n \\\"myrtille\\\",\\n \\\"nectarine\\\",\\n \\\"orange\\\",\\n \\\"pamplemousse\\\",\\n \\\"pomelo\\\",\\n \\\"pêche\\\",\\n \\\"poire\\\",\\n \\\"pomme\\\",\\n \\\"prune\\\",\\n \\\"pruneau\\\",\\n \\\"raisin\\\",\\n \\\"rhubarbe\\\",\\n \\\"ananas\\\",\\n \\\"figue\\\",\\n \\\"fruit de la passion\\\",\\n \\\"goyave\\\",\\n \\\"grenade\\\",\\n \\\"kaki\\\",\\n \\\"kiwi\\\",\\n \\\"kumquat\\\",\\n \\\"litchi\\\",\\n \\\"mangue\\\",\\n \\\"melon\\\",\\n \\\"papaye\\\",\\n \\\"pastèque\\\",\\n \\\"vanille\\\",\\n \\\"amande\\\",\\n \\\"datte\\\",\\n \\\"noisette\\\",\\n \\\"artichaut\\\",\\n \\\"aubergine\\\",\\n \\\"asperge\\\",\\n \\\"avocat\\\",\\n \\\"betterave\\\",\\n \\\"blette\\\",\\n \\\"brocoli\\\",\\n \\\"banane plantain\\\",\\n \\\"carotte\\\",\\n \\\"cardon\\\",\\n \\\"céleri rave\\\",\\n \\\"céleri branche\\\",\\n \\\"champignon\\\",\\n \\\"champignon de paris\\\",\\n \\\"chou blanc\\\",\\n \\\"chou rouge\\\",\\n \\\"chou de bruxelles\\\",\\n \\\"chou-fleur\\\",\\n \\\"citrouille\\\",\\n \\\"concombre\\\",\\n \\\"courge\\\",\\n \\\"courgette\\\",\\n \\\"crosne\\\",\\n \\\"echalote\\\",\\n \\\"epinard\\\",\\n \\\"endive\\\",\\n \\\"fenouil\\\",\\n \\\"haricot vert\\\",\\n \\\"haricot\\\",\\n \\\"navet\\\",\\n \\\"oignon\\\",\\n \\\"oseille\\\",\\n \\\"panais\\\",\\n \\\"pâtisson\\\",\\n \\\"petit pois\\\",\\n \\\"poireau\\\",\\n \\\"poivron\\\",\\n \\\"potiron\\\",\\n \\\"radis rouge\\\",\\n \\\"rutabaga\\\",\\n \\\"navet\\\",\\n \\\"salade \\\",\\n \\\"salsifis\\\",\\n \\\"tomate\\\",\\n \\\"topinambour\\\",\\n \\\"maïs\\\"]\",\n \"def insert(item, quantity, price):\\n\\n conn = sqlite3.connect(\\\"lite.db\\\")\\n\\n # Point to the cursor object\\n cursor = conn.cursor()\\n\\n # Inserting a quantity\\n cursor.execute(\\\"INSERT INTO store VALUES (?, ?, ?)\\\", (item, quantity, price))\\n\\n # Commit\\n conn.commit()\\n\\n # Close connection\\n conn.close()\",\n \"def prequantize(self, linestrings, quant_factor=1e6):\\n\\n x0, y0, x1, y1 = geometry.MultiLineString(linestrings).bounds\\n kx = 1 / ((quant_factor - 1) / (x1 - x0))\\n ky = 1 / ((quant_factor - 1) / (y1 - y0))\\n\\n for ls in linestrings:\\n ls_xy = np.array(ls.xy)\\n ls_xy = (\\n np.array([(ls_xy[0] - x0) / kx, (ls_xy[1] - y0) / ky])\\n .T.round()\\n .astype(int)\\n )\\n ls.coords = ls_xy[\\n np.insert(np.absolute(np.diff(ls_xy, 1, axis=0)).sum(axis=1), 0, 1) != 0\\n ]\\n\\n return kx, ky, x0, y0\",\n \"def buildCurrencyDict(filename): \\n currencies = {}\\n with open(os.path.join(\\\"input\\\", filename), \\\"rt\\\", encoding=\\\"utf8\\\") as f:\\n reader = csv.reader(f)\\n for line in reader:\\n currencies[line[1]] = Currency(line[1], line[0], float(line[2]))\\n return currencies\",\n \"def kosdaq_to_db(chunk):\\n bulk_list = []\\n for row in chunk:\\n bulk_list.append(Kosdaq(\\n date=row[0],\\n close=float(row[1]),\\n open=float(row[2]),\\n high=float(row[3]),\\n low=float(row[4]),\\n volume=float(row[5]),\\n d1_diff_rate=float(row[6])\\n ))\\n Kosdaq.objects.bulk_create(bulk_list)\\n return bulk_list\",\n \"def mass_fraction_conversion(cfitfile):\\n # extracting the cfit file name prefix \\n file_prefix = cfitfile.split('_model_fits.cfit')[0]\\n\\n # assigning the prefix to new files to import the normalization files corresponding to our cfit file\\n gal_norm_file = file_prefix+'_off_axis_normal_fact.dat'\\n model_norm_file = file_prefix+'_model_normal_fact.dat'\\n masstable_file = file_prefix+'_masstable.tab'\\n \\n \\n G = np.genfromtxt(gal_norm_file)\\n all_model_norms = np.genfromtxt(model_norm_file)\\n\\n # Only select the normalization factors corresponding to solar metallicities ~ 0.2 \\n solar_met = 0.02\\n met_mask = (all_model_norms.transpose()[0,:] == solar_met) #Takes first column and selects metallicity = 0.02\\n \\n N_i = all_model_norms[met_mask].T[-1]\\n \\n # Stellar Mass Formed for each population: a_i = b_i*G/N_i , where b_i are the cfit values\\n normalization_factors = G/N_i\\n \\n return normalization_factors\",\n \"def collect_batch(self, item, quantity, kitchen=None):\\n try:\\n with Transaction().start(DBNAME, 1):\\n item = item\\n quantity = quantity\\n if kitchen:\\n inventory_list = self.Inventory.search([('location', '=', self.kitchen.id)]\\n , order=[('batch_number', 'ASC')])\\n else:\\n inventory_list = self.Inventory.search([('location', '=', self.inventory.id)]\\n , order=[('batch_number', 'ASC')])\\n batch_list = []\\n today = date.today()\\n for i in inventory_list:\\n lines = i.lines\\n for j in lines:\\n if j.product.template.name == item:\\n expiry = j.expiry_date\\n if expiry:\\n if expiry >= today:\\n if Decimal(j.quantity) >= Decimal(quantity):\\n batch_list.append([str(i.batch_number), str(quantity)])\\n print [str(i.batch_number), str(quantity)]\\n return batch_list\\n else:\\n quantity = Decimal(quantity) - Decimal(j.quantity)\\n batch_list.append([str(i.batch_number), str(j.quantity)])\\n print [str(i.batch_number), str(j.quantity)]\\n return False\\n except Exception:\\n if settings.level == 10:\\n logger.exception('raised exception')\\n return False\",\n \"def load_budgets():\\n\\n Budget.query.delete()\\n\\n with open(budget_file) as f:\\n for _ in range(1):\\n next(f)\\n \\n for row in f:\\n row = row.rstrip()\\n budget_data = row.split(\\\",\\\")\\n id = int(budget_data[0])\\n budget = budget_data[1]\\n category_id = budget_data[2]\\n budget_userid = budget_data[3]\\n budget_start_date = budget_data[4]\\n budget_end_date = budget_data[5]\\n\\n budget = Budget(\\n id = id,\\n budget = budget,\\n category_id = category_id,\\n budget_userid = budget_userid,\\n budget_start_date = get_datetime(budget_start_date),\\n budget_end_date = get_datetime(budget_end_date)\\n )\\n\\n db.session.add(budget)\\n\\n db.session.commit()\",\n \"def importer():\\n\\n #Lager liste der eg legg transaksjonar som blir henta og ikkje laga:\\n get_list = []\\n\\n #Gjer txt-fila i mappen om til csv-fil\\n file_fixer()\\n\\n with open(out_path) as file:\\n reader = csv.reader(file)\\n r_0 = next(reader)\\n r_0.append(\\\"type\\\")\\n r_0.append('amount')\\n r_0.append('category')\\n r_0.append('account')\\n r_0.append('project')\\n\\n\\n for row in reader:\\n #Legger til dei fire kollonenne (amount, account, subaacount, project), tomme.\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n\\n #Omformatterer rader:\\n row = format_fix(row)\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n row.append(\\\"\\\")\\n print(row)\\n\\n\\n try:\\n obj, created = Transaction.objects.get_or_create(\\n date=row[0],\\n transaction_type=row[1],\\n description=row[2],\\n amount=row[3]\\n )\\n\\n except Transaction.MultipleObjectsReturned:\\n continue\\n\\n if not created:\\n get_list.append(obj.pk)\\n\\n return get_list\",\n \"def fill_db(qty):\\n qty = int(qty)\\n click.echo('Wiping old db')\\n init_db()\\n click.echo('Initialized the db.')\\n click.echo('Inserting {} random tasks into db.'.format(qty))\\n conn = get_db()\\n c = conn.cursor()\\n for t in create_n_tasks(qty):\\n c.execute('''\\n INSERT INTO task (task_title, task_description, task_complete, task_archived)\\n VALUES ('{title}', '{desc}', {complete}, {archived})'''.format(\\n title=t[\\\"task_title\\\"],\\n desc=t[\\\"task_description\\\"],\\n complete=t[\\\"task_complete\\\"],\\n archived=t[\\\"task_archived\\\"])\\n )\\n conn.commit()\\n click.echo('Tasks inserted.')\",\n \"def handle_quantity(self, line):\\n #ok\\n\\n if line in [\\\"#c\\\", \\\"#C\\\"]:\\n self.cancel_operation()\\n return\\n try:\\n if line:\\n new_qty = self.op_data['qty']\\n #aqui tengo que escribir la nueva cantidad\\n\\n self.state = \\\"scan_location\\\"\\n message = u\\\"Scan correcto. Scanee la ubicacion\\\\n\\\"\\n message += self.get_operation_str(mode='scan_location')\\n\\n except Exception, e:\\n str_error = u\\\"Error al cambiar la cantidad %s\\\\n\\\" % line\\n self._snd(str_error + e.message)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.54053676","0.5345252","0.5009659","0.49099687","0.47605696","0.4740605","0.4696015","0.46920276","0.46907184","0.46507764","0.46204922","0.46030006","0.45985758","0.45907193","0.45657995","0.4537645","0.45328835","0.45299235","0.45244938","0.45229474","0.4498774","0.44955948","0.44879308","0.44853455","0.44819665","0.44797873","0.44786412","0.44749254","0.446228","0.44553274","0.4448397","0.4447006","0.44411093","0.44307002","0.44306883","0.44266567","0.44215843","0.4417463","0.44173732","0.44159544","0.44147813","0.44106498","0.4409639","0.4406551","0.4404315","0.43973276","0.43964294","0.43946782","0.4384488","0.43822023","0.4379116","0.4374698","0.4367934","0.4350831","0.4348034","0.43410647","0.43395922","0.4334068","0.43224037","0.4321084","0.43189913","0.43158385","0.43158063","0.4313698","0.4310996","0.43052408","0.43039897","0.4303418","0.4303162","0.4301452","0.42983064","0.42885554","0.42789766","0.42753065","0.4273044","0.42562652","0.42525136","0.42477375","0.42408746","0.42382836","0.4237062","0.42354912","0.42334726","0.42328462","0.4232755","0.42281398","0.4226125","0.42252532","0.4222131","0.42221177","0.42173284","0.42172915","0.4216904","0.42123988","0.42105126","0.4203313","0.41974974","0.419727","0.41952738","0.41947737"],"string":"[\n \"0.54053676\",\n \"0.5345252\",\n \"0.5009659\",\n \"0.49099687\",\n \"0.47605696\",\n \"0.4740605\",\n \"0.4696015\",\n \"0.46920276\",\n \"0.46907184\",\n \"0.46507764\",\n \"0.46204922\",\n \"0.46030006\",\n \"0.45985758\",\n \"0.45907193\",\n \"0.45657995\",\n \"0.4537645\",\n \"0.45328835\",\n \"0.45299235\",\n \"0.45244938\",\n \"0.45229474\",\n \"0.4498774\",\n \"0.44955948\",\n \"0.44879308\",\n \"0.44853455\",\n \"0.44819665\",\n \"0.44797873\",\n \"0.44786412\",\n \"0.44749254\",\n \"0.446228\",\n \"0.44553274\",\n \"0.4448397\",\n \"0.4447006\",\n \"0.44411093\",\n \"0.44307002\",\n \"0.44306883\",\n \"0.44266567\",\n \"0.44215843\",\n \"0.4417463\",\n \"0.44173732\",\n \"0.44159544\",\n \"0.44147813\",\n \"0.44106498\",\n \"0.4409639\",\n \"0.4406551\",\n \"0.4404315\",\n \"0.43973276\",\n \"0.43964294\",\n \"0.43946782\",\n \"0.4384488\",\n \"0.43822023\",\n \"0.4379116\",\n \"0.4374698\",\n \"0.4367934\",\n \"0.4350831\",\n \"0.4348034\",\n \"0.43410647\",\n \"0.43395922\",\n \"0.4334068\",\n \"0.43224037\",\n \"0.4321084\",\n \"0.43189913\",\n \"0.43158385\",\n \"0.43158063\",\n \"0.4313698\",\n \"0.4310996\",\n \"0.43052408\",\n \"0.43039897\",\n \"0.4303418\",\n \"0.4303162\",\n \"0.4301452\",\n \"0.42983064\",\n \"0.42885554\",\n \"0.42789766\",\n \"0.42753065\",\n \"0.4273044\",\n \"0.42562652\",\n \"0.42525136\",\n \"0.42477375\",\n \"0.42408746\",\n \"0.42382836\",\n \"0.4237062\",\n \"0.42354912\",\n \"0.42334726\",\n \"0.42328462\",\n \"0.4232755\",\n \"0.42281398\",\n \"0.4226125\",\n \"0.42252532\",\n \"0.4222131\",\n \"0.42221177\",\n \"0.42173284\",\n \"0.42172915\",\n \"0.4216904\",\n \"0.42123988\",\n \"0.42105126\",\n \"0.4203313\",\n \"0.41974974\",\n \"0.419727\",\n \"0.41952738\",\n \"0.41947737\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7534431"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":17093,"cells":{"query":{"kind":"string","value":"Assigns the cf to the mapping; does subclassspecific collision checking"},"document":{"kind":"string","value":"def _store_cf(cl, context, new_cf):\n try:\n cl.add(new_cf, key=context)\n except TypeError:\n print(type(cl))\n raise"},"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 collision(self):\n raise NotImplementedError","def applyMapping(self):\n pass","def setupCollisions(self):\n\t\tbase.cTrav = CollisionTraverser()\n\t\tself.cHandler = CollisionHandlerEvent()\n\t\t#self.cHandler.setInPattern('%fn-sped-up')\n\t\t\n\t\tcQuad = CollisionPolygon(Point3(0, 0, 0), Point3(0, 0, 10), Point3(0, 10, 10), Point3(0, 10, 0))\n\t\tcNode = CollisionNode(\"speed_boost\")\n\t\tcNode.addSolid(cQuad)\n\t\tcNodePath = self.form.attachNewNode(cNode)\n\t\tbase.cTrav.addCollider(cNodePath, self.cHandler)","def collide_with_flower(self, flower):\n pass","def setupCollisions(self) :","def is_collision_by_map_data(self):\n raise NotImplementedError","def collision(cls, other: \"entities.Entity\") -> None:\n raise NotImplementedError","def collision_detect(self):\n\n # Check if the collision was with a map\n # Rect-based collision code\n for map_rect in Map.current_map.collision_rects:\n collision_time, norm_x, norm_y = collision.aabb_swept_collision(self.rect, (self.vx, self.vy), map_rect)\n if collision_time != 1:\n if DEBUG: print(\"[collision]\", collision_time)\n break\n self.x += self.vx * collision_time\n self.y += self.vy * collision_time\n\n remaining_time = 1 - collision_time\n \"\"\"\n if remaining_time > 0:\n self.vx *= remaining_time;\n self.vy *= remaining_time;\n \"\"\"\n if collision_time != 1:\n if abs(norm_x) > .0001:\n self.vx = -self.vx * COLLISION_DAMPING\n if abs(norm_y) > .0001:\n self.vy = -self.vy * COLLISION_DAMPING\n self.collision_counter += 1\n return True\n return False\n\n # Old, mask-based collision code\n \"\"\"\n self.mask = pygame.mask.from_surface(self.image)\n point = pygame.sprite.collide_mask(Map.current_map, self)\n if point:\n if COLLISION_ALGORITHM_EXPERIMENTAL:\n self.vx, self.vy = collision.calculate_reflection_angle(Map.current_map.mask, point, (self.vx, self.vy))\n else: \n self.vx, self.vy = collision.simple_collision(Map.current_map.mask, point, (self.vx, self.vy))\n self.vx, self.vy = self.vx * COLLISION_DAMPING, self.vy * COLLISION_DAMPING\n \n self.collision_counter += 1\n return True\n return False\n \"\"\"","def constrain(self, candidate_map, processed, to_process):\n for component in self._components:\n component.constrain(candidate_map, processed, to_process)","def _manipulate_coupling(self, mappingf, prefactorf):\n\n ndata = {}\n for okey in self:\n for nkey in mappingf(okey):\n pref = prefactorf(okey, nkey)\n if math.isclose(pref, 0, rel_tol=0, abs_tol=1e-12):\n continue\n\n b = np.multiply(pref, self[okey])\n if nkey in ndata:\n ndata[nkey] += b\n else:\n ndata[nkey] = b\n self._data = ndata","def _do_mapping(self):\n pass","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CLAS').get('abstractTypes')\n exolinks = globalMap.get('CLAS').get('exolinks')\n\n # Class AbstractCategory\n currentMap = {}\n abstractTypes['AbstractCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'] = currentMap\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'\n currentMap['eType'] = 'cplx'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.AbstractCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AbstractCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AbstractCategory.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'] = currentMap\n loadMaps['CLAS.AbstractCategory.details'] = currentMap\n currentMap['tag'] = 'CLAS.AbstractCategory.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute AbstractCategory.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'] = currentMap\n loadMaps['CLAS.AbstractCategory.name'] = currentMap\n currentMap['tag'] = 'CLAS.AbstractCategory.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role AbstractCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of AbstractCategory\n\n currentMap = abstractTypes.get('AbstractCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class Classification\n currentMap = {}\n abstractTypes['Classification'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'] = currentMap\n loadMaps['CLAS.Classification'] = currentMap\n currentMap['tag'] = 'CLAS.Classification'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'classifications'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'namingSystem'\n currentMap['class'] = ccp.api.lims.Classification.Classification\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Classification.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Classification.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute Classification.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.namingSystem\n currentMap = {}\n contentMap['namingSystem'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'] = currentMap\n loadMaps['CLAS.Classification.namingSystem'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.namingSystem'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'\n currentMap['name'] = 'namingSystem'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role Classification.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role Classification.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'] = currentMap\n loadMaps['CLAS.Classification.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.experimentTypes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.hazardPhrases\n currentMap = {}\n contentMap['hazardPhrases'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'] = currentMap\n loadMaps['CLAS.Classification.hazardPhrases'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.hazardPhrases'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'\n currentMap['name'] = 'hazardPhrases'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.holderCategorys\n currentMap = {}\n contentMap['holderCategorys'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'] = currentMap\n loadMaps['CLAS.Classification.holderCategorys'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.holderCategorys'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'\n currentMap['name'] = 'holderCategorys'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.instrumentTypes\n currentMap = {}\n contentMap['instrumentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'] = currentMap\n loadMaps['CLAS.Classification.instrumentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.instrumentTypes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'\n currentMap['name'] = 'instrumentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.sampleCategories\n currentMap = {}\n contentMap['sampleCategories'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'] = currentMap\n loadMaps['CLAS.Classification.sampleCategories'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.sampleCategories'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'\n currentMap['name'] = 'sampleCategories'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.sampleComponentCategory\n currentMap = {}\n contentMap['sampleComponentCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'] = currentMap\n loadMaps['CLAS.Classification.sampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.sampleComponentCategory'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'\n currentMap['name'] = 'sampleComponentCategory'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.targetScoreboards\n currentMap = {}\n contentMap['targetScoreboards'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'] = currentMap\n loadMaps['CLAS.Classification.targetScoreboards'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.targetScoreboards'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'\n currentMap['name'] = 'targetScoreboards'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.targetStatus\n currentMap = {}\n contentMap['targetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'] = currentMap\n loadMaps['CLAS.Classification.targetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.targetStatus'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'\n currentMap['name'] = 'targetStatus'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n # End of Classification\n\n currentMap = abstractTypes.get('Classification')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\n currentMap['headerAttrs'] = aList\n aList = ['namingSystem']\n currentMap['simpleAttrs'] = aList\n aList = ['targetStatus', 'targetScoreboards', 'sampleComponentCategory', 'sampleCategories', 'instrumentTypes', 'holderCategorys', 'hazardPhrases', 'experimentTypes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['experimentTypes', 'hazardPhrases', 'holderCategorys', 'instrumentTypes', 'sampleCategories', 'sampleComponentCategory', 'targetScoreboards', 'targetStatus']\n currentMap['children'] = aList\n\n # Class SampleComponentCategory\n currentMap = {}\n abstractTypes['SampleComponentCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'] = currentMap\n loadMaps['CLAS.SampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.SampleComponentCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'sampleComponentCategory'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute SampleComponentCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute SampleComponentCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute SampleComponentCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role SampleComponentCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of SampleComponentCategory\n\n currentMap = abstractTypes.get('SampleComponentCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ExperimentType\n currentMap = {}\n abstractTypes['ExperimentType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'] = currentMap\n loadMaps['CLAS.ExperimentType'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'experimentTypes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ExperimentType.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ExperimentType.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute ExperimentType.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role ExperimentType.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ExperimentType.instrumentTypes\n currentMap = {}\n contentMap['instrumentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'] = currentMap\n loadMaps['CLAS.ExperimentType.instrumentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType.instrumentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'\n currentMap['name'] = 'instrumentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n\n # Role ExperimentType.sampleCategories\n currentMap = {}\n contentMap['sampleCategories'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'] = currentMap\n loadMaps['CLAS.ExperimentType.sampleCategories'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType.sampleCategories'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'\n currentMap['name'] = 'sampleCategories'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of ExperimentType\n\n currentMap = abstractTypes.get('ExperimentType')\n aList = ['details', 'name', 'instrumentTypes', 'sampleCategories']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class TargetScoreboard\n currentMap = {}\n abstractTypes['TargetScoreboard'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'] = currentMap\n loadMaps['CLAS.TargetScoreboard'] = currentMap\n currentMap['tag'] = 'CLAS.TargetScoreboard'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'targetScoreboards'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute TargetScoreboard.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute TargetScoreboard.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute TargetScoreboard.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role TargetScoreboard.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role TargetScoreboard.targetStatus\n currentMap = {}\n contentMap['targetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'] = currentMap\n loadMaps['CLAS.TargetScoreboard.targetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.TargetScoreboard.targetStatus'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'\n currentMap['name'] = 'targetStatus'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of TargetScoreboard\n\n currentMap = abstractTypes.get('TargetScoreboard')\n aList = ['details', 'name', 'targetStatus']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class HolderCategory\n currentMap = {}\n abstractTypes['HolderCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'] = currentMap\n loadMaps['CLAS.HolderCategory'] = currentMap\n currentMap['tag'] = 'CLAS.HolderCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'holderCategorys'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute HolderCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute HolderCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute HolderCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role HolderCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of HolderCategory\n\n currentMap = abstractTypes.get('HolderCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class HazardPhrase\n currentMap = {}\n abstractTypes['HazardPhrase'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'] = currentMap\n loadMaps['CLAS.HazardPhrase'] = currentMap\n currentMap['tag'] = 'CLAS.HazardPhrase'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'hazardPhrases'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute HazardPhrase.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute HazardPhrase.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute HazardPhrase.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Attribute HazardPhrase.phrase\n currentMap = {}\n contentMap['phrase'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'] = currentMap\n loadMaps['CLAS.HazardPhrase.phrase'] = currentMap\n currentMap['tag'] = 'CLAS.HazardPhrase.phrase'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'\n currentMap['name'] = 'phrase'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Role HazardPhrase.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of HazardPhrase\n\n currentMap = abstractTypes.get('HazardPhrase')\n aList = ['details', 'name', 'phrase']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class InstrumentType\n currentMap = {}\n abstractTypes['InstrumentType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'] = currentMap\n loadMaps['CLAS.InstrumentType'] = currentMap\n currentMap['tag'] = 'CLAS.InstrumentType'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'instrumentTypes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute InstrumentType.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute InstrumentType.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute InstrumentType.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role InstrumentType.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role InstrumentType.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'] = currentMap\n loadMaps['CLAS.InstrumentType.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.InstrumentType.experimentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of InstrumentType\n\n currentMap = abstractTypes.get('InstrumentType')\n aList = ['details', 'name', 'experimentTypes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class SampleCategory\n currentMap = {}\n abstractTypes['SampleCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'] = currentMap\n loadMaps['CLAS.SampleCategory'] = currentMap\n currentMap['tag'] = 'CLAS.SampleCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'sampleCategories'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute SampleCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute SampleCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute SampleCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role SampleCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role SampleCategory.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'] = currentMap\n loadMaps['CLAS.SampleCategory.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.SampleCategory.experimentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of SampleCategory\n\n currentMap = abstractTypes.get('SampleCategory')\n aList = ['details', 'name', 'experimentTypes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class TargetStatus\n currentMap = {}\n abstractTypes['TargetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'] = currentMap\n loadMaps['CLAS.TargetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.TargetStatus'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'targetStatus'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute TargetStatus.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute TargetStatus.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute TargetStatus.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role TargetStatus.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role TargetStatus.targetScoreboards\n currentMap = {}\n contentMap['targetScoreboards'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'] = currentMap\n loadMaps['CLAS.TargetStatus.targetScoreboards'] = currentMap\n currentMap['tag'] = 'CLAS.TargetStatus.targetScoreboards'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'\n currentMap['name'] = 'targetScoreboards'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of TargetStatus\n\n currentMap = abstractTypes.get('TargetStatus')\n aList = ['details', 'name', 'targetScoreboards']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to Classification\n currentMap = {}\n exolinks['Classification'] = currentMap\n loadMaps['CLAS.exo-Classification'] = currentMap\n currentMap['tag'] = 'CLAS.exo-Classification'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\n currentMap['name'] = 'Classification'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.Classification\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to SampleComponentCategory\n currentMap = {}\n exolinks['SampleComponentCategory'] = currentMap\n loadMaps['CLAS.exo-SampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-SampleComponentCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\n currentMap['name'] = 'SampleComponentCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to ExperimentType\n currentMap = {}\n exolinks['ExperimentType'] = currentMap\n loadMaps['CLAS.exo-ExperimentType'] = currentMap\n currentMap['tag'] = 'CLAS.exo-ExperimentType'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\n currentMap['name'] = 'ExperimentType'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to TargetScoreboard\n currentMap = {}\n exolinks['TargetScoreboard'] = currentMap\n loadMaps['CLAS.exo-TargetScoreboard'] = currentMap\n currentMap['tag'] = 'CLAS.exo-TargetScoreboard'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\n currentMap['name'] = 'TargetScoreboard'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to HolderCategory\n currentMap = {}\n exolinks['HolderCategory'] = currentMap\n loadMaps['CLAS.exo-HolderCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-HolderCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\n currentMap['name'] = 'HolderCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to HazardPhrase\n currentMap = {}\n exolinks['HazardPhrase'] = currentMap\n loadMaps['CLAS.exo-HazardPhrase'] = currentMap\n currentMap['tag'] = 'CLAS.exo-HazardPhrase'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\n currentMap['name'] = 'HazardPhrase'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to InstrumentType\n currentMap = {}\n exolinks['InstrumentType'] = currentMap\n loadMaps['CLAS.exo-InstrumentType'] = currentMap\n currentMap['tag'] = 'CLAS.exo-InstrumentType'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\n currentMap['name'] = 'InstrumentType'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to SampleCategory\n currentMap = {}\n exolinks['SampleCategory'] = currentMap\n loadMaps['CLAS.exo-SampleCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-SampleCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\n currentMap['name'] = 'SampleCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to TargetStatus\n currentMap = {}\n exolinks['TargetStatus'] = currentMap\n loadMaps['CLAS.exo-TargetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.exo-TargetStatus'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\n currentMap['name'] = 'TargetStatus'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))","def limitByMapCollision(self,basemap,fontname='Bitstream Vera Sans',fontsize=10.0):\n if basemap.ax is None:\n raise DataSetException('Basemap is missing a reference to an \"axes\" object.')\n ax = basemap.ax\n\n #get the transformation from display units (pixels) to data units\n #we'll use this to set an offset in pixels between the city dot and\n #the city name.\n self._display_to_data_transform = ax.transData.inverted()\n \n self.project(basemap)\n if 'x' not in self._dataframe.columns and 'y' not in self._dataframe.columns:\n raise DataSetException('Cities object has not had project() called yet.')\n \n if fontname not in self._fontlist:\n raise DataSetException('Font %s not in supported list.' % fontname)\n #TODO: - check placement column\n newdf = self._dataframe.copy()\n #older versions of pandas use a different sort function\n if pd.__version__ < '0.17.0':\n newdf = newdf.sort(columns='pop',ascending=False)\n else:\n newdf = newdf.sort_values(by='pop',ascending=False)\n\n lefts,rights,bottoms,tops = self._getCityBoundingBoxes(newdf,fontname,fontsize,ax)\n ikeep = ~np.isnan(lefts)\n newdf = newdf.iloc[ikeep]\n lefts = lefts[ikeep]\n rights = rights[ikeep]\n bottoms = bottoms[ikeep]\n tops = tops[ikeep]\n ikeep = [0] #indices of rows to keep in dataframe\n for i in range(1,len(tops)):\n cname = newdf.iloc[i]['name']\n if cname.lower().find('pacific grove') > -1:\n allnames = newdf['name'].tolist()\n sidx = allnames.index('Salinas')\n sleft = lefts[sidx]\n sright = rights[sidx]\n sbottom = bottoms[sidx]\n stop = tops[sidx]\n foo = 1\n if np.isnan(lefts[i]):\n continue\n left = lefts[i]\n right = rights[i]\n bottom = bottoms[i]\n top = tops[i]\n\n clrx = (left > rights[0:i]) | (right < lefts[0:i])\n clry = (top < bottoms[0:i]) | (bottom > tops[0:i])\n allclr = (clrx | clry)\n if all(allclr):\n ikeep.append(i)\n else:\n foo = 1\n if len(newdf):\n try:\n newdf = newdf.iloc[ikeep]\n newdf['top'] = tops[ikeep]\n newdf['bottom'] = bottoms[ikeep]\n newdf['left'] = lefts[ikeep]\n newdf['right'] = rights[ikeep]\n except Exception as e:\n x = 1\n return type(self)(newdf)","def collide(self, pos):\n\t\tpass","def _fit_exact_match(self):\n entity_map = self._resource_loader.get_entity_map(self.type)\n self._exact_match_mapping = self._process_entity_map(\n self.type, entity_map, self._normalizer\n )","def on_collision(self, other_sprite, game):\n pass","def check_collide(self): #New of Rev2.0\r\n for pizza in self.overlapping_sprites:\r\n self.score.value +=50 #Incr. score by 50\r\n pizza.handle_collide()","def _check_mapping(self) -> PossibleResult[T]:\n if isinstance(self.constructor_origin, type) and issubclass(\n self.constructor_origin, Mapping\n ):\n if not isinstance(self.obj, Mapping):\n raise DeserializeError(\n Mapping, self.obj, self.new_depth, self.key\n )\n if self.constructor_args:\n _tpkey = self.constructor_args[0]\n _tpvalue = self.constructor_args[1]\n else:\n _tpkey = Any # type: ignore\n _tpvalue = Any # type: ignore\n return self.constructor_origin(\n {\n Deserialize(\n obj=key,\n constructor=_tpkey,\n depth=self.new_depth,\n convert_primitives=self.convert_primitives,\n )\n .run(): Deserialize(\n obj=value,\n constructor=_tpvalue,\n depth=self.new_depth,\n convert_primitives=self.convert_primitives,\n key=key,\n )\n .run()\n for key, value in self.obj.items()\n }\n ) # type: ignore\n return NO_RESULT","def collision_check(self):\n return True","def manageCollisions(cls, source, to):\n to.triggerCollision(source)\n logging.debug(\"%s sprite collided with %s\" % (source, to))","def _configure(self):\n from .topology import FieldBase\n\n Component._configure(self)\n\n mapBasis = {\n \"simplex\": FieldBase.SIMPLEX_BASIS,\n \"tensor\": FieldBase.TENSOR_BASIS,\n \"default\": FieldBase.DEFAULT_BASIS,\n }\n self.cellBasis = mapBasis[self.inventory.cellBasisStr]\n\n mapSpace = {\n \"polynomial\": FieldBase.POLYNOMIAL_SPACE,\n \"point\": FieldBase.POINT_SPACE,\n }\n self.feSpace = mapSpace[self.inventory.feSpaceStr]\n return","def set_factors(self, name, factormap, safe=False):\n e = False\n if name in self.masks():\n if self._get_subtype(name) != 'single':\n e = True\n else:\n if self._get_type(name) != 'single':\n e = True\n if e:\n if safe:\n err = \"Can only set factors to 'single' type categorical variables!\"\n raise TypeError(err)\n else:\n return None\n vals = self.codes(name)\n facts = list(factormap.keys())\n val_loc = self._get_value_loc(name)\n if not all(f in vals for f in facts):\n err = 'At least one factor is mapped to a code that does not exist '\n err += 'in the values object of \"{}\"!'\n raise ValueError(err.format(name))\n for value in val_loc:\n if value['value'] in factormap:\n value['factor'] = factormap[value['value']]\n else:\n value['factor'] = None\n return None","def collide(self, other, extra=None):\n pass","def __call__(\n self,\n dsk: Mapping,\n *args: Any,\n rename: Mapping[str, str] | None = None,\n ) -> CollType_co:\n raise NotImplementedError(\"Inheriting class must implement this method.\")","def process_collision(self, obj, target):\n if obj == \"small_hex\" and not self.smallhex.small_hex_flag:\n self.ship.velocity.x = -self.ship.velocity.x\n self.ship.velocity.y = -self.ship.velocity.y\n self.gameevents.add(\"score-\", \"pnts\", self.config['Score']['small_hex_penalty'])\n self.gameevents.add(\"score-\", \"flight\", self.config['Score']['small_hex_penalty'])\n self.smallhex.small_hex_flag = True\n elif obj == \"shell\":\n #remove shell, target is index of shell in shell_list\n del self.shell_list[target]\n self.gameevents.add(\"score-\", \"pnts\", self.config['Score']['shell_hit_penalty'])\n self.gameevents.add(\"score-\", \"fortress\", self.config['Score']['shell_hit_penalty'])\n self.ship.take_damage()\n if not self.ship.alive:\n self.gameevents.add(\"destroyed\", \"ship\", \"shell\")\n self.gameevents.add(\"score-\", \"pnts\", self.config['Score']['ship_death_penalty'])\n self.gameevents.add(\"score-\", \"fortress\", self.config['Score']['ship_death_penalty'])\n self.ship.color = (255, 255, 0)\n elif self.config['Ship']['colored_damage']:\n g = 255 / self.ship.start_health * (self.ship.health - 1)\n self.ship.color = (255, g, 0)\n\n elif obj.startswith(\"missile_\"):\n #if missile hits fortress, need to check if it takes damage when mine is onscreen\n if target == \"fortress\" and (len(self.mine_list) == 0 or self.config['Fortress']['hit_fortress_while_mine']):\n if self.ship.shot_timer.elapsed() >= self.config['Fortress']['vlner_time']:\n self.gameevents.add(\"score+\", \"vlner\", 1)\n if self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner >= self.config['Fortress']['vlner_threshold']:\n self.gameevents.add(\"destroyed\", \"fortress\")\n self.fortress.alive = False\n #r = choice([0,45,90,135,180,225,270,315])\n #if r:\n # self.explosion.rotate(r)\n self.fortress.reset_timer.reset()\n self.snd_explosion.play()\n self.gameevents.add(\"score+\", \"pnts\", self.config['Score']['destroy_fortress'])\n self.gameevents.add(\"score+\", \"fortress\", self.config['Score']['destroy_fortress'])\n self.score.vlner = 0\n self.destroyedFortresses += 1\n self.gameevents.add(\"reset\", \"VLNER\")\n #do we reset the mine timer?\n if self.config['Mine']['fortress_resets_mine']:\n self.mine_list.timer.reset()\n self.mine_list.flag = False\n elif self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner < self.config['Fortress']['vlner_threshold']:\n self.gameevents.add(\"reset\", \"VLNER\")\n self.score.vlner = 0\n self.snd_vlner_reset.play()\n self.ship.shot_timer.reset()\n elif target.startswith(\"mine_\"):\n #deal with missile hitting mine\n #can the mine be hit?\n if len(self.mine_list) > 0:\n if self.mine_list[0].tagged == \"fail\":\n self.gameevents.add(\"collide\", \"fail_tagged_mine\")\n elif self.mine_list[0].tagged == \"disabled\":\n self.gameevents.add(\"collide\", \"disable_tagged_mine\")\n elif self.mine_list[0].tagged == \"untagged\":\n if self.score.iff in self.mine_list.foe_letters:\n self.mine_list[0].tagged = \"disable\"\n self.gameevents.add(\"collide\", \"untagged_foe_mine\")\n else:\n self.gameevents.add(\"collide\", \"friend_mine\")\n elif self.mine_list[0].tagged == \"tagged\" and self.score.iff in self.mine_list.foe_letters:\n self.gameevents.add(\"collide\", \"tagged_foe_mine\")\n elif obj.startswith(\"mine_\"):\n #mine hit the ship\n index = int(obj[-1])\n #check to see if mine is still alive, it is possible to shot and\n #collide with a mine at the same time, ties go to ship\n if index < len(self.mine_list):\n del self.mine_list[index]\n self.score.iff = ''\n self.score.intrvl = 0\n self.mine_list.flag = False\n self.mine_list.iff_flag = False\n self.mine_list.timer.reset()\n self.gameevents.add(\"score-\", \"pnts\", self.config['Score']['mine_hit_penalty'])\n self.gameevents.add(\"score-\", \"mines\", self.config['Score']['mine_hit_penalty'])\n self.mine2 -= self.config['Score']['mine_hit_penalty']\n self.ship.take_damage()\n if not self.ship.alive:\n self.gameevents.add(\"destroyed\", \"ship\", \"mine\")\n self.gameevents.add(\"score-\", \"pnts\", self.config['Score']['ship_death_penalty'])\n self.gameevents.add(\"score-\", \"mines\", self.config['Score']['ship_death_penalty'])\n self.mine2 -= self.config['Score']['ship_death_penalty']\n self.ship.color = (255, 255, 0)\n elif self.config['Ship']['colored_damage']:\n g = 255 / self.ship.start_health * (self.ship.health - 1)\n self.ship.color = (255, g, 0)\n elif obj == \"friend_mine\":\n #get rid of mine\n self.destroyedMines += 1\n self.mine_list.flag = False\n self.mine_list.iff_flag = False\n self.gameevents.add(\"score+\", \"mines\", self.config['Score']['energize_friend'])\n self.gameevents.add(\"score+\", \"pnts\", self.config['Score']['energize_friend'])\n #see how long mine has been alive. 0-100 points if destroyed within 10 seconds\n self.gameevents.add(\"score+\", \"mines\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\n self.gameevents.add(\"score+\", \"speed\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\n #print self.mine_list.timer.elapsed()\n #print 100 - 10 * math.floor(self.mine_list.timer.elapsed()/1000)\n self.mine_list.timer.reset()\n self.mine2 += 50\n #amazingly, missile can hit the mine in the same frame as the mine hits the ship\n if len(self.mine_list) > 0:\n del self.mine_list[0]\n self.score.iff = ''\n self.score.intrvl = 0\n elif obj == \"tagged_foe_mine\":\n #get rid of mine\n self.destroyedMines += 1\n self.mine_list.flag = False\n self.mine_list.iff_flag = False\n self.gameevents.add(\"score+\", \"mines\", self.config['Score']['destroy_foe'])\n self.gameevents.add(\"score+\", \"pnts\", self.config['Score']['destroy_foe'])\n #see how long mine has been alive. 0-100 points if destroyed within 10 seconds\n self.gameevents.add(\"score+\", \"mines\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\n self.gameevents.add(\"score+\", \"speed\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\n self.mine_list.timer.reset()\n self.mine2 += 75\n if len(self.mine_list) > 0:\n del self.mine_list[0]\n self.score.iff = ''\n self.score.intrvl = 0","def on_collision(self):","def _update_farness_map(self,ind):","def __init__(self):\n\n for layer in self._layer_class_map:\n setattr(self, layer, self._layer_class_map[layer]())","def _init_from_dict(self, cfg):\n if self.top_level:\n # this is a top level domain\n self.parent_cell_size_ratio = 1\n self.parent_time_step_ratio = 1\n self.cell_size = tuple(cfg['cell_size'])\n self.ref_latlon = tuple(cfg['center_latlon'])\n self.domain_size = tuple(cfg['domain_size'])\n self.time_step = cfg.get('time_step', int(max(6*min(self.domain_size) // 1000, 1)))\n self.parent_start = (1,1)\n if 'truelats' in cfg:\n self.truelats = cfg['truelats']\n else:\n self.truelats = [self.ref_lat]*2\n if 'stand_lon' in cfg:\n self.stand_lon = cfg['stand_lon']\n else:\n self.stand_lon = self.ref_lon\n self._init_projection()\n else:\n self.parent_cell_size_ratio = cfg['parent_cell_size_ratio']\n self.parent_time_step_ratio = cfg['parent_time_step_ratio']\n self.cell_size = [float(x) / self.parent_cell_size_ratio for x in self.parent.cell_size]\n if 'bounding_box' in cfg:\n # this is a child domain that we need to place dynamically given a bounding box\n self.bbox = tuple(cfg['bounding_box'])\n\n min_lon, min_lat, max_lon, max_lat = self.bbox\n\n # project the min/max coordinates\n i1, j1 = self.parent.latlon_to_ij(min_lat, min_lon)\n i2, j2 = self.parent.latlon_to_ij(max_lat, max_lon)\n\n self.parent_start = (int(i1), int(j1))\n self.parent_end = (int(i2+1), int(j2+1))\n\n if any([x < 0 for x in self.parent_start]) or \\\n self.parent_end[0] >= self.parent.domain_size[0] or \\\n self.parent_end[1] >= self.parent.domain_size[1]:\n raise ValueError('Cannot place child, out of parents bounds')\n\n pstart, pend, pgr = self.parent_start, self.parent_end, self.parent_cell_size_ratio\n self.domain_size = (pgr * (pend[0] - pstart[0] + 1) + 1, pgr * (pend[1] - pstart[1] + 1) + 1)\n elif 'parent_start' in cfg and 'parent_end' in cfg:\n # this is a child domain, placed normally\n self.parent_start = tuple(cfg['parent_start'])\n self.parent_end = tuple(cfg['parent_end'])\n pstart, pend, pgr = self.parent_start, self.parent_end, self.parent_cell_size_ratio\n self.domain_size = (pgr * (pend[0] - pstart[0] + 1) + 1, pgr * (pend[1] - pstart[1] + 1) + 1)\n else:\n raise ValueError('Invalid domain specification')\n\n # either way, it's not precomputed\n self.precomputed = False","def __init__(self, map):\n self.map = map\n self.fast_validate = (6, map)","def add_collision_mask(prim: Usd.Prim):\n collisionAPI = PhysicsSchema.CollisionAPI.Apply(prim)\n collisionAPI.CreatePhysicsMaterialRel()\n collisionAPI.CreateCollisionGroupRel()","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CHEL').get('abstractTypes')\n exolinks = globalMap.get('CHEL').get('exolinks')\n\n # DataType HalfLifeType\n currentMap = {}\n abstractTypes['HalfLifeType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'] = currentMap\n loadMaps['CHEL.HalfLifeType'] = currentMap\n currentMap['tag'] = 'CHEL.HalfLifeType'\n currentMap['type'] = 'simple'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'\n currentMap['toStr'] = 'text'\n currentMap['cnvrt'] = 'text'\n\n # Class ChemElement\n currentMap = {}\n abstractTypes['ChemElement'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'] = currentMap\n loadMaps['CHEL.ChemElement'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemElements'\n currentMap['objkey'] = 'symbol'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemElement.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemElement.atomNumber\n currentMap = {}\n contentMap['atomNumber'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'] = currentMap\n loadMaps['CHEL.ChemElement.atomNumber'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.atomNumber'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'\n currentMap['name'] = 'atomNumber'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['proc'] = 'direct'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute ChemElement.atomicRadius\n currentMap = {}\n contentMap['atomicRadius'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'] = currentMap\n loadMaps['CHEL.ChemElement.atomicRadius'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.atomicRadius'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'\n currentMap['name'] = 'atomicRadius'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.covalentRadius\n currentMap = {}\n contentMap['covalentRadius'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'] = currentMap\n loadMaps['CHEL.ChemElement.covalentRadius'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.covalentRadius'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'\n currentMap['name'] = 'covalentRadius'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.mass\n currentMap = {}\n contentMap['mass'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'] = currentMap\n loadMaps['CHEL.ChemElement.mass'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.mass'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'\n currentMap['name'] = 'mass'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'] = currentMap\n loadMaps['CHEL.ChemElement.name'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\n\n # Attribute ChemElement.symbol\n currentMap = {}\n contentMap['symbol'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'] = currentMap\n loadMaps['CHEL.ChemElement.symbol'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.symbol'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'\n currentMap['name'] = 'symbol'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\n\n # Role ChemElement.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemElement.isotopes\n currentMap = {}\n contentMap['isotopes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'] = currentMap\n loadMaps['CHEL.ChemElement.isotopes'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.isotopes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'\n currentMap['name'] = 'isotopes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\n # End of ChemElement\n\n currentMap = abstractTypes.get('ChemElement')\n aList = ['atomNumber', 'atomicRadius', 'covalentRadius', 'mass', 'name', 'symbol']\n currentMap['headerAttrs'] = aList\n aList = ['isotopes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['isotopes']\n currentMap['children'] = aList\n\n # Class ChemElementStore\n currentMap = {}\n abstractTypes['ChemElementStore'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'] = currentMap\n loadMaps['CHEL.ChemElementStore'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemElementStores'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemElementStore.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemElementStore.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute ChemElementStore.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'] = currentMap\n loadMaps['CHEL.ChemElementStore.name'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role ChemElementStore.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemElementStore.chemElements\n currentMap = {}\n contentMap['chemElements'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'] = currentMap\n loadMaps['CHEL.ChemElementStore.chemElements'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore.chemElements'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'\n currentMap['name'] = 'chemElements'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\n # End of ChemElementStore\n\n currentMap = abstractTypes.get('ChemElementStore')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\n currentMap['headerAttrs'] = aList\n aList = ['name']\n currentMap['simpleAttrs'] = aList\n aList = ['chemElements', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['chemElements']\n currentMap['children'] = aList\n\n # Class Isotope\n currentMap = {}\n abstractTypes['Isotope'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'] = currentMap\n loadMaps['CHEL.Isotope'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'isotopes'\n currentMap['objkey'] = 'massNumber'\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Isotope.abundance\n currentMap = {}\n contentMap['abundance'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'] = currentMap\n loadMaps['CHEL.Isotope.abundance'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.abundance'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'\n currentMap['name'] = 'abundance'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00058')\n\n # Attribute Isotope.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Isotope.gyroMagneticRatio\n currentMap = {}\n contentMap['gyroMagneticRatio'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'] = currentMap\n loadMaps['CHEL.Isotope.gyroMagneticRatio'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.gyroMagneticRatio'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'\n currentMap['name'] = 'gyroMagneticRatio'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.halfLife\n currentMap = {}\n contentMap['halfLife'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'] = currentMap\n loadMaps['CHEL.Isotope.halfLife'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLife'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'\n currentMap['name'] = 'halfLife'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\n\n # Attribute Isotope.halfLifeError\n currentMap = {}\n contentMap['halfLifeError'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'] = currentMap\n loadMaps['CHEL.Isotope.halfLifeError'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLifeError'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'\n currentMap['name'] = 'halfLifeError'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\n\n # Attribute Isotope.halfLifeType\n currentMap = {}\n contentMap['halfLifeType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'] = currentMap\n loadMaps['CHEL.Isotope.halfLifeType'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLifeType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'\n currentMap['name'] = 'halfLifeType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'unknown'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002')\n\n # Attribute Isotope.magneticMoment\n currentMap = {}\n contentMap['magneticMoment'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'] = currentMap\n loadMaps['CHEL.Isotope.magneticMoment'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.magneticMoment'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'\n currentMap['name'] = 'magneticMoment'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.mass\n currentMap = {}\n contentMap['mass'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'] = currentMap\n loadMaps['CHEL.Isotope.mass'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.mass'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'\n currentMap['name'] = 'mass'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.massNumber\n currentMap = {}\n contentMap['massNumber'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'] = currentMap\n loadMaps['CHEL.Isotope.massNumber'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.massNumber'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'\n currentMap['name'] = 'massNumber'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Isotope.quadrupoleMoment\n currentMap = {}\n contentMap['quadrupoleMoment'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'] = currentMap\n loadMaps['CHEL.Isotope.quadrupoleMoment'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.quadrupoleMoment'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'\n currentMap['name'] = 'quadrupoleMoment'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.receptivity\n currentMap = {}\n contentMap['receptivity'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'] = currentMap\n loadMaps['CHEL.Isotope.receptivity'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.receptivity'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'\n currentMap['name'] = 'receptivity'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.spin\n currentMap = {}\n contentMap['spin'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'] = currentMap\n loadMaps['CHEL.Isotope.spin'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.spin'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'\n currentMap['name'] = 'spin'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role Isotope.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of Isotope\n\n currentMap = abstractTypes.get('Isotope')\n aList = ['abundance', 'gyroMagneticRatio', 'halfLife', 'halfLifeError', 'halfLifeType', 'magneticMoment', 'mass', 'massNumber', 'quadrupoleMoment', 'receptivity', 'spin']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to ChemElement\n currentMap = {}\n exolinks['ChemElement'] = currentMap\n loadMaps['CHEL.exo-ChemElement'] = currentMap\n currentMap['tag'] = 'CHEL.exo-ChemElement'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\n currentMap['name'] = 'ChemElement'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\n\n # Out-of-package link to ChemElementStore\n currentMap = {}\n exolinks['ChemElementStore'] = currentMap\n loadMaps['CHEL.exo-ChemElementStore'] = currentMap\n currentMap['tag'] = 'CHEL.exo-ChemElementStore'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\n currentMap['name'] = 'ChemElementStore'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to Isotope\n currentMap = {}\n exolinks['Isotope'] = currentMap\n loadMaps['CHEL.exo-Isotope'] = currentMap\n currentMap['tag'] = 'CHEL.exo-Isotope'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\n currentMap['name'] = 'Isotope'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))","def test_fibermap_rw(self):\n from ..io.fibermap import empty_fibermap, read_fibermap, write_fibermap\n fibermap = empty_fibermap(10)\n for key in fibermap.dtype.names:\n column = fibermap[key]\n fibermap[key] = np.random.random(column.shape).astype(column.dtype)\n\n write_fibermap(self.testfile, fibermap)\n\n fm = read_fibermap(self.testfile)\n self.assertTrue(isinstance(fm, Table))\n\n self.assertEqual(set(fibermap.dtype.names), set(fm.dtype.names))\n for key in fibermap.dtype.names:\n c1 = fibermap[key]\n c2 = fm[key]\n #- Endianness may change, but kind, size, shape, and values are same\n self.assertEqual(c1.shape, c2.shape)\n self.assertTrue(np.all(c1 == c2))\n if c1.dtype.kind == 'U':\n self.assertTrue(c2.dtype.kind in ('S', 'U'))\n else:\n self.assertEqual(c1.dtype.kind, c2.dtype.kind)\n self.assertEqual(c1.dtype.itemsize, c2.dtype.itemsize)\n\n #- read_fibermap also works with open file pointer\n with fitsio.FITS(self.testfile) as fp:\n fm1 = read_fibermap(fp)\n self.assertTrue(np.all(fm1 == fm))\n\n with fits.open(self.testfile) as fp:\n fm2 = read_fibermap(fp)\n self.assertTrue(np.all(fm2 == fm))","def _standard_mapping(self):\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\n self.camvidMap = mapping_raw['camvidMap'] * 255\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255","def _add_force(Fg: np.ndarray, dof_map: Dict[Tuple[int, int], int], model: BDF,\n load, offset: int, ndof_per_grid: int, cid: int=0, show_warning: bool=True):\n #cid = load.cid\n nid = load.node\n node_ref = load.node_ref\n ndofi = ndof_per_grid if node_ref.type == 'GRID' else 1\n assert ndofi == 6, f'GRID must have 6 DOF for structural analysis\\n{node_ref}'\n\n if node_ref.cd == cid:\n fglobal = load.mag * load.xyz\n elif node_ref.cd != cid:\n fbasic = load.to_global()\n if show_warning:\n model.log.warning(f'differing cid & cd is not supported; cid={cid} cd={node_ref.cd}')\n show_warning = False\n cd_ref = node_ref.cd_ref\n Tbg = cd_ref.beta()\n fglobal = _force_to_local(cd_ref, fbasic)\n\n if 0: # pragma: no cover\n if cd_ref.type[-1] in ['C', 'S']:\n ex = Tbg[0, :]\n ey = Tbg[1, :]\n #ez = Tbg[2, :]\n xyz_local = node_ref.get_position_wrt(model, node_ref.cd)\n if cd_ref.type[-1] == 'C':\n theta = radians(xyz_local[1])\n ct = cos(theta)\n st = sin(theta)\n T = np.array([\n [ct, -st, 0.],\n [st, ct, 0.],\n [0., 0., 1.],\n ])\n Tbg = Tbg @ T\n else:\n from pyNastran.bdf.cards.coordinate_systems import CORD2S\n rho, thetad, phid = xyz_local\n coord = CORD2S.add_ijk(-1, origin=cd_ref.origin, i=ex, j=ey, k=None, rid=0, comment='')\n beta = coord.beta()\n Tbg = Tbg @ beta\n coord.transform_vector_to_local([rho, thetad, phid])\n #theta = radians(xyz_local[1])\n #phi = radians(xyz_local[2])\n #ct = cos(theta)\n #st = sin(theta)\n\n #cp = cos(phi)\n #sp = sin(phi)\n\n str(xyz_local)\n else:\n # rectangular\n pass\n Tgb = Tbg.T\n fglobal = Tgb @ fbasic\n else:\n raise NotImplementedError(f'node_ref.cd={node_ref.cd} cid={cid} load:\\n{str(load)}')\n\n for dof in range(3):\n irow = dof_map[(nid, dof+offset)]\n Fg[irow] += fglobal[dof]\n return show_warning","def __init__(self, size:Point, **kwargs):\n PhysicsEntity.__init__(self, **kwargs)\n self.size = size\n self.collision_shape = to_collision_rect(self.size)","def __init__(self, word_fd, bigram_fd, wildcard_fd, trigram_fd):\n AbstractCollocationFinder.__init__(self, word_fd, trigram_fd)\n self.wildcard_fd = wildcard_fd\n self.bigram_fd = bigram_fd","def start_collision_handlers(self):\n self.missile_and_terrain.begin = self.missile_terrain_collision_begin\n self.missile_and_spacecraft_handler.begin = self.missile_spacecraft_collision_begin\n self.spacecraft_and_terrain_handler.begin = self.spacecraft_terrain_collision_begin\n\n self.missile_and_spacecraft_handler.pre_solve = self.collision_pre\n self.missile_and_spacecraft_handler.post_solve = self.collision_post_solve\n self.missile_and_spacecraft_handler.separate = self.collision_separate\n self.missile_and_terrain.pre_solve = self.collision_pre\n self.missile_and_terrain.post_solve = self.collision_post_solve\n self.missile_and_terrain.separate = self.collision_separate\n self.spacecraft_and_terrain_handler.pre_solve = self.collision_pre\n self.spacecraft_and_terrain_handler.post_solve = self.collision_post_solve\n self.spacecraft_and_terrain_handler.separate = self.collision_separate","def check_collide(self):\n\n\t\tfor pizza in self.overlapping_sprites:\n\t\t\tpizza.handle_collide()","def update(self, f):\n\n for p in self.__mapper__.attrs:\n\n if p.key == 'oid':\n continue\n try:\n setattr(self, p.key, getattr(f, p.key))\n\n except AttributeError:\n # The dict() method copies data property values into the main dict,\n # and these don't have associated class properties.\n continue","def update(self, f):\n\n for p in self.__mapper__.attrs:\n\n if p.key == 'oid':\n continue\n try:\n setattr(self, p.key, getattr(f, p.key))\n\n except AttributeError:\n # The dict() method copies data property values into the main dict,\n # and these don't have associated class properties.\n continue","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CCLB').get('abstractTypes')\n exolinks = globalMap.get('CCLB').get('exolinks')\n\n # Class AtomLabel\n currentMap = {}\n abstractTypes['AtomLabel'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'] = currentMap\n loadMaps['CCLB.AtomLabel'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'atomLabels'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AtomLabel.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AtomLabel.isotopeCode\n currentMap = {}\n contentMap['isotopeCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'] = currentMap\n loadMaps['CCLB.AtomLabel.isotopeCode'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.isotopeCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'\n currentMap['name'] = 'isotopeCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AtomLabel.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'] = currentMap\n loadMaps['CCLB.AtomLabel.name'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AtomLabel.subType\n currentMap = {}\n contentMap['subType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'] = currentMap\n loadMaps['CCLB.AtomLabel.subType'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.subType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'\n currentMap['name'] = 'subType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['default'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute AtomLabel.weight\n currentMap = {}\n contentMap['weight'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'] = currentMap\n loadMaps['CCLB.AtomLabel.weight'] = currentMap\n currentMap['tag'] = 'CCLB.AtomLabel.weight'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'\n currentMap['name'] = 'weight'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 1.0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\n\n # Role AtomLabel.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of AtomLabel\n\n currentMap = abstractTypes.get('AtomLabel')\n aList = ['isotopeCode', 'name', 'subType', 'weight']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ChemCompLabel\n currentMap = {}\n abstractTypes['ChemCompLabel'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'] = currentMap\n loadMaps['CCLB.ChemCompLabel'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemCompLabels'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemCompLabel.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemCompLabel.ccpCode\n currentMap = {}\n contentMap['ccpCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'] = currentMap\n loadMaps['CCLB.ChemCompLabel.ccpCode'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.ccpCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'\n currentMap['name'] = 'ccpCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ChemCompLabel.molType\n currentMap = {}\n contentMap['molType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'] = currentMap\n loadMaps['CCLB.ChemCompLabel.molType'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.molType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'\n currentMap['name'] = 'molType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\n\n # Role ChemCompLabel.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemCompLabel.isotopomers\n currentMap = {}\n contentMap['isotopomers'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'] = currentMap\n loadMaps['CCLB.ChemCompLabel.isotopomers'] = currentMap\n currentMap['tag'] = 'CCLB.ChemCompLabel.isotopomers'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'\n currentMap['name'] = 'isotopomers'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of ChemCompLabel\n\n currentMap = abstractTypes.get('ChemCompLabel')\n aList = ['ccpCode', 'molType']\n currentMap['headerAttrs'] = aList\n aList = ['isotopomers', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['isotopomers']\n currentMap['children'] = aList\n\n # Class Isotopomer\n currentMap = {}\n abstractTypes['Isotopomer'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'] = currentMap\n loadMaps['CCLB.Isotopomer'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'isotopomers'\n currentMap['objkey'] = 'serial'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Isotopomer.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Isotopomer.serial\n currentMap = {}\n contentMap['serial'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'] = currentMap\n loadMaps['CCLB.Isotopomer.serial'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.serial'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'\n currentMap['name'] = 'serial'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Isotopomer.weight\n currentMap = {}\n contentMap['weight'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'] = currentMap\n loadMaps['CCLB.Isotopomer.weight'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.weight'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'\n currentMap['name'] = 'weight'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 1.0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\n\n # Role Isotopomer.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role Isotopomer.atomLabels\n currentMap = {}\n contentMap['atomLabels'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'] = currentMap\n loadMaps['CCLB.Isotopomer.atomLabels'] = currentMap\n currentMap['tag'] = 'CCLB.Isotopomer.atomLabels'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'\n currentMap['name'] = 'atomLabels'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of Isotopomer\n\n currentMap = abstractTypes.get('Isotopomer')\n aList = ['serial', 'weight']\n currentMap['headerAttrs'] = aList\n aList = ['atomLabels', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['atomLabels']\n currentMap['children'] = aList\n\n # Class LabelingScheme\n currentMap = {}\n abstractTypes['LabelingScheme'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'] = currentMap\n loadMaps['CCLB.LabelingScheme'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'labelingSchemes'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute LabelingScheme.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute LabelingScheme.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'] = currentMap\n loadMaps['CCLB.LabelingScheme.details'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute LabelingScheme.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute LabelingScheme.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute LabelingScheme.longName\n currentMap = {}\n contentMap['longName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'] = currentMap\n loadMaps['CCLB.LabelingScheme.longName'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.longName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'\n currentMap['name'] = 'longName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute LabelingScheme.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'] = currentMap\n loadMaps['CCLB.LabelingScheme.name'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role LabelingScheme.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role LabelingScheme.chemCompLabels\n currentMap = {}\n contentMap['chemCompLabels'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'] = currentMap\n loadMaps['CCLB.LabelingScheme.chemCompLabels'] = currentMap\n currentMap['tag'] = 'CCLB.LabelingScheme.chemCompLabels'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'\n currentMap['name'] = 'chemCompLabels'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\n # End of LabelingScheme\n\n currentMap = abstractTypes.get('LabelingScheme')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy', 'name']\n currentMap['headerAttrs'] = aList\n aList = ['details', 'longName']\n currentMap['simpleAttrs'] = aList\n aList = ['chemCompLabels', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['chemCompLabels']\n currentMap['children'] = aList\n\n # Out-of-package link to AtomLabel\n currentMap = {}\n exolinks['AtomLabel'] = currentMap\n loadMaps['CCLB.exo-AtomLabel'] = currentMap\n currentMap['tag'] = 'CCLB.exo-AtomLabel'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\n currentMap['name'] = 'AtomLabel'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n\n # Out-of-package link to ChemCompLabel\n currentMap = {}\n exolinks['ChemCompLabel'] = currentMap\n loadMaps['CCLB.exo-ChemCompLabel'] = currentMap\n currentMap['tag'] = 'CCLB.exo-ChemCompLabel'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\n currentMap['name'] = 'ChemCompLabel'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n\n # Out-of-package link to Isotopomer\n currentMap = {}\n exolinks['Isotopomer'] = currentMap\n loadMaps['CCLB.exo-Isotopomer'] = currentMap\n currentMap['tag'] = 'CCLB.exo-Isotopomer'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\n currentMap['name'] = 'Isotopomer'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n\n # Out-of-package link to LabelingScheme\n currentMap = {}\n exolinks['LabelingScheme'] = currentMap\n loadMaps['CCLB.exo-LabelingScheme'] = currentMap\n currentMap['tag'] = 'CCLB.exo-LabelingScheme'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\n currentMap['name'] = 'LabelingScheme'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))","def updateMap(toname, fromname, map):\n fromobj = map[fromname]\n if isinstance(fromobj, ForcefieldResidue):\n if toname not in map:\n newres = ForcefieldResidue(fromname)\n map[toname] = newres\n for atomname in fromobj.atoms:\n map[toname].atoms[atomname] = fromobj.atoms[atomname]\n elif isinstance(fromobj, ForcefieldAtom):\n map[toname] = fromobj","def collision(self, block):\n if self.pos_x == block.pos_x and self.pos_y+self.height == block.pos_y:\n self.col_d = True\n if self.pos_x == block.pos_x+block.width and self.pos_y == block.pos_y:\n self.col_l = True\n if self.pos_x == block.pos_x-self.width and self.pos_y == block.pos_y:\n self.col_r = True","def __init__(self, cutoff: float = 0.6):\r\n super(FuzzyDict, self).__init__()\r\n self.cutoff = cutoff\r\n\r\n # short wrapper around some super (dict) methods\r\n self._dict_contains = lambda key: super(FuzzyDict, self).__contains__(key)\r\n self._dict_getitem = lambda key: super(FuzzyDict, self).__getitem__(key)","def update_maps(self):\n if self.fmodel is None:\n return\n def fft_map(map_coeffs, resolution_factor = 0.25):\n return map_coeffs.fft_map(resolution_factor = resolution_factor,\n ).apply_sigma_scaling().real_map_unpadded()\n map_types = [\"2mFo-DFc\", \"mFo-DFc\"]\n map_keys = [\"2mFo-DFc\", \"mFo-DFc\"]\n if (self.fmodel.f_obs().anomalous_flag()):\n if (self.params.anom_map_type == \"phaser\"):\n map_types.append(\"llg\")\n elif (self.params.anom_map_type == \"residual\"):\n map_types.append(\"anom_residual\")\n else :\n map_types.append(\"anom\")\n map_keys.append(\"anom\")\n if (self.use_svm):\n map_types.append(\"mFo\")\n map_keys.append(\"mFo\")\n # To save memory, we sample atomic positions immediately and throw out\n # the actual maps (instead of keeping up to 3 in memory)\n sites_frac = self.xray_structure.sites_frac()\n sites_cart = self.xray_structure.sites_cart()\n self._principal_axes_of_inertia = [ None ] * len(sites_frac)\n self._map_variances = [ None ] * len(sites_frac)\n self._map_gaussian_fits = {}\n self.calpha_mean_two_fofc = 0\n for map_type, map_key in zip(map_types, map_keys):\n real_map = self.get_map(map_type)\n if (real_map is not None):\n # Gather values for map peaks at each site\n self._map_values[map_key] = flex.double(sites_frac.size(), 0)\n self._map_gaussian_fits[map_key] = [ None ] * len(sites_frac)\n for i_seq, site_frac in enumerate(sites_frac):\n atom = self.pdb_atoms[i_seq]\n resname = atom.fetch_labels().resname.strip().upper()\n if (resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED or\n atom.segid.strip().upper() in [\"ION\"]):\n value = real_map.eight_point_interpolation(site_frac)\n self._map_values[map_key][i_seq] = value\n if (self.use_svm):\n gaussian_fit = utils.fit_gaussian(\n unit_cell=self.unit_cell,\n site_cart=atom.xyz,\n real_map=real_map)\n self._map_gaussian_fits[map_key][i_seq] = gaussian_fit\n\n if map_type in [\"2mFo-DFc\"]:\n # Gather values on map variance and principal axes of interia\n from cctbx import maptbx\n for i_seq, site_cart in enumerate(sites_cart):\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\n if resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED:\n # XXX not totally confident about how I'm weighting this...\n p_a_i = maptbx.principal_axes_of_inertia(\n real_map = real_map,\n site_cart = site_cart,\n unit_cell = self.unit_cell,\n radius = self.params.map_sampling_radius)\n self._principal_axes_of_inertia[i_seq] = p_a_i\n variance = maptbx.spherical_variance_around_point(\n real_map = real_map,\n unit_cell = self.unit_cell,\n site_cart = site_cart,\n radius = self.params.map_sampling_radius)\n self._map_variances[i_seq] = variance\n elif (i_seq in self.calpha_sel):\n # Also collect some info in average C_alpha 2FoFc peak heights\n self.calpha_mean_two_fofc += real_map.eight_point_interpolation(\n sites_frac[i_seq])\n del real_map\n\n if (self.calpha_mean_two_fofc > 0):\n n_calpha = len(self.calpha_sel)\n assert (n_calpha > 0)\n self.calpha_mean_two_fofc /= n_calpha\n\n # Gather info on carbons' average Fo peak height for use in estimating other\n # sites' atomic weight\n self.carbon_fo_values = None\n if (len(self.carbon_sel) > 0):\n self.carbon_fo_values = flex.double()\n self._map_values[\"mFo\"] = flex.double(sites_frac.size(), 0)\n fo_map = fft_map(self.fmodel.map_coefficients(\n map_type = \"mFo\",\n exclude_free_r_reflections = True,\n fill_missing = True))\n\n for i_seq, site_frac in enumerate(sites_frac):\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\n element = self.pdb_atoms[i_seq].element.strip()\n if (element == \"C\") or ((element == \"O\") and (resname in WATER_RES_NAMES)):\n map_value = fo_map.eight_point_interpolation(site_frac)\n self._map_values[\"mFo\"][i_seq] = map_value\n if (element == \"C\"):\n self.carbon_fo_values.append(map_value)\n del fo_map","def check_collide(self):\n for pizza in self.overlapping_sprites:\n pizza.handle_collide()","def reclassEcotopes(ecoMap, ecoDf, lookupDf, lookupColumn):\n \n assert 'ECO_CODE' in ecoDf.columns.values\n assert 'ECO_CODE' in lookupDf.columns.values\n assert lookupColumn in lookupDf.columns.values\n \n #-determine the lookuptable for the ecotope IDs [ecoID, lookupValue]\n df = pd.merge(ecoDf, lookupDf, on = 'ECO_CODE')\n columnData = df.loc[:,['ID', lookupColumn]].values\n lutFile = 'lutReclass1%s.txt' % uuid.uuid4() \n # needs a unique file name due to bug in pcr.lookupnominal\n np.savetxt(lutFile, columnData, fmt = '%.0f')\n \n recoded = pcr.lookupnominal(lutFile, ecoMap)\n os.remove(lutFile)\n return recoded","def init_from_others(self, a_to_b_mapping, c_iso_to_b_mapping):\n assert c_iso_to_b_mapping.is_iso()\n\n # copy the _id_maps\n self._id_maps = {}\n for (mapping, in_something) in zip([a_to_b_mapping._id_maps[Mappings.IN_A],\n c_iso_to_b_mapping._id_maps[Mappings.IN_A]],\n [Mappings.IN_A, Mappings.IN_B]):\n\n self._id_maps[in_something] = {}\n self._id_maps[in_something][Mappings.NODES] = mapping[Mappings.NODES].copy()\n self._id_maps[in_something][Mappings.EDGES] = mapping[Mappings.EDGES].copy()\n\n # map from b elem to c\n b_to_c = {}\n b_to_c[Mappings.NODES] = {}\n b_to_c[Mappings.EDGES] = {}\n for (c_elem, b_elem) in c_iso_to_b_mapping._isos:\n if self._is_node(c_elem):\n assert self._is_node(b_elem)\n b_to_c[Mappings.NODES][b_elem.id] = c_elem\n else:\n assert not self._is_node(b_elem)\n b_to_c[Mappings.EDGES][b_elem.id] = c_elem\n\n # set just a - copy a\n self._just_a = list(a_to_b_mapping._just_a)\n\n # set isos\n self._isos = []\n for (a_elem, b_elem) in a_to_b_mapping._isos:\n if self._is_node(b_elem):\n if (b_elem.id in b_to_c[Mappings.NODES]):\n c_elem = b_to_c[Mappings.NODES][b_elem.id]\n else:\n if b_elem.id in b_to_c[Mappings.EDGES]:\n c_elem = b_to_c[Mappings.EDGES][b_elem.id]\n self._isos.append( (a_elem, c_elem) )\n\n # set just b\n self._just_b = []\n for b_elem in a_to_b_mapping._just_b:\n if self._is_node(b_elem):\n if b_elem.id in b_to_c[Mappings.NODES]:\n c_elem = b_to_c[Mappings.NODES][b_elem.id]\n else:\n if b_elem.id in b_to_c[Mappings.EDGES]:\n c_elem = b_to_c[Mappings.EDGES][b_elem.id]\n\n self._just_b.append( c_elem )","def _configure_flowables(self, flowables):\n if flowables is None:\n flowables = DEFAULT_FLOWABLES\n\n # FlowablesDict-- mainly to upsample CAS numbers for matching\n self._fm = FlowablesDict()\n\n self._fm.new_entry('carbon dioxide', '124-38-9')\n self._fm.new_entry('Water', '7732-18-5')\n # we store the child object and use it to signify biogenic CO2 to optionally quell\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\n\n # now load + merge from file\n self._fm.load(flowables)\n\n # now add all known \"biotic\" synonyms for CO2 to the biotic child\n for k in self._fm.synonyms('124-38-9'):\n if bool(biogenic.search(k)):\n self._bio_co2.add_term(k)\n self._fq_map = {fb: set() for fb in self._fm.objects}","def __init__(self, c):\n self.coords = c[:4]\n self.center = c[4]\n\n # init width and height of block\n widthAndHeight(self)\n\n self.x = randrange((pyxel.width - self.width)/4)\n self.y = 0\n self.vy = 32\n self.falling = True\n\n # init random color\n self.color = randrange(2, 15)\n\n # Add block to posMap\n mapAdd(self, theFallen)\n\n self.frame = pyxel.frame_count","def should_grow_on_food_collision(self):\n return True","def _update_conformers(self, cutoff=0.002):\n logger.debug(\"Updating conformers based on occupancy\")\n\n # Check that all arrays match dimensions.\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\n\n # Filter all arrays & lists based on self._occupancies\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\n filterarray = self._occupancies >= cutoff\n self._occupancies = self._occupancies[filterarray]\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\n self._bs = list(itertools.compress(self._bs, filterarray))\n\n logger.debug(f\"Remaining valid conformations: {len(self._coor_set)}\")","def requires_mapping(self):","def _set_mapper(self, classification_dict):\n d = {class_code: class_index for class_index, class_code in enumerate(classification_dict.keys())}\n # Here we update the dict so that code 65 remains unchanged.\n # Indeed, 65 is reserved for noise/artefacts points, that will be deleted by transform \"DropPointsByClass\".\n d.update({65: 65})\n self.mapper = np.vectorize(lambda class_code: d.get(class_code))","def initMaps(self):\r\n assert isinstance(self.CLASSES, (list, tuple))\r\n assert self.CLASSES[0] == \"__background__\"\r\n cls = self.CLASSES\r\n self.name_to_id = dict(zip(cls, range(len(cls))))\r\n self.id_to_name = dict(zip(range(len(cls)), cls))","def detect_collision(self, pos):\n for rect in self.stock:\n if rect.collidepoint((pos)):\n return ['S0', 0]\n for rect in self.waste:\n if rect.collidepoint((pos)):\n return ['W0', 0]\n for i, rect in enumerate(self.foundations):\n if rect.collidepoint((pos)):\n return ['F'+str(i), 0]\n for rect in self.tableaus:\n if rect[0].collidepoint((pos)):\n return rect[1]\n\n return [0,0]","def try_put(self, object_to_put, pos_x, pos_y):\n self.validate_position(pos_x, pos_y)\n if self.map[pos_x][pos_y] is None:\n self.map[pos_x][pos_y] = object_to_put\n else:\n return self.map[pos_x][pos_y]","def handle_matching_collision(self, dmg, hp):\n\n # Delegate to the function in 'systems'.\n systems.handle_damage_collision(dmg, hp)\n\n # Return the result ( we handled the collision. )\n return physics.CollisionResult(True, True)","def __init__(self, mappings):\r\n for key, value in mappings.iteritems():\r\n setattr(self, key, value)","def initialize(cls):\n if len(cls.mapping) == 0:\n cls.mapping[\"noop\"] = cls(Transform.identity, Combiner.noop)\n cls.mapping[\"sigmoid\"] = cls(Transform.sigmoid, Combiner.multiplies)\n cls.mapping[\"log-sigmoid\"] = cls(Transform.log_sigmoid, Combiner.plus)\n\n for p in range(1, 5):\n cls.mapping[\"l{}-hinge\".format(p)] = cls(\n Transform.get_lp_hinge(p), Combiner.multiplies\n )\n cls.mapping[\"log-l{}-hinge\".format(p)] = cls(\n Transform.get_log_lp_hinge(p), Combiner.plus\n )\n\n # for backward compatibility\n cls.mapping[True] = cls.mapping[\"l3-hinge\"]\n cls.mapping[False] = cls.mapping[\"noop\"]\n cls.mapping[None] = cls.mapping[\"noop\"]","def _setup_collision_handlers(self):\n self._world.add_collision_handler(\"player\", \"item\", on_begin=self._handle_player_collide_item)\n self._world.add_collision_handler(\"player\", \"block\", on_begin=self._handle_player_collide_block,\n on_separate=self._handle_player_separate_block)\n self._world.add_collision_handler(\"player\", \"mob\", on_begin=self._handle_player_collide_mob)\n self._world.add_collision_handler(\"mob\", \"block\", on_begin=self._handle_mob_collide_block)\n self._world.add_collision_handler(\"mob\", \"mob\", on_begin=self._handle_mob_collide_mob)\n self._world.add_collision_handler(\"mob\", \"item\", on_begin=self._handle_mob_collide_item)","def _update_collidable_components(self):\n\n #First we must iterate through each collision shape component.\n for cBody in self.get_all_components(\"CBODY\"):\n\n #Then for each collison shape, we must grab its position and\n # update the dependent component of the collision shape.\n\n #The y position needs flipped because pymunk and sfml's y coordinates start\n # on different sides (top-left is (0,0) in sfml, bottom-left is (0,0) in pymunk)\n lPosition = [cBody._Get_Body().position[0], \\\n config.WINDOW_HEIGHT - cBody._Get_Body().position[1]]\n\n dependentSprite = self.get_component(cBody._Get_Dependent_Component_ID())\n\n if (dependentSprite):\n dependentSprite._Update_Position(lPosition, cBody._Get_Body().angle)","def get_shapes(self):\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\n X = []\n backmap = {}\n rad = 3\n for k,((i,y),(j,x)) in enumerate(self.mids):\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\n colours[i][j] = m\n X.append(m)\n backmap[k] = (i,j)\n print(np.shape(X))\n Z = linkage(X, 'ward')\n Q = fcluster(Z, self.thresh, criterion='distance')\n\n closenesses = []\n for k,cls in enumerate(Q):\n i,j = backmap[k]\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\n minidx = np.argmin(closenesses)\n bgcls = Q[minidx]\n\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\n img4 = self.img2.copy()\n for k,((i,y),(j,x)) in enumerate(self.mids):\n cls = Q[k]\n if cls == bgcls:\n continue\n col = blibs[(cls-1)]\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\n\n write_img(\"./out/test_classes.png\", img4)\n self.classimg = img4\n\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\n mx = np.max(Q)\n for k,cls in enumerate(Q):\n if cls == bgcls:\n continue\n\n if cls == mx:\n plotcls = bgcls\n else:\n plotcls = cls\n i,j = backmap[k]\n A[i][j] = plotcls\n\n self.res = A","def _fit(self, clean, entity_map):\n raise NotImplementedError","def check_collision(self):\n self.collided = False\n\n for point in self.collision_points:\n\n try:\n if self.game_map.get_at((\n int(point[0]), int(point[1])\n )) == WHITE_COLOR:\n self.collided = True\n break\n except:\n self.collided = True","def constrain(self, gamut_map, processed, to_process):\n gamut_map[self._referent] = range_intersect(\n gamut_map.get(self._referent, None),\n self.gamut\n )\n if self._referent not in processed:\n to_process.add(self._referent)","def mapToAtlas(self, obj):\n raise Exception(\"Must be reimplemented in subclass.\")","def __init__(self, fvcom):\n\n # Prepare this object with all the objects we'll need later on (data, dims, time, grid, atts).\n self._prep()\n\n self.obj_iter = lambda x: [a for a in dir(x) if not a.startswith('__')]\n\n grid_names = ('lon', 'lat', 'lonc', 'latc', 'nv',\n 'h', 'h_center',\n 'nbe', 'ntsn', 'nbsn', 'ntve', 'nbve',\n 'art1', 'art2', 'a1u', 'a2u',\n 'siglay', 'siglev')\n time_names = ('time', 'Times', 'datetime', 'Itime', 'Itime2')\n\n for key in fvcom:\n if key in grid_names:\n setattr(self.grid, key, fvcom[key])\n elif key in time_names:\n setattr(self.time, key, fvcom[key])\n else: # assume data.\n setattr(self.data, key, fvcom[key])\n # Make some dimensions\n self.dims.three = 3\n self.dims.four = 4\n self.dims.maxnode = 11\n self.dims.maxelem = 9\n # This is a little repetitive (each dimension can be set multiple times), but it has simplicity to its\n # advantage.\n for obj in self.obj_iter(self.data):\n if obj in ('ua', 'va'):\n try:\n self.dims.time, self.dims.nele = getattr(self.data, obj).shape\n except ValueError:\n # Assume we've got a single position.\n self.dims.time = getattr(self.data, obj).shape[0]\n self.dims.nele = 1\n elif obj in ('temp', 'salinity'):\n try:\n self.dims.time, self.dims.siglay, self.dims.node = getattr(self.data, obj).shape\n except ValueError:\n # Assume we've got a single position\n self.dims.time, self.dims.siglay = getattr(self.data, obj).shape[:2]\n self.dims.node = 1\n self.dims.siglev = self.dims.siglay + 1\n elif obj in ['zeta']:\n try:\n self.dims.time, self.dims.node = getattr(self.data, obj).shape\n except ValueError:\n # Assume we've got a single position\n self.dims.time = getattr(self.data, obj).shape[0]\n self.dims.node = 1\n elif obj in ('Times'):\n self.dims.time, self.dims.DateStrLen = getattr(self.time, obj).shape\n elif obj in ('time', 'Itime', 'Itime2', 'datetime'):\n self.dims.time = getattr(self.time, obj).shape","def __subclasshook__(cls, other_class: type):\n # issubclass calls result in infinite recursion\n # guard against infinite recursion with direct calls to base subclasshooks\n # https://docs.python.org/3/library/collections.abc.html#collections-abstract-base-classes\n return (\n cls is HashableMapping\n and True == CA.Hashable.__subclasshook__(other_class) # type: ignore\n and True == CA.Collection.__subclasshook__(other_class) # type: ignore\n and True == check_methods(other_class, '__getitem__', '__eq__', '__ne__')\n or NotImplemented\n )","def _ignore_collision(self):\n # The legacy version only ignores collision of child links of active joints.\n for link in self.cabinet.get_links():\n for s in link.get_collision_shapes():\n g0, g1, g2, g3 = s.get_collision_groups()\n s.set_collision_groups(g0, g1, g2 | 1 << 31, g3)","def check_collide(self):\r\n for raindrop in self.overlapping_sprites:\r\n raindrop.handle_collide()","def __init__(self, mapping=None, **kwargs):\n\n masked_kwargs = {}\n if len(kwargs) > 0:\n masked_kwargs = self._mask_dict(kwargs)\n\n if isinstance(mapping, MaskedDict):\n super().__init__(self._unify(mapping, masked_kwargs))\n\n elif isinstance(mapping, (dict, Headers)):\n temp = {}\n for key, value in mapping.items():\n if masking_services.should_mask(key) is True:\n temp[key] = self.MASK\n else:\n temp[key] = self._mask(value)\n\n super().__init__(self._unify(temp, masked_kwargs))\n\n elif isinstance(mapping, LIST_TYPES):\n temp = []\n for key, value in mapping:\n if masking_services.should_mask(key) is True:\n temp.append((key, self._mask(value)))\n else:\n temp.append((key, value))\n\n super().__init__(temp, **masked_kwargs)\n\n else:\n super().__init__(masked_kwargs)","def remap(self,newMasters,modMap,objMaps=[]):\n #--Masters\n self.tes3.masters = newMasters\n #--File mapping\n modMapKeys = modMap.keys()\n #--Remap iObjs\n cells_id = self.cells_id\n reObjNum = re.compile('[0-9A-Z]{8}$')\n for (iMod,objMap) in objMaps:\n cellIds = objMap.keys()\n for cellId in cellIds:\n cellObjMap = objMap[cellId]\n #--Save \n cell = cells_id.get(cellId)\n if not cell: continue\n #--Objects\n objects = cell.getObjects()\n for object in objects.list():\n #--Different mod?\n if object[0] != iMod:\n pass\n #--Cell deleted?\n elif cellObjMap == -1:\n objects.remove(object)\n #--Remapped object?\n elif object[1] in cellObjMap:\n (newIObj,objId) = cellObjMap[object[1]]\n objIdBase = reObjNum.sub('',objId) #--Strip '00001234' id num from object\n #--Mismatched object id?\n if objId != objIdBase:\n #print 'Mismatch:',object[:3]\n pass \n #--Deleted object?\n elif newIObj == -1:\n #print 'Deleted',object[:3]\n objects.remove(object)\n #--Remapped object?\n else:\n #print 'Remapped',object[:3],'to',newIObj\n newObject = self.remapObject(object,iMod,newIObj)\n objects.replace(object,newObject)\n self.updateScptRefs()\n #--Remap iMods\n if not modMapKeys: return\n for cell in self.cells:\n objects = cell.getObjects()\n for object in objects.list():\n #--Remap IMod\n iMod = object[0]\n #--No change?\n if iMod not in modMapKeys: \n pass\n #--Object deleted?\n elif modMap[iMod] == -1:\n objects.remove(object)\n #--Object not deleted?\n else:\n newObject = self.remapObject(object,modMap[iMod])\n objects.replace(object,newObject)\n self.updateScptRefs()","def __init__(self, posn, w, h, c):\r\n self.corner = posn\r\n self.width = w\r\n self.height = h\r\n self.collision = c","def box_cox_map(self, col_need, gamma=1.0, col_replace=True):\r\n df_need = self.df[col_need]\r\n if col_replace:\r\n self.df[col_need] = df_need.applymap(lambda x: boxcox1p(x, gamma))\r\n else:\r\n col_need_extend = [col + \"_boxCox\" for col in col_need]\r\n self.df[col_need_extend] = df_need.applymap(lambda x: boxcox1p(x, gamma))","def __init__(self, word_fd, quadgram_fd, ii, iii, ixi, ixxi, iixi, ixii):\n AbstractCollocationFinder.__init__(self, word_fd, quadgram_fd)\n self.iii = iii\n self.ii = ii\n self.ixi = ixi\n self.ixxi = ixxi\n self.iixi = iixi\n self.ixii = ixii","def _strict_match(self, struct1, struct2, fu, s1_supercell=True,\n use_rms=False, break_on_match=False):\n if fu < 1:\n raise ValueError(\"fu cannot be less than 1\")\n\n mask, s1_t_inds, s2_t_ind = self._get_mask(struct1, struct2,\n fu, s1_supercell)\n\n if mask.shape[0] > mask.shape[1]:\n raise ValueError('after supercell creation, struct1 must '\n 'have more sites than struct2')\n\n # check that a valid mapping exists\n if (not self._subset) and mask.shape[1] != mask.shape[0]:\n return None\n\n if LinearAssignment(mask).min_cost > 0:\n return None\n\n best_match = None\n # loop over all lattices\n for s1fc, s2fc, avg_l, sc_m in \\\n self._get_supercells(struct1, struct2, fu, s1_supercell):\n # compute fractional tolerance\n normalization = (len(s1fc) / avg_l.volume) ** (1/3)\n inv_abc = np.array(avg_l.reciprocal_lattice.abc)\n frac_tol = inv_abc * self.stol / (np.pi * normalization)\n # loop over all translations\n for s1i in s1_t_inds:\n t = s1fc[s1i] - s2fc[s2_t_ind]\n t_s2fc = s2fc + t\n if self._cmp_fstruct(s1fc, t_s2fc, frac_tol, mask):\n inv_lll_abc = np.array(avg_l.get_lll_reduced_lattice().reciprocal_lattice.abc)\n lll_frac_tol = inv_lll_abc * self.stol / (np.pi * normalization)\n dist, t_adj, mapping = self._cart_dists(\n s1fc, t_s2fc, avg_l, mask, normalization, lll_frac_tol)\n if use_rms:\n val = np.linalg.norm(dist) / len(dist) ** 0.5\n else:\n val = max(dist)\n if best_match is None or val < best_match[0]:\n total_t = t + t_adj\n total_t -= np.round(total_t)\n best_match = val, dist, sc_m, total_t, mapping\n if (break_on_match or val < 1e-5) and val < self.stol:\n return best_match\n\n if best_match and best_match[0] < self.stol:\n return best_match","def collision_info(self, point):\n pass","def collide(self, obj):\n if obj.type == 'food':\n if self.carry_food == False:\n self.r += 1\n self.color = (0, 255, 0, 128)\n self.carry_food = True\n if self.mass > obj.mass:\n pass\n elif self.mass*5 < obj.mass:\n self.orientation += math.pi\n if (obj.type == 'wall') and (obj.colony):\n if self.carry_food == True:\n self.r += 100\n self.carry_food = False\n self.color = (128, 128, 128, 128)\n else:\n pass\n # self.orientation += rnd.choice([math.pi / 4, - math.pi / 4])\n # else:\n # print('collision')\n # self.orientation += math.pi","def collision(self, model, new_location):\n\n within_bounds = all(model.boundaries[0] <= new_location) and all(new_location <= model.boundaries[1])\n\n if not within_bounds:\n\n collide = True\n\n elif self.neighbourhood(model, new_location):\n\n collide = True\n\n else:\n\n collide = False\n\n return collide","def make_sector_map(self, data):\n\n def format_county_fips(cf):\n\n cf = str(cf)\n\n if len(cf)<=4:\n\n cf = '0'+cf\n\n return cf\n\n data['COUNTY_FIPS'] = data.COUNTY_FIPS.apply(\n lambda x: format_county_fips(x)\n )\n\n # match on geo_id\n map_data = self.cshp.set_index('GEOID').join(\n data.set_index('COUNTY_FIPS').MMBtu\n )\n\n ## Need to specify colors or will geopandas automatcially assign?","def __init__(self, fn):\n\n #for the scripting engine\n script_engine.ScriptableObject.__init__(self)\n\n #store variables we'll need later\n self.fn = fn\n\n #get a script engine (singleton)\n self.scriptEngine = script_engine.ScriptEngine()\n\n #parse the XML file\n root = data.getTreeRoot(fn)\n self.music = os.path.join(settings.path, \"data\", data.getAttr(root, \"music\", data.D_STRING))\n\n #open the actual map data file to create the map tile data\n mapPath = os.path.join(settings.path, \"data\", data.getAttr(root, \"file\", data.D_STRING))\n self.openMap(mapPath)\n\n #create the tileset\n tilesetPath = os.path.join(settings.path, \"data\", data.getAttr(root, \"tileset\", data.D_STRING))\n self.tileset = tileset.Tileset(tilesetPath)\n\n #set the border tiles\n self.borderTiles = {}\n borderNode = data.getChild(root, \"border\")\n\n #set each border node with the correct tile indexes, subtracting 1 because the tileset starts at 1 not 0\n self.borderTiles[BD_NW] = data.getAttr(borderNode, \"nw\", data.D_INT)-1\n self.borderTiles[BD_NE] = data.getAttr(borderNode, \"ne\", data.D_INT)-1\n self.borderTiles[BD_SW] = data.getAttr(borderNode, \"sw\", data.D_INT)-1\n self.borderTiles[BD_SE] = data.getAttr(borderNode, \"se\", data.D_INT)-1\n \n #create any connections from the map\n #connected maps will not be loaded until the map becomes the main game map\n #connections are stored as {direction: (filename, offset)}\n self.connections = {}\n self.connectedMaps = {}\n for c in data.getChildren(root, \"connection\"):\n side = data.getAttr(c, \"side\", data.D_STRING)\n fp = os.path.join(settings.path, \"data\", data.getAttr(c, \"map\", data.D_STRING))\n offset = data.getAttr(c, \"offset\", data.D_INT)\n \n if side == \"left\":\n self.connections[sprite.DIR_LEFT] = (fp, offset)\n elif side == \"right\":\n self.connections[sprite.DIR_RIGHT] = (fp, offset)\n elif side == \"up\":\n self.connections[sprite.DIR_UP] = (fp, offset)\n elif side == \"down\":\n self.connections[sprite.DIR_DOWN] = (fp, offset)\n\n #create any NPCs, adding them to the sprite dictionary\n self.sprites = {}\n for n in data.getChildren(root, \"npc\"):\n spr = npc.NPC(n, self)\n self.sprites[spr.id] = spr\n\n #create a dictionary to hold positions reserved by moving sprites\n self.reservedPositions = {}\n\n #create script and warp events, adding them to the events dictionary\n #if a load script is defined, create it\n self.events = {}\n loadScript = None\n for s in data.getChildren(root, \"script\"):\n trigger = data.getAttr(s, \"trigger\", data.D_STRING)\n if trigger == \"load\":\n loadScript = script_engine.Script(s) \n else:\n position = tuple(data.getAttr(s, \"position\", data.D_INT2LIST)) \n self.events[position] = events.ScriptEvent(s, self)\n \n for w in root.findall(\"warp\"):\n position = tuple(data.getAttr(w, \"position\", data.D_INT2LIST))\n self.events[position] = events.Warp(w, self)\n\n #if there is a load script, run it\n if loadScript is not None:\n self.scriptEngine.run(loadScript, self)","def _collide(self):\n\n collisions = self._get_collisions()\n for collision in collisions:\n self._update_excitation(collision)\n atom1 = self.atoms[collision[0]]\n atom2 = self.atoms[collision[1]]\n\n r = atom1.pos-atom2.pos\n r_mag = np.linalg.norm(r)\n r_hat = r/r_mag\n\n v_1_r = np.dot(atom1.vel, r_hat)\n v_2_r = np.dot(atom2.vel, r_hat)\n\n v_1_r_f = (atom1.mass-atom2.mass)*v_1_r/(atom1.mass + atom2.mass)\\\n + 2*atom2.mass*v_2_r/(atom1.mass + atom2.mass)\n v_2_r_f = (atom2.mass-atom1.mass)*v_2_r/(atom1.mass + atom2.mass)\\\n + 2*atom1.mass*v_1_r/(atom1.mass + atom2.mass)\n\n delta_v_1 = (v_1_r_f - v_1_r)*r_hat\n delta_v_2 = (v_2_r_f - v_2_r)*r_hat\n\n self.atoms[collision[0]].vel += delta_v_1\n self.atoms[collision[1]].vel += delta_v_2","def read_cbf_file(inputfilename):\n \n \n with open(inputfilename, 'rb') as fid:\n BD = np.fromfile(fid, np.float64)\n \n # https://www.mathworks.com/help/matlab/ref/fwrite.html\n # https://www.mathworks.com/help/matlab/numeric-types.html\n \n k=0;\n # Static data (100 places)\n SD=BD[k:k+100]\n k=k+100\n # Priors (50 places)\n PR=BD[k:k+50];\n k=k+50;\n # Priorunc (50 places)\n PRU=BD[k:k+50]\n k=k+50 \n \n # O. Priors (50 places)\n OPR=BD[k:k+50]\n k=k+50\n # O. Priorunc (50 places)\n OPRU=BD[k:k+50]\n k=k+50\n \n CBF = {}\n CBF['PARPRIORS'] = np.expand_dims(PR,axis=1)\n CBF['PARPRIORUNC'] = np.expand_dims(PRU,axis=1)\n CBF=read_other_obs_constraints(CBF,OPR,OPRU)\n \n CBF['ID'] = SD[0] # ID (not used)\n CBF['LAT'] = SD[1] # Latitude\n CBF['nodays'] = int(SD[2]) # Number of days\n CBF['nomet'] = int(SD[3])\n CBF['noobs'] =int(SD[4])\n CBF['EDC'] = SD[5]\n CBF['EDCDIAG'] = SD[6]\n# CBF = {'PARPRIORS':np.expand_dims(PR,axis=1), \n# 'PARPRIORUNC':np.expand_dims(PRU,axis=1), \n# 'OTHERPRIORS':np.expand_dims(OPR,axis=1), #\n# 'OTHERPRIORSUNC':np.expand_dims(OPRU,axis=1),\n# 'ID':SD[0], # ID (not used)\n# 'LAT':SD[1], # Latitude\n# 'nodays':int(SD[2]), # Number of days\n# 'nomet':int(SD[3]), \n# 'noobs':int(SD[4]),\n# 'EDC':SD[5],\n# 'EDCDIAG':SD[6],\n# 'gppabs':SD[7],\n# 'rc_random_search':SD[10]==1,\n# 'nbe_annual_unc':SD[13],\n# 'etiav':SD[14],\n# 'nbe_seasonal_unc':SD[15]}\n \n #MCMC start searching EDCs from anywhere (1) or from prescribed starting\n #point(0). this is outdated - consider deleting\n CBF['rc_random_search'] = SD[10]==1\n \n #NEE IAV options\n CBF=read_obs_uncertainty_fields(CBF,SD,OPRU)\n \n \n TEMPDATA=BD[k:k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']].reshape(CBF['nodays'],\n (CBF['nomet']+CBF['noobs']))\n #All met data\n CBF['MET'] = TEMPDATA[0:CBF['nodays'],0:CBF['nomet']] # Add in new meteorology here\n# CBF['OBS'] = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\n CBFOBS = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\n CBF=define_cbf_obs_fields(CBF,CBFOBS)\n \n #Removing redundant fields\n# CBF=rmfield(CBF,'noobs');\n# # CBF=rmfield(CBF,'nomet');\n# # CBF=rmfield(CBF,'nodays');\n \n \n # Read prescribed mean meteorology\n \n if len(BD) - (k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']) == CBF['nomet'] + CBF['noobs']:\n \n kmmet= k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']\n CBF['mmet'] = BD[kmmet:kmmet+CBF['nomet']]\n \n \n #Retaining \"OTHERPRIORS\" for now\n CBF['RAW'] = {}\n CBF['RAW']['OTHERPRIORS']=OPR;\n CBF['RAW']['OTHERPRIORSUNC']=OPRU;\n CBF['RAW']['info']='Raw inputs/outputs as stored in CBF binary structure';\n CBF['RAW']['details']='For completeness & development purpose only; When re-writing CBF to file, these are over-written by CBF.OBS, etc.';\n\n \n \n \n \n return CBF\n #disp(sprintf('CHECK: .cbf file \"%s\" successfully read into matlab.',filename)) ","def setCollidemask(self):\n friends = self.createFriendlyEmpireList()\n mask = 0\n for id in friends:\n id = int(id)\n mask = mask + (1<<id)\n self.collidemask = mask","def map_face(self):\n #Array Order: U0,D1,R2,L3,F4,B5,\n \n cube_list = []\n cube_list = self.cube.definition()\n \n for index, cubit in enumerate(self.faces['Up']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\n for index, cubit in enumerate(self.faces['Ri']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\n for index, cubit in enumerate(self.faces['Ft']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\n for index, cubit in enumerate(self.faces['Dn']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\n for index, cubit in enumerate(self.faces['Le']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\n for index, cubit in enumerate(self.faces['Bk']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])","def __init__(self, vcffiles):\n self.vcffilenames = vcffiles\n self.snpsites = {}\n self.snp_positions = {}","def classify_defect_clusters_modifier(frame, data):\n\n if data.particles.count == 0:\n # No particles there to classify, create empty properties anyway\n data.particles_.create_property('Si_V', dtype=int, components=1)\n data.particles_.create_property('Si_I', dtype=int, components=1)\n data.particles_.create_property('Si_C', dtype=int, components=1)\n data.particles_.create_property('C_V', dtype=int, components=1)\n data.particles_.create_property('C_I', dtype=int, components=1)\n data.particles_.create_property('C_Si', dtype=int, components=1)\n return\n\n # TODO Create numpy arrays containing the number of Si vacancies,\n # interstitials, etc for each particle site in `data.particles`. These\n # next lines are just placeholders!\n si_vacancy = data.particles[\"vacancy_mask\"][...] * data.particles[\"Is Si Site\"][...]\n si_interstitial = (data.particles[\"Is Si Site\"][...] & (data.particles[\"Si Occupancy\"][...] > 1)) * (\n data.particles[\"Si Occupancy\"][...] - 1) + (\n (data.particles[\"Is C Site\"][...]) * data.particles[\"Si Occupancy\"][...]) - (\n data.particles[\"Is C Site\"][...] & data.particles[\"antisite_mask\"][...])\n si_antisite = data.particles[\"antisite_mask\"][...] * data.particles[\"Is Si Site\"][...]\n c_vacancy = data.particles[\"vacancy_mask\"][...] * data.particles[\"Is C Site\"][...]\n c_interstitial = (data.particles[\"Is C Site\"][...] & (data.particles[\"C Occupancy\"][...] > 1)) * (\n data.particles[\"C Occupancy\"][...] - 1) + (\n (data.particles[\"Is Si Site\"][...]) * data.particles[\"C Occupancy\"][...]) - (\n data.particles[\"Is Si Site\"][...] & data.particles[\"antisite_mask\"][...])\n c_antisite = data.particles[\"antisite_mask\"][...] * data.particles[\"Is C Site\"][...]\n\n\n data.particles_.create_property('Si_V', data=si_vacancy.astype(int))\n data.particles_.create_property('Si_I', data=si_interstitial.astype(int))\n data.particles_.create_property('Si_C', data=si_antisite.astype(int))\n data.particles_.create_property('C_V', data=c_vacancy.astype(int))\n data.particles_.create_property('C_I', data=c_interstitial.astype(int))\n data.particles_.create_property('C_Si', data=c_antisite.astype(int))","def __init___0(self, map):\n super(LongObjectHashMap, self).__init__()\n self.__init__()\n putAll(map)","def __init__(self):\n self._map = {}","def __init__(self, tileset, letter_mapping, space_width=None, transparent_color=0):\n\t\tsuper().__init__(tileset, letter_mapping)\n\t\tself._bound_rects = {}\n\t\twith pygame.PixelArray(self._tileset.get_texture()) as pixels:\n\t\t\tfor letter in self._letter_mapping.keys():\n\t\t\t\tletter_image = self._tileset.get_tile(self._letter_mapping[letter])\n\t\t\t\tletter_rect = letter_image.get_rect()\n\t\t\t\tself._bound_rects[letter] = utils.graphics.get_bounding_rect(letter_rect, lambda p: (pixels[p.x, p.y] == transparent_color), space_width=space_width)","def __init__(self, lower_left_corner, upper_right_corner, projection='merc'):\n self.basemap = MLMap.__create_basemap(lower_left_corner[0], lower_left_corner[1], upper_right_corner[0],\n upper_right_corner[1], projection=projection)\n self.shapes = pd.DataFrame()\n self.shapes_to_draw = []\n llc = self.basemap(lower_left_corner[0], lower_left_corner[1])\n urc = self.basemap(upper_right_corner[0], upper_right_corner[1])\n\n #self.bbox = Bbox([llc, urc])\n self.bbox = (lower_left_corner[0], lower_left_corner[1], upper_right_corner[0], upper_right_corner[1])","def __init__(self, mappings):\n self.mappings = mappings","def __init__(self, mapping_filepath=None, calibration_filepath=None,\n badchannels_filepath=None, runid=None):\n # Mapping processing (file or cdb):\n if mapping_filepath is not None:\n with open(mapping_filepath, \"r\") as f:\n self.mapping = self.ParseMapping(f)\n elif runid is not None and CDB_AVAIL:\n # Perform CDB operations to retrive mapping..\n cdb_mapping = Cabling().get_cabling_for_run('Trackers', runid)\n self.mapping = self.ParseMapping(cdb_mapping.split('\\n'))\n else:\n raise ValueError(\"Unable to load mapping, no methods available\")\n\n # Mapping processing (file or cdb):\n if calibration_filepath is not None:\n with open(calibration_filepath, \"r\") as f:\n self.calibration = self.ParseCalibration(f.read())\n elif runid is not None and CDB_AVAIL:\n # Perform CDB operations to retrive mapping..\n cdb_calib = Calibration().get_calibration_for_run('Trackers', \n runid, 'trackers')\n print cdb_calib\n self.calibration = self.ParseCalibration(cdb_calib)\n else:\n raise ValueError(\"Unable to load calibration, no methods available\")\n\n #self.mapping = self.LoadMapping(mapping_filepath)\n #self.calibration = self.LoadCalibration(calibration_filepath)\n\n if badchannels_filepath is not None:\n self.badfechannels = self.LoadBadChannelUIDs(badchannels_filepath)\n else:\n self.badfechannels = []\n\n # Lookup object, for finding things.\n self.lookup = self.GenerateLookup(self.mapping, self.calibration, self.badfechannels)\n\n # Missing channels from a given plane\n self.badplanelookup = self.GeneratePlaneBadLookup(self.lookup)","def __init__(self, ff, definition, userff, usernames=None):\n self.map = {}\n self.name = ff\n defpath = \"\"\n\n if userff is None:\n defpath = getFFfile(ff)\n if defpath == \"\":\n raise ValueError(\"Unable to find forcefield parameter file %s!\" % sys.path)\n\n file = open(defpath, 'rU')\n\n else:\n file = userff\n\n lines = file.readlines()\n for line in lines:\n if not line.startswith(\"#\"):\n fields = line.split()\n if fields == []: continue\n try:\n resname = fields[0]\n atomname = fields[1]\n charge = float(fields[2])\n radius = float(fields[3])\n except ValueError:\n txt = \"Unable to recognize user-defined forcefield file\"\n if defpath != \"\":\n txt += \" %s!\" % defpath\n else:\n txt += \"!\"\n txt += \" Please use a valid parameter file.\"\n raise ValueError(txt)\n\n try:\n group = fields[4]\n atom = ForcefieldAtom(atomname, charge, radius, resname, group)\n except:\n atom = ForcefieldAtom(atomname, charge, radius, resname)\n\n myResidue = self.getResidue(resname)\n if myResidue is None:\n myResidue = ForcefieldResidue(resname)\n self.map[resname] = myResidue\n myResidue.addAtom(atom)\n\n file.close()\n\n # Now parse the XML file, associating with FF objects -\n # This is not necessary (if canonical names match ff names)\n\n defpath = getNamesFile(ff)\n if defpath != \"\":\n\n handler = ForcefieldHandler(self.map, definition.map)\n sax.make_parser()\n\n if usernames is not None:\n namesfile = usernames\n sax.parseString(namesfile.read(), handler)\n else:\n namesfile = open(defpath)\n sax.parseString(namesfile.read(), handler)\n namesfile.close()\n\n # CGI based .names file handling\n else:\n handler = ForcefieldHandler(self.map, definition.map)\n sax.make_parser()\n\n if usernames is not None:\n namesfile = usernames\n sax.parseString(namesfile.getvalue(), handler)\n else:\n raise ValueError(\"Please provide a valid .names file!\")\n namesfile.close()","def test_conceptmap_6(base_settings):\n filename = base_settings[\"unittest_data_dir\"] / \"cm-contact-point-use-v2.json\"\n inst = conceptmap.ConceptMap.parse_file(\n filename, content_type=\"application/json\", encoding=\"utf-8\"\n )\n assert \"ConceptMap\" == inst.resource_type\n\n impl_conceptmap_6(inst)\n\n # testing reverse by generating data from itself and create again.\n data = inst.dict()\n assert \"ConceptMap\" == data[\"resourceType\"]\n\n inst2 = conceptmap.ConceptMap(**data)\n impl_conceptmap_6(inst2)","def from_mapping(cls, mapping):\n raise NotImplementedError('Subclasses of MapInitializable must implement from_mapping.')","def process_class(self, parent, cls):\n if cls.typemap.flat_name in self.class_map:\n raise RuntimeError(\"process_class: class {} already exists in class_map\"\n .format(cls.typemap.flat_name))\n self.class_map[cls.typemap.flat_name] = cls\n for var in cls.variables:\n self.add_var_getter_setter(parent, cls, var)\n cls.functions = self.define_function_suffix(cls.functions)","def __circle_collision(self, circle):\n raise Exception('--- This methods have not been implemented yet! Use circle_collider instead ---')"],"string":"[\n \"def collision(self):\\n raise NotImplementedError\",\n \"def applyMapping(self):\\n pass\",\n \"def setupCollisions(self):\\n\\t\\tbase.cTrav = CollisionTraverser()\\n\\t\\tself.cHandler = CollisionHandlerEvent()\\n\\t\\t#self.cHandler.setInPattern('%fn-sped-up')\\n\\t\\t\\n\\t\\tcQuad = CollisionPolygon(Point3(0, 0, 0), Point3(0, 0, 10), Point3(0, 10, 10), Point3(0, 10, 0))\\n\\t\\tcNode = CollisionNode(\\\"speed_boost\\\")\\n\\t\\tcNode.addSolid(cQuad)\\n\\t\\tcNodePath = self.form.attachNewNode(cNode)\\n\\t\\tbase.cTrav.addCollider(cNodePath, self.cHandler)\",\n \"def collide_with_flower(self, flower):\\n pass\",\n \"def setupCollisions(self) :\",\n \"def is_collision_by_map_data(self):\\n raise NotImplementedError\",\n \"def collision(cls, other: \\\"entities.Entity\\\") -> None:\\n raise NotImplementedError\",\n \"def collision_detect(self):\\n\\n # Check if the collision was with a map\\n # Rect-based collision code\\n for map_rect in Map.current_map.collision_rects:\\n collision_time, norm_x, norm_y = collision.aabb_swept_collision(self.rect, (self.vx, self.vy), map_rect)\\n if collision_time != 1:\\n if DEBUG: print(\\\"[collision]\\\", collision_time)\\n break\\n self.x += self.vx * collision_time\\n self.y += self.vy * collision_time\\n\\n remaining_time = 1 - collision_time\\n \\\"\\\"\\\"\\n if remaining_time > 0:\\n self.vx *= remaining_time;\\n self.vy *= remaining_time;\\n \\\"\\\"\\\"\\n if collision_time != 1:\\n if abs(norm_x) > .0001:\\n self.vx = -self.vx * COLLISION_DAMPING\\n if abs(norm_y) > .0001:\\n self.vy = -self.vy * COLLISION_DAMPING\\n self.collision_counter += 1\\n return True\\n return False\\n\\n # Old, mask-based collision code\\n \\\"\\\"\\\"\\n self.mask = pygame.mask.from_surface(self.image)\\n point = pygame.sprite.collide_mask(Map.current_map, self)\\n if point:\\n if COLLISION_ALGORITHM_EXPERIMENTAL:\\n self.vx, self.vy = collision.calculate_reflection_angle(Map.current_map.mask, point, (self.vx, self.vy))\\n else: \\n self.vx, self.vy = collision.simple_collision(Map.current_map.mask, point, (self.vx, self.vy))\\n self.vx, self.vy = self.vx * COLLISION_DAMPING, self.vy * COLLISION_DAMPING\\n \\n self.collision_counter += 1\\n return True\\n return False\\n \\\"\\\"\\\"\",\n \"def constrain(self, candidate_map, processed, to_process):\\n for component in self._components:\\n component.constrain(candidate_map, processed, to_process)\",\n \"def _manipulate_coupling(self, mappingf, prefactorf):\\n\\n ndata = {}\\n for okey in self:\\n for nkey in mappingf(okey):\\n pref = prefactorf(okey, nkey)\\n if math.isclose(pref, 0, rel_tol=0, abs_tol=1e-12):\\n continue\\n\\n b = np.multiply(pref, self[okey])\\n if nkey in ndata:\\n ndata[nkey] += b\\n else:\\n ndata[nkey] = b\\n self._data = ndata\",\n \"def _do_mapping(self):\\n pass\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CLAS').get('abstractTypes')\\n exolinks = globalMap.get('CLAS').get('exolinks')\\n\\n # Class AbstractCategory\\n currentMap = {}\\n abstractTypes['AbstractCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'] = currentMap\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.AbstractCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AbstractCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AbstractCategory.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'] = currentMap\\n loadMaps['CLAS.AbstractCategory.details'] = currentMap\\n currentMap['tag'] = 'CLAS.AbstractCategory.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute AbstractCategory.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'] = currentMap\\n loadMaps['CLAS.AbstractCategory.name'] = currentMap\\n currentMap['tag'] = 'CLAS.AbstractCategory.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role AbstractCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of AbstractCategory\\n\\n currentMap = abstractTypes.get('AbstractCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class Classification\\n currentMap = {}\\n abstractTypes['Classification'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'] = currentMap\\n loadMaps['CLAS.Classification'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'classifications'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'namingSystem'\\n currentMap['class'] = ccp.api.lims.Classification.Classification\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Classification.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Classification.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute Classification.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.namingSystem\\n currentMap = {}\\n contentMap['namingSystem'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'] = currentMap\\n loadMaps['CLAS.Classification.namingSystem'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.namingSystem'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'\\n currentMap['name'] = 'namingSystem'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role Classification.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role Classification.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'] = currentMap\\n loadMaps['CLAS.Classification.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.experimentTypes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.hazardPhrases\\n currentMap = {}\\n contentMap['hazardPhrases'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'] = currentMap\\n loadMaps['CLAS.Classification.hazardPhrases'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.hazardPhrases'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'\\n currentMap['name'] = 'hazardPhrases'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.holderCategorys\\n currentMap = {}\\n contentMap['holderCategorys'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'] = currentMap\\n loadMaps['CLAS.Classification.holderCategorys'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.holderCategorys'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'\\n currentMap['name'] = 'holderCategorys'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.instrumentTypes\\n currentMap = {}\\n contentMap['instrumentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'] = currentMap\\n loadMaps['CLAS.Classification.instrumentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.instrumentTypes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'\\n currentMap['name'] = 'instrumentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.sampleCategories\\n currentMap = {}\\n contentMap['sampleCategories'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'] = currentMap\\n loadMaps['CLAS.Classification.sampleCategories'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.sampleCategories'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'\\n currentMap['name'] = 'sampleCategories'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.sampleComponentCategory\\n currentMap = {}\\n contentMap['sampleComponentCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'] = currentMap\\n loadMaps['CLAS.Classification.sampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.sampleComponentCategory'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'\\n currentMap['name'] = 'sampleComponentCategory'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.targetScoreboards\\n currentMap = {}\\n contentMap['targetScoreboards'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'] = currentMap\\n loadMaps['CLAS.Classification.targetScoreboards'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.targetScoreboards'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'\\n currentMap['name'] = 'targetScoreboards'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.targetStatus\\n currentMap = {}\\n contentMap['targetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'] = currentMap\\n loadMaps['CLAS.Classification.targetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.targetStatus'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'\\n currentMap['name'] = 'targetStatus'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n # End of Classification\\n\\n currentMap = abstractTypes.get('Classification')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\\n currentMap['headerAttrs'] = aList\\n aList = ['namingSystem']\\n currentMap['simpleAttrs'] = aList\\n aList = ['targetStatus', 'targetScoreboards', 'sampleComponentCategory', 'sampleCategories', 'instrumentTypes', 'holderCategorys', 'hazardPhrases', 'experimentTypes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['experimentTypes', 'hazardPhrases', 'holderCategorys', 'instrumentTypes', 'sampleCategories', 'sampleComponentCategory', 'targetScoreboards', 'targetStatus']\\n currentMap['children'] = aList\\n\\n # Class SampleComponentCategory\\n currentMap = {}\\n abstractTypes['SampleComponentCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'] = currentMap\\n loadMaps['CLAS.SampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleComponentCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'sampleComponentCategory'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute SampleComponentCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute SampleComponentCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute SampleComponentCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role SampleComponentCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of SampleComponentCategory\\n\\n currentMap = abstractTypes.get('SampleComponentCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ExperimentType\\n currentMap = {}\\n abstractTypes['ExperimentType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'] = currentMap\\n loadMaps['CLAS.ExperimentType'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'experimentTypes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ExperimentType.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ExperimentType.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute ExperimentType.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role ExperimentType.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ExperimentType.instrumentTypes\\n currentMap = {}\\n contentMap['instrumentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'] = currentMap\\n loadMaps['CLAS.ExperimentType.instrumentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType.instrumentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'\\n currentMap['name'] = 'instrumentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n\\n # Role ExperimentType.sampleCategories\\n currentMap = {}\\n contentMap['sampleCategories'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'] = currentMap\\n loadMaps['CLAS.ExperimentType.sampleCategories'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType.sampleCategories'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'\\n currentMap['name'] = 'sampleCategories'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of ExperimentType\\n\\n currentMap = abstractTypes.get('ExperimentType')\\n aList = ['details', 'name', 'instrumentTypes', 'sampleCategories']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class TargetScoreboard\\n currentMap = {}\\n abstractTypes['TargetScoreboard'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'] = currentMap\\n loadMaps['CLAS.TargetScoreboard'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetScoreboard'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'targetScoreboards'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute TargetScoreboard.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute TargetScoreboard.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute TargetScoreboard.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role TargetScoreboard.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role TargetScoreboard.targetStatus\\n currentMap = {}\\n contentMap['targetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'] = currentMap\\n loadMaps['CLAS.TargetScoreboard.targetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetScoreboard.targetStatus'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'\\n currentMap['name'] = 'targetStatus'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of TargetScoreboard\\n\\n currentMap = abstractTypes.get('TargetScoreboard')\\n aList = ['details', 'name', 'targetStatus']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class HolderCategory\\n currentMap = {}\\n abstractTypes['HolderCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'] = currentMap\\n loadMaps['CLAS.HolderCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.HolderCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'holderCategorys'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute HolderCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute HolderCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute HolderCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role HolderCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of HolderCategory\\n\\n currentMap = abstractTypes.get('HolderCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class HazardPhrase\\n currentMap = {}\\n abstractTypes['HazardPhrase'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'] = currentMap\\n loadMaps['CLAS.HazardPhrase'] = currentMap\\n currentMap['tag'] = 'CLAS.HazardPhrase'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'hazardPhrases'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute HazardPhrase.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute HazardPhrase.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute HazardPhrase.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Attribute HazardPhrase.phrase\\n currentMap = {}\\n contentMap['phrase'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'] = currentMap\\n loadMaps['CLAS.HazardPhrase.phrase'] = currentMap\\n currentMap['tag'] = 'CLAS.HazardPhrase.phrase'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'\\n currentMap['name'] = 'phrase'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Role HazardPhrase.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of HazardPhrase\\n\\n currentMap = abstractTypes.get('HazardPhrase')\\n aList = ['details', 'name', 'phrase']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class InstrumentType\\n currentMap = {}\\n abstractTypes['InstrumentType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'] = currentMap\\n loadMaps['CLAS.InstrumentType'] = currentMap\\n currentMap['tag'] = 'CLAS.InstrumentType'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'instrumentTypes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute InstrumentType.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute InstrumentType.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute InstrumentType.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role InstrumentType.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role InstrumentType.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'] = currentMap\\n loadMaps['CLAS.InstrumentType.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.InstrumentType.experimentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of InstrumentType\\n\\n currentMap = abstractTypes.get('InstrumentType')\\n aList = ['details', 'name', 'experimentTypes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class SampleCategory\\n currentMap = {}\\n abstractTypes['SampleCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'] = currentMap\\n loadMaps['CLAS.SampleCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'sampleCategories'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute SampleCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute SampleCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute SampleCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role SampleCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role SampleCategory.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'] = currentMap\\n loadMaps['CLAS.SampleCategory.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleCategory.experimentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of SampleCategory\\n\\n currentMap = abstractTypes.get('SampleCategory')\\n aList = ['details', 'name', 'experimentTypes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class TargetStatus\\n currentMap = {}\\n abstractTypes['TargetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'] = currentMap\\n loadMaps['CLAS.TargetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetStatus'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'targetStatus'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute TargetStatus.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute TargetStatus.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute TargetStatus.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role TargetStatus.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role TargetStatus.targetScoreboards\\n currentMap = {}\\n contentMap['targetScoreboards'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'] = currentMap\\n loadMaps['CLAS.TargetStatus.targetScoreboards'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetStatus.targetScoreboards'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'\\n currentMap['name'] = 'targetScoreboards'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of TargetStatus\\n\\n currentMap = abstractTypes.get('TargetStatus')\\n aList = ['details', 'name', 'targetScoreboards']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to Classification\\n currentMap = {}\\n exolinks['Classification'] = currentMap\\n loadMaps['CLAS.exo-Classification'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-Classification'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\\n currentMap['name'] = 'Classification'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.Classification\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to SampleComponentCategory\\n currentMap = {}\\n exolinks['SampleComponentCategory'] = currentMap\\n loadMaps['CLAS.exo-SampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-SampleComponentCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\\n currentMap['name'] = 'SampleComponentCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to ExperimentType\\n currentMap = {}\\n exolinks['ExperimentType'] = currentMap\\n loadMaps['CLAS.exo-ExperimentType'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-ExperimentType'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\\n currentMap['name'] = 'ExperimentType'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to TargetScoreboard\\n currentMap = {}\\n exolinks['TargetScoreboard'] = currentMap\\n loadMaps['CLAS.exo-TargetScoreboard'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-TargetScoreboard'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\\n currentMap['name'] = 'TargetScoreboard'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to HolderCategory\\n currentMap = {}\\n exolinks['HolderCategory'] = currentMap\\n loadMaps['CLAS.exo-HolderCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-HolderCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\\n currentMap['name'] = 'HolderCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to HazardPhrase\\n currentMap = {}\\n exolinks['HazardPhrase'] = currentMap\\n loadMaps['CLAS.exo-HazardPhrase'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-HazardPhrase'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\\n currentMap['name'] = 'HazardPhrase'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to InstrumentType\\n currentMap = {}\\n exolinks['InstrumentType'] = currentMap\\n loadMaps['CLAS.exo-InstrumentType'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-InstrumentType'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\\n currentMap['name'] = 'InstrumentType'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to SampleCategory\\n currentMap = {}\\n exolinks['SampleCategory'] = currentMap\\n loadMaps['CLAS.exo-SampleCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-SampleCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\\n currentMap['name'] = 'SampleCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to TargetStatus\\n currentMap = {}\\n exolinks['TargetStatus'] = currentMap\\n loadMaps['CLAS.exo-TargetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-TargetStatus'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\\n currentMap['name'] = 'TargetStatus'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\",\n \"def limitByMapCollision(self,basemap,fontname='Bitstream Vera Sans',fontsize=10.0):\\n if basemap.ax is None:\\n raise DataSetException('Basemap is missing a reference to an \\\"axes\\\" object.')\\n ax = basemap.ax\\n\\n #get the transformation from display units (pixels) to data units\\n #we'll use this to set an offset in pixels between the city dot and\\n #the city name.\\n self._display_to_data_transform = ax.transData.inverted()\\n \\n self.project(basemap)\\n if 'x' not in self._dataframe.columns and 'y' not in self._dataframe.columns:\\n raise DataSetException('Cities object has not had project() called yet.')\\n \\n if fontname not in self._fontlist:\\n raise DataSetException('Font %s not in supported list.' % fontname)\\n #TODO: - check placement column\\n newdf = self._dataframe.copy()\\n #older versions of pandas use a different sort function\\n if pd.__version__ < '0.17.0':\\n newdf = newdf.sort(columns='pop',ascending=False)\\n else:\\n newdf = newdf.sort_values(by='pop',ascending=False)\\n\\n lefts,rights,bottoms,tops = self._getCityBoundingBoxes(newdf,fontname,fontsize,ax)\\n ikeep = ~np.isnan(lefts)\\n newdf = newdf.iloc[ikeep]\\n lefts = lefts[ikeep]\\n rights = rights[ikeep]\\n bottoms = bottoms[ikeep]\\n tops = tops[ikeep]\\n ikeep = [0] #indices of rows to keep in dataframe\\n for i in range(1,len(tops)):\\n cname = newdf.iloc[i]['name']\\n if cname.lower().find('pacific grove') > -1:\\n allnames = newdf['name'].tolist()\\n sidx = allnames.index('Salinas')\\n sleft = lefts[sidx]\\n sright = rights[sidx]\\n sbottom = bottoms[sidx]\\n stop = tops[sidx]\\n foo = 1\\n if np.isnan(lefts[i]):\\n continue\\n left = lefts[i]\\n right = rights[i]\\n bottom = bottoms[i]\\n top = tops[i]\\n\\n clrx = (left > rights[0:i]) | (right < lefts[0:i])\\n clry = (top < bottoms[0:i]) | (bottom > tops[0:i])\\n allclr = (clrx | clry)\\n if all(allclr):\\n ikeep.append(i)\\n else:\\n foo = 1\\n if len(newdf):\\n try:\\n newdf = newdf.iloc[ikeep]\\n newdf['top'] = tops[ikeep]\\n newdf['bottom'] = bottoms[ikeep]\\n newdf['left'] = lefts[ikeep]\\n newdf['right'] = rights[ikeep]\\n except Exception as e:\\n x = 1\\n return type(self)(newdf)\",\n \"def collide(self, pos):\\n\\t\\tpass\",\n \"def _fit_exact_match(self):\\n entity_map = self._resource_loader.get_entity_map(self.type)\\n self._exact_match_mapping = self._process_entity_map(\\n self.type, entity_map, self._normalizer\\n )\",\n \"def on_collision(self, other_sprite, game):\\n pass\",\n \"def check_collide(self): #New of Rev2.0\\r\\n for pizza in self.overlapping_sprites:\\r\\n self.score.value +=50 #Incr. score by 50\\r\\n pizza.handle_collide()\",\n \"def _check_mapping(self) -> PossibleResult[T]:\\n if isinstance(self.constructor_origin, type) and issubclass(\\n self.constructor_origin, Mapping\\n ):\\n if not isinstance(self.obj, Mapping):\\n raise DeserializeError(\\n Mapping, self.obj, self.new_depth, self.key\\n )\\n if self.constructor_args:\\n _tpkey = self.constructor_args[0]\\n _tpvalue = self.constructor_args[1]\\n else:\\n _tpkey = Any # type: ignore\\n _tpvalue = Any # type: ignore\\n return self.constructor_origin(\\n {\\n Deserialize(\\n obj=key,\\n constructor=_tpkey,\\n depth=self.new_depth,\\n convert_primitives=self.convert_primitives,\\n )\\n .run(): Deserialize(\\n obj=value,\\n constructor=_tpvalue,\\n depth=self.new_depth,\\n convert_primitives=self.convert_primitives,\\n key=key,\\n )\\n .run()\\n for key, value in self.obj.items()\\n }\\n ) # type: ignore\\n return NO_RESULT\",\n \"def collision_check(self):\\n return True\",\n \"def manageCollisions(cls, source, to):\\n to.triggerCollision(source)\\n logging.debug(\\\"%s sprite collided with %s\\\" % (source, to))\",\n \"def _configure(self):\\n from .topology import FieldBase\\n\\n Component._configure(self)\\n\\n mapBasis = {\\n \\\"simplex\\\": FieldBase.SIMPLEX_BASIS,\\n \\\"tensor\\\": FieldBase.TENSOR_BASIS,\\n \\\"default\\\": FieldBase.DEFAULT_BASIS,\\n }\\n self.cellBasis = mapBasis[self.inventory.cellBasisStr]\\n\\n mapSpace = {\\n \\\"polynomial\\\": FieldBase.POLYNOMIAL_SPACE,\\n \\\"point\\\": FieldBase.POINT_SPACE,\\n }\\n self.feSpace = mapSpace[self.inventory.feSpaceStr]\\n return\",\n \"def set_factors(self, name, factormap, safe=False):\\n e = False\\n if name in self.masks():\\n if self._get_subtype(name) != 'single':\\n e = True\\n else:\\n if self._get_type(name) != 'single':\\n e = True\\n if e:\\n if safe:\\n err = \\\"Can only set factors to 'single' type categorical variables!\\\"\\n raise TypeError(err)\\n else:\\n return None\\n vals = self.codes(name)\\n facts = list(factormap.keys())\\n val_loc = self._get_value_loc(name)\\n if not all(f in vals for f in facts):\\n err = 'At least one factor is mapped to a code that does not exist '\\n err += 'in the values object of \\\"{}\\\"!'\\n raise ValueError(err.format(name))\\n for value in val_loc:\\n if value['value'] in factormap:\\n value['factor'] = factormap[value['value']]\\n else:\\n value['factor'] = None\\n return None\",\n \"def collide(self, other, extra=None):\\n pass\",\n \"def __call__(\\n self,\\n dsk: Mapping,\\n *args: Any,\\n rename: Mapping[str, str] | None = None,\\n ) -> CollType_co:\\n raise NotImplementedError(\\\"Inheriting class must implement this method.\\\")\",\n \"def process_collision(self, obj, target):\\n if obj == \\\"small_hex\\\" and not self.smallhex.small_hex_flag:\\n self.ship.velocity.x = -self.ship.velocity.x\\n self.ship.velocity.y = -self.ship.velocity.y\\n self.gameevents.add(\\\"score-\\\", \\\"pnts\\\", self.config['Score']['small_hex_penalty'])\\n self.gameevents.add(\\\"score-\\\", \\\"flight\\\", self.config['Score']['small_hex_penalty'])\\n self.smallhex.small_hex_flag = True\\n elif obj == \\\"shell\\\":\\n #remove shell, target is index of shell in shell_list\\n del self.shell_list[target]\\n self.gameevents.add(\\\"score-\\\", \\\"pnts\\\", self.config['Score']['shell_hit_penalty'])\\n self.gameevents.add(\\\"score-\\\", \\\"fortress\\\", self.config['Score']['shell_hit_penalty'])\\n self.ship.take_damage()\\n if not self.ship.alive:\\n self.gameevents.add(\\\"destroyed\\\", \\\"ship\\\", \\\"shell\\\")\\n self.gameevents.add(\\\"score-\\\", \\\"pnts\\\", self.config['Score']['ship_death_penalty'])\\n self.gameevents.add(\\\"score-\\\", \\\"fortress\\\", self.config['Score']['ship_death_penalty'])\\n self.ship.color = (255, 255, 0)\\n elif self.config['Ship']['colored_damage']:\\n g = 255 / self.ship.start_health * (self.ship.health - 1)\\n self.ship.color = (255, g, 0)\\n\\n elif obj.startswith(\\\"missile_\\\"):\\n #if missile hits fortress, need to check if it takes damage when mine is onscreen\\n if target == \\\"fortress\\\" and (len(self.mine_list) == 0 or self.config['Fortress']['hit_fortress_while_mine']):\\n if self.ship.shot_timer.elapsed() >= self.config['Fortress']['vlner_time']:\\n self.gameevents.add(\\\"score+\\\", \\\"vlner\\\", 1)\\n if self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner >= self.config['Fortress']['vlner_threshold']:\\n self.gameevents.add(\\\"destroyed\\\", \\\"fortress\\\")\\n self.fortress.alive = False\\n #r = choice([0,45,90,135,180,225,270,315])\\n #if r:\\n # self.explosion.rotate(r)\\n self.fortress.reset_timer.reset()\\n self.snd_explosion.play()\\n self.gameevents.add(\\\"score+\\\", \\\"pnts\\\", self.config['Score']['destroy_fortress'])\\n self.gameevents.add(\\\"score+\\\", \\\"fortress\\\", self.config['Score']['destroy_fortress'])\\n self.score.vlner = 0\\n self.destroyedFortresses += 1\\n self.gameevents.add(\\\"reset\\\", \\\"VLNER\\\")\\n #do we reset the mine timer?\\n if self.config['Mine']['fortress_resets_mine']:\\n self.mine_list.timer.reset()\\n self.mine_list.flag = False\\n elif self.ship.shot_timer.elapsed() < self.config['Fortress']['vlner_time'] and self.score.vlner < self.config['Fortress']['vlner_threshold']:\\n self.gameevents.add(\\\"reset\\\", \\\"VLNER\\\")\\n self.score.vlner = 0\\n self.snd_vlner_reset.play()\\n self.ship.shot_timer.reset()\\n elif target.startswith(\\\"mine_\\\"):\\n #deal with missile hitting mine\\n #can the mine be hit?\\n if len(self.mine_list) > 0:\\n if self.mine_list[0].tagged == \\\"fail\\\":\\n self.gameevents.add(\\\"collide\\\", \\\"fail_tagged_mine\\\")\\n elif self.mine_list[0].tagged == \\\"disabled\\\":\\n self.gameevents.add(\\\"collide\\\", \\\"disable_tagged_mine\\\")\\n elif self.mine_list[0].tagged == \\\"untagged\\\":\\n if self.score.iff in self.mine_list.foe_letters:\\n self.mine_list[0].tagged = \\\"disable\\\"\\n self.gameevents.add(\\\"collide\\\", \\\"untagged_foe_mine\\\")\\n else:\\n self.gameevents.add(\\\"collide\\\", \\\"friend_mine\\\")\\n elif self.mine_list[0].tagged == \\\"tagged\\\" and self.score.iff in self.mine_list.foe_letters:\\n self.gameevents.add(\\\"collide\\\", \\\"tagged_foe_mine\\\")\\n elif obj.startswith(\\\"mine_\\\"):\\n #mine hit the ship\\n index = int(obj[-1])\\n #check to see if mine is still alive, it is possible to shot and\\n #collide with a mine at the same time, ties go to ship\\n if index < len(self.mine_list):\\n del self.mine_list[index]\\n self.score.iff = ''\\n self.score.intrvl = 0\\n self.mine_list.flag = False\\n self.mine_list.iff_flag = False\\n self.mine_list.timer.reset()\\n self.gameevents.add(\\\"score-\\\", \\\"pnts\\\", self.config['Score']['mine_hit_penalty'])\\n self.gameevents.add(\\\"score-\\\", \\\"mines\\\", self.config['Score']['mine_hit_penalty'])\\n self.mine2 -= self.config['Score']['mine_hit_penalty']\\n self.ship.take_damage()\\n if not self.ship.alive:\\n self.gameevents.add(\\\"destroyed\\\", \\\"ship\\\", \\\"mine\\\")\\n self.gameevents.add(\\\"score-\\\", \\\"pnts\\\", self.config['Score']['ship_death_penalty'])\\n self.gameevents.add(\\\"score-\\\", \\\"mines\\\", self.config['Score']['ship_death_penalty'])\\n self.mine2 -= self.config['Score']['ship_death_penalty']\\n self.ship.color = (255, 255, 0)\\n elif self.config['Ship']['colored_damage']:\\n g = 255 / self.ship.start_health * (self.ship.health - 1)\\n self.ship.color = (255, g, 0)\\n elif obj == \\\"friend_mine\\\":\\n #get rid of mine\\n self.destroyedMines += 1\\n self.mine_list.flag = False\\n self.mine_list.iff_flag = False\\n self.gameevents.add(\\\"score+\\\", \\\"mines\\\", self.config['Score']['energize_friend'])\\n self.gameevents.add(\\\"score+\\\", \\\"pnts\\\", self.config['Score']['energize_friend'])\\n #see how long mine has been alive. 0-100 points if destroyed within 10 seconds\\n self.gameevents.add(\\\"score+\\\", \\\"mines\\\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\\n self.gameevents.add(\\\"score+\\\", \\\"speed\\\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\\n #print self.mine_list.timer.elapsed()\\n #print 100 - 10 * math.floor(self.mine_list.timer.elapsed()/1000)\\n self.mine_list.timer.reset()\\n self.mine2 += 50\\n #amazingly, missile can hit the mine in the same frame as the mine hits the ship\\n if len(self.mine_list) > 0:\\n del self.mine_list[0]\\n self.score.iff = ''\\n self.score.intrvl = 0\\n elif obj == \\\"tagged_foe_mine\\\":\\n #get rid of mine\\n self.destroyedMines += 1\\n self.mine_list.flag = False\\n self.mine_list.iff_flag = False\\n self.gameevents.add(\\\"score+\\\", \\\"mines\\\", self.config['Score']['destroy_foe'])\\n self.gameevents.add(\\\"score+\\\", \\\"pnts\\\", self.config['Score']['destroy_foe'])\\n #see how long mine has been alive. 0-100 points if destroyed within 10 seconds\\n self.gameevents.add(\\\"score+\\\", \\\"mines\\\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\\n self.gameevents.add(\\\"score+\\\", \\\"speed\\\", 100 - 10 * math.floor(self.mine_list.timer.elapsed() / 1000))\\n self.mine_list.timer.reset()\\n self.mine2 += 75\\n if len(self.mine_list) > 0:\\n del self.mine_list[0]\\n self.score.iff = ''\\n self.score.intrvl = 0\",\n \"def on_collision(self):\",\n \"def _update_farness_map(self,ind):\",\n \"def __init__(self):\\n\\n for layer in self._layer_class_map:\\n setattr(self, layer, self._layer_class_map[layer]())\",\n \"def _init_from_dict(self, cfg):\\n if self.top_level:\\n # this is a top level domain\\n self.parent_cell_size_ratio = 1\\n self.parent_time_step_ratio = 1\\n self.cell_size = tuple(cfg['cell_size'])\\n self.ref_latlon = tuple(cfg['center_latlon'])\\n self.domain_size = tuple(cfg['domain_size'])\\n self.time_step = cfg.get('time_step', int(max(6*min(self.domain_size) // 1000, 1)))\\n self.parent_start = (1,1)\\n if 'truelats' in cfg:\\n self.truelats = cfg['truelats']\\n else:\\n self.truelats = [self.ref_lat]*2\\n if 'stand_lon' in cfg:\\n self.stand_lon = cfg['stand_lon']\\n else:\\n self.stand_lon = self.ref_lon\\n self._init_projection()\\n else:\\n self.parent_cell_size_ratio = cfg['parent_cell_size_ratio']\\n self.parent_time_step_ratio = cfg['parent_time_step_ratio']\\n self.cell_size = [float(x) / self.parent_cell_size_ratio for x in self.parent.cell_size]\\n if 'bounding_box' in cfg:\\n # this is a child domain that we need to place dynamically given a bounding box\\n self.bbox = tuple(cfg['bounding_box'])\\n\\n min_lon, min_lat, max_lon, max_lat = self.bbox\\n\\n # project the min/max coordinates\\n i1, j1 = self.parent.latlon_to_ij(min_lat, min_lon)\\n i2, j2 = self.parent.latlon_to_ij(max_lat, max_lon)\\n\\n self.parent_start = (int(i1), int(j1))\\n self.parent_end = (int(i2+1), int(j2+1))\\n\\n if any([x < 0 for x in self.parent_start]) or \\\\\\n self.parent_end[0] >= self.parent.domain_size[0] or \\\\\\n self.parent_end[1] >= self.parent.domain_size[1]:\\n raise ValueError('Cannot place child, out of parents bounds')\\n\\n pstart, pend, pgr = self.parent_start, self.parent_end, self.parent_cell_size_ratio\\n self.domain_size = (pgr * (pend[0] - pstart[0] + 1) + 1, pgr * (pend[1] - pstart[1] + 1) + 1)\\n elif 'parent_start' in cfg and 'parent_end' in cfg:\\n # this is a child domain, placed normally\\n self.parent_start = tuple(cfg['parent_start'])\\n self.parent_end = tuple(cfg['parent_end'])\\n pstart, pend, pgr = self.parent_start, self.parent_end, self.parent_cell_size_ratio\\n self.domain_size = (pgr * (pend[0] - pstart[0] + 1) + 1, pgr * (pend[1] - pstart[1] + 1) + 1)\\n else:\\n raise ValueError('Invalid domain specification')\\n\\n # either way, it's not precomputed\\n self.precomputed = False\",\n \"def __init__(self, map):\\n self.map = map\\n self.fast_validate = (6, map)\",\n \"def add_collision_mask(prim: Usd.Prim):\\n collisionAPI = PhysicsSchema.CollisionAPI.Apply(prim)\\n collisionAPI.CreatePhysicsMaterialRel()\\n collisionAPI.CreateCollisionGroupRel()\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CHEL').get('abstractTypes')\\n exolinks = globalMap.get('CHEL').get('exolinks')\\n\\n # DataType HalfLifeType\\n currentMap = {}\\n abstractTypes['HalfLifeType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'] = currentMap\\n loadMaps['CHEL.HalfLifeType'] = currentMap\\n currentMap['tag'] = 'CHEL.HalfLifeType'\\n currentMap['type'] = 'simple'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'\\n currentMap['toStr'] = 'text'\\n currentMap['cnvrt'] = 'text'\\n\\n # Class ChemElement\\n currentMap = {}\\n abstractTypes['ChemElement'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'] = currentMap\\n loadMaps['CHEL.ChemElement'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemElements'\\n currentMap['objkey'] = 'symbol'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemElement.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemElement.atomNumber\\n currentMap = {}\\n contentMap['atomNumber'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'] = currentMap\\n loadMaps['CHEL.ChemElement.atomNumber'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.atomNumber'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'\\n currentMap['name'] = 'atomNumber'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['proc'] = 'direct'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute ChemElement.atomicRadius\\n currentMap = {}\\n contentMap['atomicRadius'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'] = currentMap\\n loadMaps['CHEL.ChemElement.atomicRadius'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.atomicRadius'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'\\n currentMap['name'] = 'atomicRadius'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.covalentRadius\\n currentMap = {}\\n contentMap['covalentRadius'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'] = currentMap\\n loadMaps['CHEL.ChemElement.covalentRadius'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.covalentRadius'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'\\n currentMap['name'] = 'covalentRadius'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.mass\\n currentMap = {}\\n contentMap['mass'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'] = currentMap\\n loadMaps['CHEL.ChemElement.mass'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.mass'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'\\n currentMap['name'] = 'mass'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'] = currentMap\\n loadMaps['CHEL.ChemElement.name'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\\n\\n # Attribute ChemElement.symbol\\n currentMap = {}\\n contentMap['symbol'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'] = currentMap\\n loadMaps['CHEL.ChemElement.symbol'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.symbol'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'\\n currentMap['name'] = 'symbol'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\\n\\n # Role ChemElement.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemElement.isotopes\\n currentMap = {}\\n contentMap['isotopes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'] = currentMap\\n loadMaps['CHEL.ChemElement.isotopes'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.isotopes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'\\n currentMap['name'] = 'isotopes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\\n # End of ChemElement\\n\\n currentMap = abstractTypes.get('ChemElement')\\n aList = ['atomNumber', 'atomicRadius', 'covalentRadius', 'mass', 'name', 'symbol']\\n currentMap['headerAttrs'] = aList\\n aList = ['isotopes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['isotopes']\\n currentMap['children'] = aList\\n\\n # Class ChemElementStore\\n currentMap = {}\\n abstractTypes['ChemElementStore'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'] = currentMap\\n loadMaps['CHEL.ChemElementStore'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemElementStores'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemElementStore.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemElementStore.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute ChemElementStore.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'] = currentMap\\n loadMaps['CHEL.ChemElementStore.name'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role ChemElementStore.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemElementStore.chemElements\\n currentMap = {}\\n contentMap['chemElements'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'] = currentMap\\n loadMaps['CHEL.ChemElementStore.chemElements'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore.chemElements'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'\\n currentMap['name'] = 'chemElements'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\\n # End of ChemElementStore\\n\\n currentMap = abstractTypes.get('ChemElementStore')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\\n currentMap['headerAttrs'] = aList\\n aList = ['name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['chemElements', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['chemElements']\\n currentMap['children'] = aList\\n\\n # Class Isotope\\n currentMap = {}\\n abstractTypes['Isotope'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'] = currentMap\\n loadMaps['CHEL.Isotope'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'isotopes'\\n currentMap['objkey'] = 'massNumber'\\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Isotope.abundance\\n currentMap = {}\\n contentMap['abundance'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'] = currentMap\\n loadMaps['CHEL.Isotope.abundance'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.abundance'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'\\n currentMap['name'] = 'abundance'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00058')\\n\\n # Attribute Isotope.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Isotope.gyroMagneticRatio\\n currentMap = {}\\n contentMap['gyroMagneticRatio'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'] = currentMap\\n loadMaps['CHEL.Isotope.gyroMagneticRatio'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.gyroMagneticRatio'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'\\n currentMap['name'] = 'gyroMagneticRatio'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.halfLife\\n currentMap = {}\\n contentMap['halfLife'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'] = currentMap\\n loadMaps['CHEL.Isotope.halfLife'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLife'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'\\n currentMap['name'] = 'halfLife'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\\n\\n # Attribute Isotope.halfLifeError\\n currentMap = {}\\n contentMap['halfLifeError'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'] = currentMap\\n loadMaps['CHEL.Isotope.halfLifeError'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLifeError'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'\\n currentMap['name'] = 'halfLifeError'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\\n\\n # Attribute Isotope.halfLifeType\\n currentMap = {}\\n contentMap['halfLifeType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'] = currentMap\\n loadMaps['CHEL.Isotope.halfLifeType'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLifeType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'\\n currentMap['name'] = 'halfLifeType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'unknown'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002')\\n\\n # Attribute Isotope.magneticMoment\\n currentMap = {}\\n contentMap['magneticMoment'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'] = currentMap\\n loadMaps['CHEL.Isotope.magneticMoment'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.magneticMoment'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'\\n currentMap['name'] = 'magneticMoment'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.mass\\n currentMap = {}\\n contentMap['mass'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'] = currentMap\\n loadMaps['CHEL.Isotope.mass'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.mass'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'\\n currentMap['name'] = 'mass'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.massNumber\\n currentMap = {}\\n contentMap['massNumber'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'] = currentMap\\n loadMaps['CHEL.Isotope.massNumber'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.massNumber'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'\\n currentMap['name'] = 'massNumber'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Isotope.quadrupoleMoment\\n currentMap = {}\\n contentMap['quadrupoleMoment'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'] = currentMap\\n loadMaps['CHEL.Isotope.quadrupoleMoment'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.quadrupoleMoment'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'\\n currentMap['name'] = 'quadrupoleMoment'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.receptivity\\n currentMap = {}\\n contentMap['receptivity'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'] = currentMap\\n loadMaps['CHEL.Isotope.receptivity'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.receptivity'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'\\n currentMap['name'] = 'receptivity'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.spin\\n currentMap = {}\\n contentMap['spin'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'] = currentMap\\n loadMaps['CHEL.Isotope.spin'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.spin'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'\\n currentMap['name'] = 'spin'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role Isotope.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of Isotope\\n\\n currentMap = abstractTypes.get('Isotope')\\n aList = ['abundance', 'gyroMagneticRatio', 'halfLife', 'halfLifeError', 'halfLifeType', 'magneticMoment', 'mass', 'massNumber', 'quadrupoleMoment', 'receptivity', 'spin']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to ChemElement\\n currentMap = {}\\n exolinks['ChemElement'] = currentMap\\n loadMaps['CHEL.exo-ChemElement'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-ChemElement'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\\n currentMap['name'] = 'ChemElement'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\\n\\n # Out-of-package link to ChemElementStore\\n currentMap = {}\\n exolinks['ChemElementStore'] = currentMap\\n loadMaps['CHEL.exo-ChemElementStore'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-ChemElementStore'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\\n currentMap['name'] = 'ChemElementStore'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to Isotope\\n currentMap = {}\\n exolinks['Isotope'] = currentMap\\n loadMaps['CHEL.exo-Isotope'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-Isotope'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\\n currentMap['name'] = 'Isotope'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\",\n \"def test_fibermap_rw(self):\\n from ..io.fibermap import empty_fibermap, read_fibermap, write_fibermap\\n fibermap = empty_fibermap(10)\\n for key in fibermap.dtype.names:\\n column = fibermap[key]\\n fibermap[key] = np.random.random(column.shape).astype(column.dtype)\\n\\n write_fibermap(self.testfile, fibermap)\\n\\n fm = read_fibermap(self.testfile)\\n self.assertTrue(isinstance(fm, Table))\\n\\n self.assertEqual(set(fibermap.dtype.names), set(fm.dtype.names))\\n for key in fibermap.dtype.names:\\n c1 = fibermap[key]\\n c2 = fm[key]\\n #- Endianness may change, but kind, size, shape, and values are same\\n self.assertEqual(c1.shape, c2.shape)\\n self.assertTrue(np.all(c1 == c2))\\n if c1.dtype.kind == 'U':\\n self.assertTrue(c2.dtype.kind in ('S', 'U'))\\n else:\\n self.assertEqual(c1.dtype.kind, c2.dtype.kind)\\n self.assertEqual(c1.dtype.itemsize, c2.dtype.itemsize)\\n\\n #- read_fibermap also works with open file pointer\\n with fitsio.FITS(self.testfile) as fp:\\n fm1 = read_fibermap(fp)\\n self.assertTrue(np.all(fm1 == fm))\\n\\n with fits.open(self.testfile) as fp:\\n fm2 = read_fibermap(fp)\\n self.assertTrue(np.all(fm2 == fm))\",\n \"def _standard_mapping(self):\\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\\n self.camvidMap = mapping_raw['camvidMap'] * 255\\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255\",\n \"def _add_force(Fg: np.ndarray, dof_map: Dict[Tuple[int, int], int], model: BDF,\\n load, offset: int, ndof_per_grid: int, cid: int=0, show_warning: bool=True):\\n #cid = load.cid\\n nid = load.node\\n node_ref = load.node_ref\\n ndofi = ndof_per_grid if node_ref.type == 'GRID' else 1\\n assert ndofi == 6, f'GRID must have 6 DOF for structural analysis\\\\n{node_ref}'\\n\\n if node_ref.cd == cid:\\n fglobal = load.mag * load.xyz\\n elif node_ref.cd != cid:\\n fbasic = load.to_global()\\n if show_warning:\\n model.log.warning(f'differing cid & cd is not supported; cid={cid} cd={node_ref.cd}')\\n show_warning = False\\n cd_ref = node_ref.cd_ref\\n Tbg = cd_ref.beta()\\n fglobal = _force_to_local(cd_ref, fbasic)\\n\\n if 0: # pragma: no cover\\n if cd_ref.type[-1] in ['C', 'S']:\\n ex = Tbg[0, :]\\n ey = Tbg[1, :]\\n #ez = Tbg[2, :]\\n xyz_local = node_ref.get_position_wrt(model, node_ref.cd)\\n if cd_ref.type[-1] == 'C':\\n theta = radians(xyz_local[1])\\n ct = cos(theta)\\n st = sin(theta)\\n T = np.array([\\n [ct, -st, 0.],\\n [st, ct, 0.],\\n [0., 0., 1.],\\n ])\\n Tbg = Tbg @ T\\n else:\\n from pyNastran.bdf.cards.coordinate_systems import CORD2S\\n rho, thetad, phid = xyz_local\\n coord = CORD2S.add_ijk(-1, origin=cd_ref.origin, i=ex, j=ey, k=None, rid=0, comment='')\\n beta = coord.beta()\\n Tbg = Tbg @ beta\\n coord.transform_vector_to_local([rho, thetad, phid])\\n #theta = radians(xyz_local[1])\\n #phi = radians(xyz_local[2])\\n #ct = cos(theta)\\n #st = sin(theta)\\n\\n #cp = cos(phi)\\n #sp = sin(phi)\\n\\n str(xyz_local)\\n else:\\n # rectangular\\n pass\\n Tgb = Tbg.T\\n fglobal = Tgb @ fbasic\\n else:\\n raise NotImplementedError(f'node_ref.cd={node_ref.cd} cid={cid} load:\\\\n{str(load)}')\\n\\n for dof in range(3):\\n irow = dof_map[(nid, dof+offset)]\\n Fg[irow] += fglobal[dof]\\n return show_warning\",\n \"def __init__(self, size:Point, **kwargs):\\n PhysicsEntity.__init__(self, **kwargs)\\n self.size = size\\n self.collision_shape = to_collision_rect(self.size)\",\n \"def __init__(self, word_fd, bigram_fd, wildcard_fd, trigram_fd):\\n AbstractCollocationFinder.__init__(self, word_fd, trigram_fd)\\n self.wildcard_fd = wildcard_fd\\n self.bigram_fd = bigram_fd\",\n \"def start_collision_handlers(self):\\n self.missile_and_terrain.begin = self.missile_terrain_collision_begin\\n self.missile_and_spacecraft_handler.begin = self.missile_spacecraft_collision_begin\\n self.spacecraft_and_terrain_handler.begin = self.spacecraft_terrain_collision_begin\\n\\n self.missile_and_spacecraft_handler.pre_solve = self.collision_pre\\n self.missile_and_spacecraft_handler.post_solve = self.collision_post_solve\\n self.missile_and_spacecraft_handler.separate = self.collision_separate\\n self.missile_and_terrain.pre_solve = self.collision_pre\\n self.missile_and_terrain.post_solve = self.collision_post_solve\\n self.missile_and_terrain.separate = self.collision_separate\\n self.spacecraft_and_terrain_handler.pre_solve = self.collision_pre\\n self.spacecraft_and_terrain_handler.post_solve = self.collision_post_solve\\n self.spacecraft_and_terrain_handler.separate = self.collision_separate\",\n \"def check_collide(self):\\n\\n\\t\\tfor pizza in self.overlapping_sprites:\\n\\t\\t\\tpizza.handle_collide()\",\n \"def update(self, f):\\n\\n for p in self.__mapper__.attrs:\\n\\n if p.key == 'oid':\\n continue\\n try:\\n setattr(self, p.key, getattr(f, p.key))\\n\\n except AttributeError:\\n # The dict() method copies data property values into the main dict,\\n # and these don't have associated class properties.\\n continue\",\n \"def update(self, f):\\n\\n for p in self.__mapper__.attrs:\\n\\n if p.key == 'oid':\\n continue\\n try:\\n setattr(self, p.key, getattr(f, p.key))\\n\\n except AttributeError:\\n # The dict() method copies data property values into the main dict,\\n # and these don't have associated class properties.\\n continue\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CCLB').get('abstractTypes')\\n exolinks = globalMap.get('CCLB').get('exolinks')\\n\\n # Class AtomLabel\\n currentMap = {}\\n abstractTypes['AtomLabel'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'] = currentMap\\n loadMaps['CCLB.AtomLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'atomLabels'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AtomLabel.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AtomLabel.isotopeCode\\n currentMap = {}\\n contentMap['isotopeCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'] = currentMap\\n loadMaps['CCLB.AtomLabel.isotopeCode'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.isotopeCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00092'\\n currentMap['name'] = 'isotopeCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AtomLabel.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'] = currentMap\\n loadMaps['CCLB.AtomLabel.name'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00003'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AtomLabel.subType\\n currentMap = {}\\n contentMap['subType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'] = currentMap\\n loadMaps['CCLB.AtomLabel.subType'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.subType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00004'\\n currentMap['name'] = 'subType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['default'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute AtomLabel.weight\\n currentMap = {}\\n contentMap['weight'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'] = currentMap\\n loadMaps['CCLB.AtomLabel.weight'] = currentMap\\n currentMap['tag'] = 'CCLB.AtomLabel.weight'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00093'\\n currentMap['name'] = 'weight'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 1.0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\\n\\n # Role AtomLabel.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of AtomLabel\\n\\n currentMap = abstractTypes.get('AtomLabel')\\n aList = ['isotopeCode', 'name', 'subType', 'weight']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ChemCompLabel\\n currentMap = {}\\n abstractTypes['ChemCompLabel'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'] = currentMap\\n loadMaps['CCLB.ChemCompLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemCompLabels'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemCompLabel.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemCompLabel.ccpCode\\n currentMap = {}\\n contentMap['ccpCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.ccpCode'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.ccpCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00073'\\n currentMap['name'] = 'ccpCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ChemCompLabel.molType\\n currentMap = {}\\n contentMap['molType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.molType'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.molType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:37_00072'\\n currentMap['name'] = 'molType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\\n\\n # Role ChemCompLabel.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemCompLabel.isotopomers\\n currentMap = {}\\n contentMap['isotopomers'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'] = currentMap\\n loadMaps['CCLB.ChemCompLabel.isotopomers'] = currentMap\\n currentMap['tag'] = 'CCLB.ChemCompLabel.isotopomers'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:13_00001'\\n currentMap['name'] = 'isotopomers'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of ChemCompLabel\\n\\n currentMap = abstractTypes.get('ChemCompLabel')\\n aList = ['ccpCode', 'molType']\\n currentMap['headerAttrs'] = aList\\n aList = ['isotopomers', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['isotopomers']\\n currentMap['children'] = aList\\n\\n # Class Isotopomer\\n currentMap = {}\\n abstractTypes['Isotopomer'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'] = currentMap\\n loadMaps['CCLB.Isotopomer'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'isotopomers'\\n currentMap['objkey'] = 'serial'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Isotopomer.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Isotopomer.serial\\n currentMap = {}\\n contentMap['serial'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'] = currentMap\\n loadMaps['CCLB.Isotopomer.serial'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.serial'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00005'\\n currentMap['name'] = 'serial'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Isotopomer.weight\\n currentMap = {}\\n contentMap['weight'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'] = currentMap\\n loadMaps['CCLB.Isotopomer.weight'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.weight'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00006'\\n currentMap['name'] = 'weight'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 1.0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00009')\\n\\n # Role Isotopomer.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role Isotopomer.atomLabels\\n currentMap = {}\\n contentMap['atomLabels'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'] = currentMap\\n loadMaps['CCLB.Isotopomer.atomLabels'] = currentMap\\n currentMap['tag'] = 'CCLB.Isotopomer.atomLabels'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:30:14_00001'\\n currentMap['name'] = 'atomLabels'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of Isotopomer\\n\\n currentMap = abstractTypes.get('Isotopomer')\\n aList = ['serial', 'weight']\\n currentMap['headerAttrs'] = aList\\n aList = ['atomLabels', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['atomLabels']\\n currentMap['children'] = aList\\n\\n # Class LabelingScheme\\n currentMap = {}\\n abstractTypes['LabelingScheme'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'] = currentMap\\n loadMaps['CCLB.LabelingScheme'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'labelingSchemes'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute LabelingScheme.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute LabelingScheme.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'] = currentMap\\n loadMaps['CCLB.LabelingScheme.details'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00005'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute LabelingScheme.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute LabelingScheme.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute LabelingScheme.longName\\n currentMap = {}\\n contentMap['longName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'] = currentMap\\n loadMaps['CCLB.LabelingScheme.longName'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.longName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00004'\\n currentMap['name'] = 'longName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute LabelingScheme.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'] = currentMap\\n loadMaps['CCLB.LabelingScheme.name'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00003'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role LabelingScheme.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role LabelingScheme.chemCompLabels\\n currentMap = {}\\n contentMap['chemCompLabels'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'] = currentMap\\n loadMaps['CCLB.LabelingScheme.chemCompLabels'] = currentMap\\n currentMap['tag'] = 'CCLB.LabelingScheme.chemCompLabels'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:55_00002'\\n currentMap['name'] = 'chemCompLabels'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CCLB').get('abstractTypes')\\n # End of LabelingScheme\\n\\n currentMap = abstractTypes.get('LabelingScheme')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy', 'name']\\n currentMap['headerAttrs'] = aList\\n aList = ['details', 'longName']\\n currentMap['simpleAttrs'] = aList\\n aList = ['chemCompLabels', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['chemCompLabels']\\n currentMap['children'] = aList\\n\\n # Out-of-package link to AtomLabel\\n currentMap = {}\\n exolinks['AtomLabel'] = currentMap\\n loadMaps['CCLB.exo-AtomLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-AtomLabel'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00018'\\n currentMap['name'] = 'AtomLabel'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.AtomLabel\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n\\n # Out-of-package link to ChemCompLabel\\n currentMap = {}\\n exolinks['ChemCompLabel'] = currentMap\\n loadMaps['CCLB.exo-ChemCompLabel'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-ChemCompLabel'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:25:09_00014'\\n currentMap['name'] = 'ChemCompLabel'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.ChemCompLabel\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n\\n # Out-of-package link to Isotopomer\\n currentMap = {}\\n exolinks['Isotopomer'] = currentMap\\n loadMaps['CCLB.exo-Isotopomer'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-Isotopomer'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-24-11:28:54_00001'\\n currentMap['name'] = 'Isotopomer'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.Isotopomer\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n\\n # Out-of-package link to LabelingScheme\\n currentMap = {}\\n exolinks['LabelingScheme'] = currentMap\\n loadMaps['CCLB.exo-LabelingScheme'] = currentMap\\n currentMap['tag'] = 'CCLB.exo-LabelingScheme'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-01-24-12:23:14_00001'\\n currentMap['name'] = 'LabelingScheme'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemCompLabel.LabelingScheme\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\",\n \"def updateMap(toname, fromname, map):\\n fromobj = map[fromname]\\n if isinstance(fromobj, ForcefieldResidue):\\n if toname not in map:\\n newres = ForcefieldResidue(fromname)\\n map[toname] = newres\\n for atomname in fromobj.atoms:\\n map[toname].atoms[atomname] = fromobj.atoms[atomname]\\n elif isinstance(fromobj, ForcefieldAtom):\\n map[toname] = fromobj\",\n \"def collision(self, block):\\n if self.pos_x == block.pos_x and self.pos_y+self.height == block.pos_y:\\n self.col_d = True\\n if self.pos_x == block.pos_x+block.width and self.pos_y == block.pos_y:\\n self.col_l = True\\n if self.pos_x == block.pos_x-self.width and self.pos_y == block.pos_y:\\n self.col_r = True\",\n \"def __init__(self, cutoff: float = 0.6):\\r\\n super(FuzzyDict, self).__init__()\\r\\n self.cutoff = cutoff\\r\\n\\r\\n # short wrapper around some super (dict) methods\\r\\n self._dict_contains = lambda key: super(FuzzyDict, self).__contains__(key)\\r\\n self._dict_getitem = lambda key: super(FuzzyDict, self).__getitem__(key)\",\n \"def update_maps(self):\\n if self.fmodel is None:\\n return\\n def fft_map(map_coeffs, resolution_factor = 0.25):\\n return map_coeffs.fft_map(resolution_factor = resolution_factor,\\n ).apply_sigma_scaling().real_map_unpadded()\\n map_types = [\\\"2mFo-DFc\\\", \\\"mFo-DFc\\\"]\\n map_keys = [\\\"2mFo-DFc\\\", \\\"mFo-DFc\\\"]\\n if (self.fmodel.f_obs().anomalous_flag()):\\n if (self.params.anom_map_type == \\\"phaser\\\"):\\n map_types.append(\\\"llg\\\")\\n elif (self.params.anom_map_type == \\\"residual\\\"):\\n map_types.append(\\\"anom_residual\\\")\\n else :\\n map_types.append(\\\"anom\\\")\\n map_keys.append(\\\"anom\\\")\\n if (self.use_svm):\\n map_types.append(\\\"mFo\\\")\\n map_keys.append(\\\"mFo\\\")\\n # To save memory, we sample atomic positions immediately and throw out\\n # the actual maps (instead of keeping up to 3 in memory)\\n sites_frac = self.xray_structure.sites_frac()\\n sites_cart = self.xray_structure.sites_cart()\\n self._principal_axes_of_inertia = [ None ] * len(sites_frac)\\n self._map_variances = [ None ] * len(sites_frac)\\n self._map_gaussian_fits = {}\\n self.calpha_mean_two_fofc = 0\\n for map_type, map_key in zip(map_types, map_keys):\\n real_map = self.get_map(map_type)\\n if (real_map is not None):\\n # Gather values for map peaks at each site\\n self._map_values[map_key] = flex.double(sites_frac.size(), 0)\\n self._map_gaussian_fits[map_key] = [ None ] * len(sites_frac)\\n for i_seq, site_frac in enumerate(sites_frac):\\n atom = self.pdb_atoms[i_seq]\\n resname = atom.fetch_labels().resname.strip().upper()\\n if (resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED or\\n atom.segid.strip().upper() in [\\\"ION\\\"]):\\n value = real_map.eight_point_interpolation(site_frac)\\n self._map_values[map_key][i_seq] = value\\n if (self.use_svm):\\n gaussian_fit = utils.fit_gaussian(\\n unit_cell=self.unit_cell,\\n site_cart=atom.xyz,\\n real_map=real_map)\\n self._map_gaussian_fits[map_key][i_seq] = gaussian_fit\\n\\n if map_type in [\\\"2mFo-DFc\\\"]:\\n # Gather values on map variance and principal axes of interia\\n from cctbx import maptbx\\n for i_seq, site_cart in enumerate(sites_cart):\\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\\n if resname in WATER_RES_NAMES + mmtbx.ions.SUPPORTED:\\n # XXX not totally confident about how I'm weighting this...\\n p_a_i = maptbx.principal_axes_of_inertia(\\n real_map = real_map,\\n site_cart = site_cart,\\n unit_cell = self.unit_cell,\\n radius = self.params.map_sampling_radius)\\n self._principal_axes_of_inertia[i_seq] = p_a_i\\n variance = maptbx.spherical_variance_around_point(\\n real_map = real_map,\\n unit_cell = self.unit_cell,\\n site_cart = site_cart,\\n radius = self.params.map_sampling_radius)\\n self._map_variances[i_seq] = variance\\n elif (i_seq in self.calpha_sel):\\n # Also collect some info in average C_alpha 2FoFc peak heights\\n self.calpha_mean_two_fofc += real_map.eight_point_interpolation(\\n sites_frac[i_seq])\\n del real_map\\n\\n if (self.calpha_mean_two_fofc > 0):\\n n_calpha = len(self.calpha_sel)\\n assert (n_calpha > 0)\\n self.calpha_mean_two_fofc /= n_calpha\\n\\n # Gather info on carbons' average Fo peak height for use in estimating other\\n # sites' atomic weight\\n self.carbon_fo_values = None\\n if (len(self.carbon_sel) > 0):\\n self.carbon_fo_values = flex.double()\\n self._map_values[\\\"mFo\\\"] = flex.double(sites_frac.size(), 0)\\n fo_map = fft_map(self.fmodel.map_coefficients(\\n map_type = \\\"mFo\\\",\\n exclude_free_r_reflections = True,\\n fill_missing = True))\\n\\n for i_seq, site_frac in enumerate(sites_frac):\\n resname = self.pdb_atoms[i_seq].fetch_labels().resname.strip()\\n element = self.pdb_atoms[i_seq].element.strip()\\n if (element == \\\"C\\\") or ((element == \\\"O\\\") and (resname in WATER_RES_NAMES)):\\n map_value = fo_map.eight_point_interpolation(site_frac)\\n self._map_values[\\\"mFo\\\"][i_seq] = map_value\\n if (element == \\\"C\\\"):\\n self.carbon_fo_values.append(map_value)\\n del fo_map\",\n \"def check_collide(self):\\n for pizza in self.overlapping_sprites:\\n pizza.handle_collide()\",\n \"def reclassEcotopes(ecoMap, ecoDf, lookupDf, lookupColumn):\\n \\n assert 'ECO_CODE' in ecoDf.columns.values\\n assert 'ECO_CODE' in lookupDf.columns.values\\n assert lookupColumn in lookupDf.columns.values\\n \\n #-determine the lookuptable for the ecotope IDs [ecoID, lookupValue]\\n df = pd.merge(ecoDf, lookupDf, on = 'ECO_CODE')\\n columnData = df.loc[:,['ID', lookupColumn]].values\\n lutFile = 'lutReclass1%s.txt' % uuid.uuid4() \\n # needs a unique file name due to bug in pcr.lookupnominal\\n np.savetxt(lutFile, columnData, fmt = '%.0f')\\n \\n recoded = pcr.lookupnominal(lutFile, ecoMap)\\n os.remove(lutFile)\\n return recoded\",\n \"def init_from_others(self, a_to_b_mapping, c_iso_to_b_mapping):\\n assert c_iso_to_b_mapping.is_iso()\\n\\n # copy the _id_maps\\n self._id_maps = {}\\n for (mapping, in_something) in zip([a_to_b_mapping._id_maps[Mappings.IN_A],\\n c_iso_to_b_mapping._id_maps[Mappings.IN_A]],\\n [Mappings.IN_A, Mappings.IN_B]):\\n\\n self._id_maps[in_something] = {}\\n self._id_maps[in_something][Mappings.NODES] = mapping[Mappings.NODES].copy()\\n self._id_maps[in_something][Mappings.EDGES] = mapping[Mappings.EDGES].copy()\\n\\n # map from b elem to c\\n b_to_c = {}\\n b_to_c[Mappings.NODES] = {}\\n b_to_c[Mappings.EDGES] = {}\\n for (c_elem, b_elem) in c_iso_to_b_mapping._isos:\\n if self._is_node(c_elem):\\n assert self._is_node(b_elem)\\n b_to_c[Mappings.NODES][b_elem.id] = c_elem\\n else:\\n assert not self._is_node(b_elem)\\n b_to_c[Mappings.EDGES][b_elem.id] = c_elem\\n\\n # set just a - copy a\\n self._just_a = list(a_to_b_mapping._just_a)\\n\\n # set isos\\n self._isos = []\\n for (a_elem, b_elem) in a_to_b_mapping._isos:\\n if self._is_node(b_elem):\\n if (b_elem.id in b_to_c[Mappings.NODES]):\\n c_elem = b_to_c[Mappings.NODES][b_elem.id]\\n else:\\n if b_elem.id in b_to_c[Mappings.EDGES]:\\n c_elem = b_to_c[Mappings.EDGES][b_elem.id]\\n self._isos.append( (a_elem, c_elem) )\\n\\n # set just b\\n self._just_b = []\\n for b_elem in a_to_b_mapping._just_b:\\n if self._is_node(b_elem):\\n if b_elem.id in b_to_c[Mappings.NODES]:\\n c_elem = b_to_c[Mappings.NODES][b_elem.id]\\n else:\\n if b_elem.id in b_to_c[Mappings.EDGES]:\\n c_elem = b_to_c[Mappings.EDGES][b_elem.id]\\n\\n self._just_b.append( c_elem )\",\n \"def _configure_flowables(self, flowables):\\n if flowables is None:\\n flowables = DEFAULT_FLOWABLES\\n\\n # FlowablesDict-- mainly to upsample CAS numbers for matching\\n self._fm = FlowablesDict()\\n\\n self._fm.new_entry('carbon dioxide', '124-38-9')\\n self._fm.new_entry('Water', '7732-18-5')\\n # we store the child object and use it to signify biogenic CO2 to optionally quell\\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\\n\\n # now load + merge from file\\n self._fm.load(flowables)\\n\\n # now add all known \\\"biotic\\\" synonyms for CO2 to the biotic child\\n for k in self._fm.synonyms('124-38-9'):\\n if bool(biogenic.search(k)):\\n self._bio_co2.add_term(k)\\n self._fq_map = {fb: set() for fb in self._fm.objects}\",\n \"def __init__(self, c):\\n self.coords = c[:4]\\n self.center = c[4]\\n\\n # init width and height of block\\n widthAndHeight(self)\\n\\n self.x = randrange((pyxel.width - self.width)/4)\\n self.y = 0\\n self.vy = 32\\n self.falling = True\\n\\n # init random color\\n self.color = randrange(2, 15)\\n\\n # Add block to posMap\\n mapAdd(self, theFallen)\\n\\n self.frame = pyxel.frame_count\",\n \"def should_grow_on_food_collision(self):\\n return True\",\n \"def _update_conformers(self, cutoff=0.002):\\n logger.debug(\\\"Updating conformers based on occupancy\\\")\\n\\n # Check that all arrays match dimensions.\\n assert len(self._occupancies) == len(self._coor_set) == len(self._bs)\\n\\n # Filter all arrays & lists based on self._occupancies\\n # NB: _coor_set and _bs are lists (not arrays). We must compress, not slice.\\n filterarray = self._occupancies >= cutoff\\n self._occupancies = self._occupancies[filterarray]\\n self._coor_set = list(itertools.compress(self._coor_set, filterarray))\\n self._bs = list(itertools.compress(self._bs, filterarray))\\n\\n logger.debug(f\\\"Remaining valid conformations: {len(self._coor_set)}\\\")\",\n \"def requires_mapping(self):\",\n \"def _set_mapper(self, classification_dict):\\n d = {class_code: class_index for class_index, class_code in enumerate(classification_dict.keys())}\\n # Here we update the dict so that code 65 remains unchanged.\\n # Indeed, 65 is reserved for noise/artefacts points, that will be deleted by transform \\\"DropPointsByClass\\\".\\n d.update({65: 65})\\n self.mapper = np.vectorize(lambda class_code: d.get(class_code))\",\n \"def initMaps(self):\\r\\n assert isinstance(self.CLASSES, (list, tuple))\\r\\n assert self.CLASSES[0] == \\\"__background__\\\"\\r\\n cls = self.CLASSES\\r\\n self.name_to_id = dict(zip(cls, range(len(cls))))\\r\\n self.id_to_name = dict(zip(range(len(cls)), cls))\",\n \"def detect_collision(self, pos):\\n for rect in self.stock:\\n if rect.collidepoint((pos)):\\n return ['S0', 0]\\n for rect in self.waste:\\n if rect.collidepoint((pos)):\\n return ['W0', 0]\\n for i, rect in enumerate(self.foundations):\\n if rect.collidepoint((pos)):\\n return ['F'+str(i), 0]\\n for rect in self.tableaus:\\n if rect[0].collidepoint((pos)):\\n return rect[1]\\n\\n return [0,0]\",\n \"def try_put(self, object_to_put, pos_x, pos_y):\\n self.validate_position(pos_x, pos_y)\\n if self.map[pos_x][pos_y] is None:\\n self.map[pos_x][pos_y] = object_to_put\\n else:\\n return self.map[pos_x][pos_y]\",\n \"def handle_matching_collision(self, dmg, hp):\\n\\n # Delegate to the function in 'systems'.\\n systems.handle_damage_collision(dmg, hp)\\n\\n # Return the result ( we handled the collision. )\\n return physics.CollisionResult(True, True)\",\n \"def __init__(self, mappings):\\r\\n for key, value in mappings.iteritems():\\r\\n setattr(self, key, value)\",\n \"def initialize(cls):\\n if len(cls.mapping) == 0:\\n cls.mapping[\\\"noop\\\"] = cls(Transform.identity, Combiner.noop)\\n cls.mapping[\\\"sigmoid\\\"] = cls(Transform.sigmoid, Combiner.multiplies)\\n cls.mapping[\\\"log-sigmoid\\\"] = cls(Transform.log_sigmoid, Combiner.plus)\\n\\n for p in range(1, 5):\\n cls.mapping[\\\"l{}-hinge\\\".format(p)] = cls(\\n Transform.get_lp_hinge(p), Combiner.multiplies\\n )\\n cls.mapping[\\\"log-l{}-hinge\\\".format(p)] = cls(\\n Transform.get_log_lp_hinge(p), Combiner.plus\\n )\\n\\n # for backward compatibility\\n cls.mapping[True] = cls.mapping[\\\"l3-hinge\\\"]\\n cls.mapping[False] = cls.mapping[\\\"noop\\\"]\\n cls.mapping[None] = cls.mapping[\\\"noop\\\"]\",\n \"def _setup_collision_handlers(self):\\n self._world.add_collision_handler(\\\"player\\\", \\\"item\\\", on_begin=self._handle_player_collide_item)\\n self._world.add_collision_handler(\\\"player\\\", \\\"block\\\", on_begin=self._handle_player_collide_block,\\n on_separate=self._handle_player_separate_block)\\n self._world.add_collision_handler(\\\"player\\\", \\\"mob\\\", on_begin=self._handle_player_collide_mob)\\n self._world.add_collision_handler(\\\"mob\\\", \\\"block\\\", on_begin=self._handle_mob_collide_block)\\n self._world.add_collision_handler(\\\"mob\\\", \\\"mob\\\", on_begin=self._handle_mob_collide_mob)\\n self._world.add_collision_handler(\\\"mob\\\", \\\"item\\\", on_begin=self._handle_mob_collide_item)\",\n \"def _update_collidable_components(self):\\n\\n #First we must iterate through each collision shape component.\\n for cBody in self.get_all_components(\\\"CBODY\\\"):\\n\\n #Then for each collison shape, we must grab its position and\\n # update the dependent component of the collision shape.\\n\\n #The y position needs flipped because pymunk and sfml's y coordinates start\\n # on different sides (top-left is (0,0) in sfml, bottom-left is (0,0) in pymunk)\\n lPosition = [cBody._Get_Body().position[0], \\\\\\n config.WINDOW_HEIGHT - cBody._Get_Body().position[1]]\\n\\n dependentSprite = self.get_component(cBody._Get_Dependent_Component_ID())\\n\\n if (dependentSprite):\\n dependentSprite._Update_Position(lPosition, cBody._Get_Body().angle)\",\n \"def get_shapes(self):\\n colours = [[None for j in range(self.cellcounts[0])] for i in range(self.cellcounts[1])]\\n X = []\\n backmap = {}\\n rad = 3\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n chunk = self.img[y-rad:y+rad, x-rad:x+rad,:]\\n m = np.mean(np.mean(chunk, axis=0), axis=0).astype(np.uint16)\\n colours[i][j] = m\\n X.append(m)\\n backmap[k] = (i,j)\\n print(np.shape(X))\\n Z = linkage(X, 'ward')\\n Q = fcluster(Z, self.thresh, criterion='distance')\\n\\n closenesses = []\\n for k,cls in enumerate(Q):\\n i,j = backmap[k]\\n closenesses.append( np.sqrt(np.sum( (colours[i][j] - self.ideal_bg)**2) ) )\\n minidx = np.argmin(closenesses)\\n bgcls = Q[minidx]\\n\\n blibs = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (0,255,255), (255,0,255)]\\n img4 = self.img2.copy()\\n for k,((i,y),(j,x)) in enumerate(self.mids):\\n cls = Q[k]\\n if cls == bgcls:\\n continue\\n col = blibs[(cls-1)]\\n img4 = cv2.circle(img4, (x,y), 5, col, 2)\\n\\n write_img(\\\"./out/test_classes.png\\\", img4)\\n self.classimg = img4\\n\\n A = np.zeros(shape=self.cellcounts, dtype=np.uint8)\\n mx = np.max(Q)\\n for k,cls in enumerate(Q):\\n if cls == bgcls:\\n continue\\n\\n if cls == mx:\\n plotcls = bgcls\\n else:\\n plotcls = cls\\n i,j = backmap[k]\\n A[i][j] = plotcls\\n\\n self.res = A\",\n \"def _fit(self, clean, entity_map):\\n raise NotImplementedError\",\n \"def check_collision(self):\\n self.collided = False\\n\\n for point in self.collision_points:\\n\\n try:\\n if self.game_map.get_at((\\n int(point[0]), int(point[1])\\n )) == WHITE_COLOR:\\n self.collided = True\\n break\\n except:\\n self.collided = True\",\n \"def constrain(self, gamut_map, processed, to_process):\\n gamut_map[self._referent] = range_intersect(\\n gamut_map.get(self._referent, None),\\n self.gamut\\n )\\n if self._referent not in processed:\\n to_process.add(self._referent)\",\n \"def mapToAtlas(self, obj):\\n raise Exception(\\\"Must be reimplemented in subclass.\\\")\",\n \"def __init__(self, fvcom):\\n\\n # Prepare this object with all the objects we'll need later on (data, dims, time, grid, atts).\\n self._prep()\\n\\n self.obj_iter = lambda x: [a for a in dir(x) if not a.startswith('__')]\\n\\n grid_names = ('lon', 'lat', 'lonc', 'latc', 'nv',\\n 'h', 'h_center',\\n 'nbe', 'ntsn', 'nbsn', 'ntve', 'nbve',\\n 'art1', 'art2', 'a1u', 'a2u',\\n 'siglay', 'siglev')\\n time_names = ('time', 'Times', 'datetime', 'Itime', 'Itime2')\\n\\n for key in fvcom:\\n if key in grid_names:\\n setattr(self.grid, key, fvcom[key])\\n elif key in time_names:\\n setattr(self.time, key, fvcom[key])\\n else: # assume data.\\n setattr(self.data, key, fvcom[key])\\n # Make some dimensions\\n self.dims.three = 3\\n self.dims.four = 4\\n self.dims.maxnode = 11\\n self.dims.maxelem = 9\\n # This is a little repetitive (each dimension can be set multiple times), but it has simplicity to its\\n # advantage.\\n for obj in self.obj_iter(self.data):\\n if obj in ('ua', 'va'):\\n try:\\n self.dims.time, self.dims.nele = getattr(self.data, obj).shape\\n except ValueError:\\n # Assume we've got a single position.\\n self.dims.time = getattr(self.data, obj).shape[0]\\n self.dims.nele = 1\\n elif obj in ('temp', 'salinity'):\\n try:\\n self.dims.time, self.dims.siglay, self.dims.node = getattr(self.data, obj).shape\\n except ValueError:\\n # Assume we've got a single position\\n self.dims.time, self.dims.siglay = getattr(self.data, obj).shape[:2]\\n self.dims.node = 1\\n self.dims.siglev = self.dims.siglay + 1\\n elif obj in ['zeta']:\\n try:\\n self.dims.time, self.dims.node = getattr(self.data, obj).shape\\n except ValueError:\\n # Assume we've got a single position\\n self.dims.time = getattr(self.data, obj).shape[0]\\n self.dims.node = 1\\n elif obj in ('Times'):\\n self.dims.time, self.dims.DateStrLen = getattr(self.time, obj).shape\\n elif obj in ('time', 'Itime', 'Itime2', 'datetime'):\\n self.dims.time = getattr(self.time, obj).shape\",\n \"def __subclasshook__(cls, other_class: type):\\n # issubclass calls result in infinite recursion\\n # guard against infinite recursion with direct calls to base subclasshooks\\n # https://docs.python.org/3/library/collections.abc.html#collections-abstract-base-classes\\n return (\\n cls is HashableMapping\\n and True == CA.Hashable.__subclasshook__(other_class) # type: ignore\\n and True == CA.Collection.__subclasshook__(other_class) # type: ignore\\n and True == check_methods(other_class, '__getitem__', '__eq__', '__ne__')\\n or NotImplemented\\n )\",\n \"def _ignore_collision(self):\\n # The legacy version only ignores collision of child links of active joints.\\n for link in self.cabinet.get_links():\\n for s in link.get_collision_shapes():\\n g0, g1, g2, g3 = s.get_collision_groups()\\n s.set_collision_groups(g0, g1, g2 | 1 << 31, g3)\",\n \"def check_collide(self):\\r\\n for raindrop in self.overlapping_sprites:\\r\\n raindrop.handle_collide()\",\n \"def __init__(self, mapping=None, **kwargs):\\n\\n masked_kwargs = {}\\n if len(kwargs) > 0:\\n masked_kwargs = self._mask_dict(kwargs)\\n\\n if isinstance(mapping, MaskedDict):\\n super().__init__(self._unify(mapping, masked_kwargs))\\n\\n elif isinstance(mapping, (dict, Headers)):\\n temp = {}\\n for key, value in mapping.items():\\n if masking_services.should_mask(key) is True:\\n temp[key] = self.MASK\\n else:\\n temp[key] = self._mask(value)\\n\\n super().__init__(self._unify(temp, masked_kwargs))\\n\\n elif isinstance(mapping, LIST_TYPES):\\n temp = []\\n for key, value in mapping:\\n if masking_services.should_mask(key) is True:\\n temp.append((key, self._mask(value)))\\n else:\\n temp.append((key, value))\\n\\n super().__init__(temp, **masked_kwargs)\\n\\n else:\\n super().__init__(masked_kwargs)\",\n \"def remap(self,newMasters,modMap,objMaps=[]):\\n #--Masters\\n self.tes3.masters = newMasters\\n #--File mapping\\n modMapKeys = modMap.keys()\\n #--Remap iObjs\\n cells_id = self.cells_id\\n reObjNum = re.compile('[0-9A-Z]{8}$')\\n for (iMod,objMap) in objMaps:\\n cellIds = objMap.keys()\\n for cellId in cellIds:\\n cellObjMap = objMap[cellId]\\n #--Save \\n cell = cells_id.get(cellId)\\n if not cell: continue\\n #--Objects\\n objects = cell.getObjects()\\n for object in objects.list():\\n #--Different mod?\\n if object[0] != iMod:\\n pass\\n #--Cell deleted?\\n elif cellObjMap == -1:\\n objects.remove(object)\\n #--Remapped object?\\n elif object[1] in cellObjMap:\\n (newIObj,objId) = cellObjMap[object[1]]\\n objIdBase = reObjNum.sub('',objId) #--Strip '00001234' id num from object\\n #--Mismatched object id?\\n if objId != objIdBase:\\n #print 'Mismatch:',object[:3]\\n pass \\n #--Deleted object?\\n elif newIObj == -1:\\n #print 'Deleted',object[:3]\\n objects.remove(object)\\n #--Remapped object?\\n else:\\n #print 'Remapped',object[:3],'to',newIObj\\n newObject = self.remapObject(object,iMod,newIObj)\\n objects.replace(object,newObject)\\n self.updateScptRefs()\\n #--Remap iMods\\n if not modMapKeys: return\\n for cell in self.cells:\\n objects = cell.getObjects()\\n for object in objects.list():\\n #--Remap IMod\\n iMod = object[0]\\n #--No change?\\n if iMod not in modMapKeys: \\n pass\\n #--Object deleted?\\n elif modMap[iMod] == -1:\\n objects.remove(object)\\n #--Object not deleted?\\n else:\\n newObject = self.remapObject(object,modMap[iMod])\\n objects.replace(object,newObject)\\n self.updateScptRefs()\",\n \"def __init__(self, posn, w, h, c):\\r\\n self.corner = posn\\r\\n self.width = w\\r\\n self.height = h\\r\\n self.collision = c\",\n \"def box_cox_map(self, col_need, gamma=1.0, col_replace=True):\\r\\n df_need = self.df[col_need]\\r\\n if col_replace:\\r\\n self.df[col_need] = df_need.applymap(lambda x: boxcox1p(x, gamma))\\r\\n else:\\r\\n col_need_extend = [col + \\\"_boxCox\\\" for col in col_need]\\r\\n self.df[col_need_extend] = df_need.applymap(lambda x: boxcox1p(x, gamma))\",\n \"def __init__(self, word_fd, quadgram_fd, ii, iii, ixi, ixxi, iixi, ixii):\\n AbstractCollocationFinder.__init__(self, word_fd, quadgram_fd)\\n self.iii = iii\\n self.ii = ii\\n self.ixi = ixi\\n self.ixxi = ixxi\\n self.iixi = iixi\\n self.ixii = ixii\",\n \"def _strict_match(self, struct1, struct2, fu, s1_supercell=True,\\n use_rms=False, break_on_match=False):\\n if fu < 1:\\n raise ValueError(\\\"fu cannot be less than 1\\\")\\n\\n mask, s1_t_inds, s2_t_ind = self._get_mask(struct1, struct2,\\n fu, s1_supercell)\\n\\n if mask.shape[0] > mask.shape[1]:\\n raise ValueError('after supercell creation, struct1 must '\\n 'have more sites than struct2')\\n\\n # check that a valid mapping exists\\n if (not self._subset) and mask.shape[1] != mask.shape[0]:\\n return None\\n\\n if LinearAssignment(mask).min_cost > 0:\\n return None\\n\\n best_match = None\\n # loop over all lattices\\n for s1fc, s2fc, avg_l, sc_m in \\\\\\n self._get_supercells(struct1, struct2, fu, s1_supercell):\\n # compute fractional tolerance\\n normalization = (len(s1fc) / avg_l.volume) ** (1/3)\\n inv_abc = np.array(avg_l.reciprocal_lattice.abc)\\n frac_tol = inv_abc * self.stol / (np.pi * normalization)\\n # loop over all translations\\n for s1i in s1_t_inds:\\n t = s1fc[s1i] - s2fc[s2_t_ind]\\n t_s2fc = s2fc + t\\n if self._cmp_fstruct(s1fc, t_s2fc, frac_tol, mask):\\n inv_lll_abc = np.array(avg_l.get_lll_reduced_lattice().reciprocal_lattice.abc)\\n lll_frac_tol = inv_lll_abc * self.stol / (np.pi * normalization)\\n dist, t_adj, mapping = self._cart_dists(\\n s1fc, t_s2fc, avg_l, mask, normalization, lll_frac_tol)\\n if use_rms:\\n val = np.linalg.norm(dist) / len(dist) ** 0.5\\n else:\\n val = max(dist)\\n if best_match is None or val < best_match[0]:\\n total_t = t + t_adj\\n total_t -= np.round(total_t)\\n best_match = val, dist, sc_m, total_t, mapping\\n if (break_on_match or val < 1e-5) and val < self.stol:\\n return best_match\\n\\n if best_match and best_match[0] < self.stol:\\n return best_match\",\n \"def collision_info(self, point):\\n pass\",\n \"def collide(self, obj):\\n if obj.type == 'food':\\n if self.carry_food == False:\\n self.r += 1\\n self.color = (0, 255, 0, 128)\\n self.carry_food = True\\n if self.mass > obj.mass:\\n pass\\n elif self.mass*5 < obj.mass:\\n self.orientation += math.pi\\n if (obj.type == 'wall') and (obj.colony):\\n if self.carry_food == True:\\n self.r += 100\\n self.carry_food = False\\n self.color = (128, 128, 128, 128)\\n else:\\n pass\\n # self.orientation += rnd.choice([math.pi / 4, - math.pi / 4])\\n # else:\\n # print('collision')\\n # self.orientation += math.pi\",\n \"def collision(self, model, new_location):\\n\\n within_bounds = all(model.boundaries[0] <= new_location) and all(new_location <= model.boundaries[1])\\n\\n if not within_bounds:\\n\\n collide = True\\n\\n elif self.neighbourhood(model, new_location):\\n\\n collide = True\\n\\n else:\\n\\n collide = False\\n\\n return collide\",\n \"def make_sector_map(self, data):\\n\\n def format_county_fips(cf):\\n\\n cf = str(cf)\\n\\n if len(cf)<=4:\\n\\n cf = '0'+cf\\n\\n return cf\\n\\n data['COUNTY_FIPS'] = data.COUNTY_FIPS.apply(\\n lambda x: format_county_fips(x)\\n )\\n\\n # match on geo_id\\n map_data = self.cshp.set_index('GEOID').join(\\n data.set_index('COUNTY_FIPS').MMBtu\\n )\\n\\n ## Need to specify colors or will geopandas automatcially assign?\",\n \"def __init__(self, fn):\\n\\n #for the scripting engine\\n script_engine.ScriptableObject.__init__(self)\\n\\n #store variables we'll need later\\n self.fn = fn\\n\\n #get a script engine (singleton)\\n self.scriptEngine = script_engine.ScriptEngine()\\n\\n #parse the XML file\\n root = data.getTreeRoot(fn)\\n self.music = os.path.join(settings.path, \\\"data\\\", data.getAttr(root, \\\"music\\\", data.D_STRING))\\n\\n #open the actual map data file to create the map tile data\\n mapPath = os.path.join(settings.path, \\\"data\\\", data.getAttr(root, \\\"file\\\", data.D_STRING))\\n self.openMap(mapPath)\\n\\n #create the tileset\\n tilesetPath = os.path.join(settings.path, \\\"data\\\", data.getAttr(root, \\\"tileset\\\", data.D_STRING))\\n self.tileset = tileset.Tileset(tilesetPath)\\n\\n #set the border tiles\\n self.borderTiles = {}\\n borderNode = data.getChild(root, \\\"border\\\")\\n\\n #set each border node with the correct tile indexes, subtracting 1 because the tileset starts at 1 not 0\\n self.borderTiles[BD_NW] = data.getAttr(borderNode, \\\"nw\\\", data.D_INT)-1\\n self.borderTiles[BD_NE] = data.getAttr(borderNode, \\\"ne\\\", data.D_INT)-1\\n self.borderTiles[BD_SW] = data.getAttr(borderNode, \\\"sw\\\", data.D_INT)-1\\n self.borderTiles[BD_SE] = data.getAttr(borderNode, \\\"se\\\", data.D_INT)-1\\n \\n #create any connections from the map\\n #connected maps will not be loaded until the map becomes the main game map\\n #connections are stored as {direction: (filename, offset)}\\n self.connections = {}\\n self.connectedMaps = {}\\n for c in data.getChildren(root, \\\"connection\\\"):\\n side = data.getAttr(c, \\\"side\\\", data.D_STRING)\\n fp = os.path.join(settings.path, \\\"data\\\", data.getAttr(c, \\\"map\\\", data.D_STRING))\\n offset = data.getAttr(c, \\\"offset\\\", data.D_INT)\\n \\n if side == \\\"left\\\":\\n self.connections[sprite.DIR_LEFT] = (fp, offset)\\n elif side == \\\"right\\\":\\n self.connections[sprite.DIR_RIGHT] = (fp, offset)\\n elif side == \\\"up\\\":\\n self.connections[sprite.DIR_UP] = (fp, offset)\\n elif side == \\\"down\\\":\\n self.connections[sprite.DIR_DOWN] = (fp, offset)\\n\\n #create any NPCs, adding them to the sprite dictionary\\n self.sprites = {}\\n for n in data.getChildren(root, \\\"npc\\\"):\\n spr = npc.NPC(n, self)\\n self.sprites[spr.id] = spr\\n\\n #create a dictionary to hold positions reserved by moving sprites\\n self.reservedPositions = {}\\n\\n #create script and warp events, adding them to the events dictionary\\n #if a load script is defined, create it\\n self.events = {}\\n loadScript = None\\n for s in data.getChildren(root, \\\"script\\\"):\\n trigger = data.getAttr(s, \\\"trigger\\\", data.D_STRING)\\n if trigger == \\\"load\\\":\\n loadScript = script_engine.Script(s) \\n else:\\n position = tuple(data.getAttr(s, \\\"position\\\", data.D_INT2LIST)) \\n self.events[position] = events.ScriptEvent(s, self)\\n \\n for w in root.findall(\\\"warp\\\"):\\n position = tuple(data.getAttr(w, \\\"position\\\", data.D_INT2LIST))\\n self.events[position] = events.Warp(w, self)\\n\\n #if there is a load script, run it\\n if loadScript is not None:\\n self.scriptEngine.run(loadScript, self)\",\n \"def _collide(self):\\n\\n collisions = self._get_collisions()\\n for collision in collisions:\\n self._update_excitation(collision)\\n atom1 = self.atoms[collision[0]]\\n atom2 = self.atoms[collision[1]]\\n\\n r = atom1.pos-atom2.pos\\n r_mag = np.linalg.norm(r)\\n r_hat = r/r_mag\\n\\n v_1_r = np.dot(atom1.vel, r_hat)\\n v_2_r = np.dot(atom2.vel, r_hat)\\n\\n v_1_r_f = (atom1.mass-atom2.mass)*v_1_r/(atom1.mass + atom2.mass)\\\\\\n + 2*atom2.mass*v_2_r/(atom1.mass + atom2.mass)\\n v_2_r_f = (atom2.mass-atom1.mass)*v_2_r/(atom1.mass + atom2.mass)\\\\\\n + 2*atom1.mass*v_1_r/(atom1.mass + atom2.mass)\\n\\n delta_v_1 = (v_1_r_f - v_1_r)*r_hat\\n delta_v_2 = (v_2_r_f - v_2_r)*r_hat\\n\\n self.atoms[collision[0]].vel += delta_v_1\\n self.atoms[collision[1]].vel += delta_v_2\",\n \"def read_cbf_file(inputfilename):\\n \\n \\n with open(inputfilename, 'rb') as fid:\\n BD = np.fromfile(fid, np.float64)\\n \\n # https://www.mathworks.com/help/matlab/ref/fwrite.html\\n # https://www.mathworks.com/help/matlab/numeric-types.html\\n \\n k=0;\\n # Static data (100 places)\\n SD=BD[k:k+100]\\n k=k+100\\n # Priors (50 places)\\n PR=BD[k:k+50];\\n k=k+50;\\n # Priorunc (50 places)\\n PRU=BD[k:k+50]\\n k=k+50 \\n \\n # O. Priors (50 places)\\n OPR=BD[k:k+50]\\n k=k+50\\n # O. Priorunc (50 places)\\n OPRU=BD[k:k+50]\\n k=k+50\\n \\n CBF = {}\\n CBF['PARPRIORS'] = np.expand_dims(PR,axis=1)\\n CBF['PARPRIORUNC'] = np.expand_dims(PRU,axis=1)\\n CBF=read_other_obs_constraints(CBF,OPR,OPRU)\\n \\n CBF['ID'] = SD[0] # ID (not used)\\n CBF['LAT'] = SD[1] # Latitude\\n CBF['nodays'] = int(SD[2]) # Number of days\\n CBF['nomet'] = int(SD[3])\\n CBF['noobs'] =int(SD[4])\\n CBF['EDC'] = SD[5]\\n CBF['EDCDIAG'] = SD[6]\\n# CBF = {'PARPRIORS':np.expand_dims(PR,axis=1), \\n# 'PARPRIORUNC':np.expand_dims(PRU,axis=1), \\n# 'OTHERPRIORS':np.expand_dims(OPR,axis=1), #\\n# 'OTHERPRIORSUNC':np.expand_dims(OPRU,axis=1),\\n# 'ID':SD[0], # ID (not used)\\n# 'LAT':SD[1], # Latitude\\n# 'nodays':int(SD[2]), # Number of days\\n# 'nomet':int(SD[3]), \\n# 'noobs':int(SD[4]),\\n# 'EDC':SD[5],\\n# 'EDCDIAG':SD[6],\\n# 'gppabs':SD[7],\\n# 'rc_random_search':SD[10]==1,\\n# 'nbe_annual_unc':SD[13],\\n# 'etiav':SD[14],\\n# 'nbe_seasonal_unc':SD[15]}\\n \\n #MCMC start searching EDCs from anywhere (1) or from prescribed starting\\n #point(0). this is outdated - consider deleting\\n CBF['rc_random_search'] = SD[10]==1\\n \\n #NEE IAV options\\n CBF=read_obs_uncertainty_fields(CBF,SD,OPRU)\\n \\n \\n TEMPDATA=BD[k:k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']].reshape(CBF['nodays'],\\n (CBF['nomet']+CBF['noobs']))\\n #All met data\\n CBF['MET'] = TEMPDATA[0:CBF['nodays'],0:CBF['nomet']] # Add in new meteorology here\\n# CBF['OBS'] = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\\n CBFOBS = TEMPDATA[0:CBF['nodays'],CBF['nomet']:]\\n CBF=define_cbf_obs_fields(CBF,CBFOBS)\\n \\n #Removing redundant fields\\n# CBF=rmfield(CBF,'noobs');\\n# # CBF=rmfield(CBF,'nomet');\\n# # CBF=rmfield(CBF,'nodays');\\n \\n \\n # Read prescribed mean meteorology\\n \\n if len(BD) - (k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']) == CBF['nomet'] + CBF['noobs']:\\n \\n kmmet= k+(CBF['nomet']+CBF['noobs'])*CBF['nodays']\\n CBF['mmet'] = BD[kmmet:kmmet+CBF['nomet']]\\n \\n \\n #Retaining \\\"OTHERPRIORS\\\" for now\\n CBF['RAW'] = {}\\n CBF['RAW']['OTHERPRIORS']=OPR;\\n CBF['RAW']['OTHERPRIORSUNC']=OPRU;\\n CBF['RAW']['info']='Raw inputs/outputs as stored in CBF binary structure';\\n CBF['RAW']['details']='For completeness & development purpose only; When re-writing CBF to file, these are over-written by CBF.OBS, etc.';\\n\\n \\n \\n \\n \\n return CBF\\n #disp(sprintf('CHECK: .cbf file \\\"%s\\\" successfully read into matlab.',filename)) \",\n \"def setCollidemask(self):\\n friends = self.createFriendlyEmpireList()\\n mask = 0\\n for id in friends:\\n id = int(id)\\n mask = mask + (1<<id)\\n self.collidemask = mask\",\n \"def map_face(self):\\n #Array Order: U0,D1,R2,L3,F4,B5,\\n \\n cube_list = []\\n cube_list = self.cube.definition()\\n \\n for index, cubit in enumerate(self.faces['Up']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\\n for index, cubit in enumerate(self.faces['Ri']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\\n for index, cubit in enumerate(self.faces['Ft']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\\n for index, cubit in enumerate(self.faces['Dn']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\\n for index, cubit in enumerate(self.faces['Le']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\\n for index, cubit in enumerate(self.faces['Bk']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])\",\n \"def __init__(self, vcffiles):\\n self.vcffilenames = vcffiles\\n self.snpsites = {}\\n self.snp_positions = {}\",\n \"def classify_defect_clusters_modifier(frame, data):\\n\\n if data.particles.count == 0:\\n # No particles there to classify, create empty properties anyway\\n data.particles_.create_property('Si_V', dtype=int, components=1)\\n data.particles_.create_property('Si_I', dtype=int, components=1)\\n data.particles_.create_property('Si_C', dtype=int, components=1)\\n data.particles_.create_property('C_V', dtype=int, components=1)\\n data.particles_.create_property('C_I', dtype=int, components=1)\\n data.particles_.create_property('C_Si', dtype=int, components=1)\\n return\\n\\n # TODO Create numpy arrays containing the number of Si vacancies,\\n # interstitials, etc for each particle site in `data.particles`. These\\n # next lines are just placeholders!\\n si_vacancy = data.particles[\\\"vacancy_mask\\\"][...] * data.particles[\\\"Is Si Site\\\"][...]\\n si_interstitial = (data.particles[\\\"Is Si Site\\\"][...] & (data.particles[\\\"Si Occupancy\\\"][...] > 1)) * (\\n data.particles[\\\"Si Occupancy\\\"][...] - 1) + (\\n (data.particles[\\\"Is C Site\\\"][...]) * data.particles[\\\"Si Occupancy\\\"][...]) - (\\n data.particles[\\\"Is C Site\\\"][...] & data.particles[\\\"antisite_mask\\\"][...])\\n si_antisite = data.particles[\\\"antisite_mask\\\"][...] * data.particles[\\\"Is Si Site\\\"][...]\\n c_vacancy = data.particles[\\\"vacancy_mask\\\"][...] * data.particles[\\\"Is C Site\\\"][...]\\n c_interstitial = (data.particles[\\\"Is C Site\\\"][...] & (data.particles[\\\"C Occupancy\\\"][...] > 1)) * (\\n data.particles[\\\"C Occupancy\\\"][...] - 1) + (\\n (data.particles[\\\"Is Si Site\\\"][...]) * data.particles[\\\"C Occupancy\\\"][...]) - (\\n data.particles[\\\"Is Si Site\\\"][...] & data.particles[\\\"antisite_mask\\\"][...])\\n c_antisite = data.particles[\\\"antisite_mask\\\"][...] * data.particles[\\\"Is C Site\\\"][...]\\n\\n\\n data.particles_.create_property('Si_V', data=si_vacancy.astype(int))\\n data.particles_.create_property('Si_I', data=si_interstitial.astype(int))\\n data.particles_.create_property('Si_C', data=si_antisite.astype(int))\\n data.particles_.create_property('C_V', data=c_vacancy.astype(int))\\n data.particles_.create_property('C_I', data=c_interstitial.astype(int))\\n data.particles_.create_property('C_Si', data=c_antisite.astype(int))\",\n \"def __init___0(self, map):\\n super(LongObjectHashMap, self).__init__()\\n self.__init__()\\n putAll(map)\",\n \"def __init__(self):\\n self._map = {}\",\n \"def __init__(self, tileset, letter_mapping, space_width=None, transparent_color=0):\\n\\t\\tsuper().__init__(tileset, letter_mapping)\\n\\t\\tself._bound_rects = {}\\n\\t\\twith pygame.PixelArray(self._tileset.get_texture()) as pixels:\\n\\t\\t\\tfor letter in self._letter_mapping.keys():\\n\\t\\t\\t\\tletter_image = self._tileset.get_tile(self._letter_mapping[letter])\\n\\t\\t\\t\\tletter_rect = letter_image.get_rect()\\n\\t\\t\\t\\tself._bound_rects[letter] = utils.graphics.get_bounding_rect(letter_rect, lambda p: (pixels[p.x, p.y] == transparent_color), space_width=space_width)\",\n \"def __init__(self, lower_left_corner, upper_right_corner, projection='merc'):\\n self.basemap = MLMap.__create_basemap(lower_left_corner[0], lower_left_corner[1], upper_right_corner[0],\\n upper_right_corner[1], projection=projection)\\n self.shapes = pd.DataFrame()\\n self.shapes_to_draw = []\\n llc = self.basemap(lower_left_corner[0], lower_left_corner[1])\\n urc = self.basemap(upper_right_corner[0], upper_right_corner[1])\\n\\n #self.bbox = Bbox([llc, urc])\\n self.bbox = (lower_left_corner[0], lower_left_corner[1], upper_right_corner[0], upper_right_corner[1])\",\n \"def __init__(self, mappings):\\n self.mappings = mappings\",\n \"def __init__(self, mapping_filepath=None, calibration_filepath=None,\\n badchannels_filepath=None, runid=None):\\n # Mapping processing (file or cdb):\\n if mapping_filepath is not None:\\n with open(mapping_filepath, \\\"r\\\") as f:\\n self.mapping = self.ParseMapping(f)\\n elif runid is not None and CDB_AVAIL:\\n # Perform CDB operations to retrive mapping..\\n cdb_mapping = Cabling().get_cabling_for_run('Trackers', runid)\\n self.mapping = self.ParseMapping(cdb_mapping.split('\\\\n'))\\n else:\\n raise ValueError(\\\"Unable to load mapping, no methods available\\\")\\n\\n # Mapping processing (file or cdb):\\n if calibration_filepath is not None:\\n with open(calibration_filepath, \\\"r\\\") as f:\\n self.calibration = self.ParseCalibration(f.read())\\n elif runid is not None and CDB_AVAIL:\\n # Perform CDB operations to retrive mapping..\\n cdb_calib = Calibration().get_calibration_for_run('Trackers', \\n runid, 'trackers')\\n print cdb_calib\\n self.calibration = self.ParseCalibration(cdb_calib)\\n else:\\n raise ValueError(\\\"Unable to load calibration, no methods available\\\")\\n\\n #self.mapping = self.LoadMapping(mapping_filepath)\\n #self.calibration = self.LoadCalibration(calibration_filepath)\\n\\n if badchannels_filepath is not None:\\n self.badfechannels = self.LoadBadChannelUIDs(badchannels_filepath)\\n else:\\n self.badfechannels = []\\n\\n # Lookup object, for finding things.\\n self.lookup = self.GenerateLookup(self.mapping, self.calibration, self.badfechannels)\\n\\n # Missing channels from a given plane\\n self.badplanelookup = self.GeneratePlaneBadLookup(self.lookup)\",\n \"def __init__(self, ff, definition, userff, usernames=None):\\n self.map = {}\\n self.name = ff\\n defpath = \\\"\\\"\\n\\n if userff is None:\\n defpath = getFFfile(ff)\\n if defpath == \\\"\\\":\\n raise ValueError(\\\"Unable to find forcefield parameter file %s!\\\" % sys.path)\\n\\n file = open(defpath, 'rU')\\n\\n else:\\n file = userff\\n\\n lines = file.readlines()\\n for line in lines:\\n if not line.startswith(\\\"#\\\"):\\n fields = line.split()\\n if fields == []: continue\\n try:\\n resname = fields[0]\\n atomname = fields[1]\\n charge = float(fields[2])\\n radius = float(fields[3])\\n except ValueError:\\n txt = \\\"Unable to recognize user-defined forcefield file\\\"\\n if defpath != \\\"\\\":\\n txt += \\\" %s!\\\" % defpath\\n else:\\n txt += \\\"!\\\"\\n txt += \\\" Please use a valid parameter file.\\\"\\n raise ValueError(txt)\\n\\n try:\\n group = fields[4]\\n atom = ForcefieldAtom(atomname, charge, radius, resname, group)\\n except:\\n atom = ForcefieldAtom(atomname, charge, radius, resname)\\n\\n myResidue = self.getResidue(resname)\\n if myResidue is None:\\n myResidue = ForcefieldResidue(resname)\\n self.map[resname] = myResidue\\n myResidue.addAtom(atom)\\n\\n file.close()\\n\\n # Now parse the XML file, associating with FF objects -\\n # This is not necessary (if canonical names match ff names)\\n\\n defpath = getNamesFile(ff)\\n if defpath != \\\"\\\":\\n\\n handler = ForcefieldHandler(self.map, definition.map)\\n sax.make_parser()\\n\\n if usernames is not None:\\n namesfile = usernames\\n sax.parseString(namesfile.read(), handler)\\n else:\\n namesfile = open(defpath)\\n sax.parseString(namesfile.read(), handler)\\n namesfile.close()\\n\\n # CGI based .names file handling\\n else:\\n handler = ForcefieldHandler(self.map, definition.map)\\n sax.make_parser()\\n\\n if usernames is not None:\\n namesfile = usernames\\n sax.parseString(namesfile.getvalue(), handler)\\n else:\\n raise ValueError(\\\"Please provide a valid .names file!\\\")\\n namesfile.close()\",\n \"def test_conceptmap_6(base_settings):\\n filename = base_settings[\\\"unittest_data_dir\\\"] / \\\"cm-contact-point-use-v2.json\\\"\\n inst = conceptmap.ConceptMap.parse_file(\\n filename, content_type=\\\"application/json\\\", encoding=\\\"utf-8\\\"\\n )\\n assert \\\"ConceptMap\\\" == inst.resource_type\\n\\n impl_conceptmap_6(inst)\\n\\n # testing reverse by generating data from itself and create again.\\n data = inst.dict()\\n assert \\\"ConceptMap\\\" == data[\\\"resourceType\\\"]\\n\\n inst2 = conceptmap.ConceptMap(**data)\\n impl_conceptmap_6(inst2)\",\n \"def from_mapping(cls, mapping):\\n raise NotImplementedError('Subclasses of MapInitializable must implement from_mapping.')\",\n \"def process_class(self, parent, cls):\\n if cls.typemap.flat_name in self.class_map:\\n raise RuntimeError(\\\"process_class: class {} already exists in class_map\\\"\\n .format(cls.typemap.flat_name))\\n self.class_map[cls.typemap.flat_name] = cls\\n for var in cls.variables:\\n self.add_var_getter_setter(parent, cls, var)\\n cls.functions = self.define_function_suffix(cls.functions)\",\n \"def __circle_collision(self, circle):\\n raise Exception('--- This methods have not been implemented yet! Use circle_collider instead ---')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5515978","0.53430635","0.52271914","0.522315","0.5207508","0.519834","0.5172758","0.5147812","0.5145852","0.51225555","0.5114735","0.50724304","0.50228596","0.50203246","0.49639764","0.49526194","0.4949708","0.4940785","0.49291757","0.49172798","0.49058458","0.4897888","0.48855814","0.48768264","0.4864428","0.48502633","0.48249426","0.48182994","0.4804644","0.48045143","0.47801688","0.47782722","0.47777024","0.4767871","0.4763715","0.47587383","0.47530723","0.47439238","0.47422954","0.47267964","0.47267964","0.4723276","0.47218397","0.47073862","0.47026408","0.470226","0.46942756","0.46874663","0.46858197","0.46832135","0.4680241","0.4677669","0.4654831","0.4646262","0.46403694","0.4632295","0.46202978","0.4617836","0.46044743","0.46022782","0.46016476","0.45998123","0.45983458","0.45876184","0.45870328","0.45811445","0.45778966","0.45624867","0.45611835","0.45524386","0.45481065","0.45416248","0.45258176","0.45250815","0.45231616","0.45223185","0.45210096","0.4519205","0.45186624","0.45110184","0.45089728","0.4508167","0.45012054","0.44986123","0.44960204","0.44953912","0.44923568","0.44916716","0.44897673","0.44853786","0.4484834","0.44813824","0.44686326","0.4461513","0.44597298","0.4451591","0.44506124","0.44499603","0.4435414","0.44312897"],"string":"[\n \"0.5515978\",\n \"0.53430635\",\n \"0.52271914\",\n \"0.522315\",\n \"0.5207508\",\n \"0.519834\",\n \"0.5172758\",\n \"0.5147812\",\n \"0.5145852\",\n \"0.51225555\",\n \"0.5114735\",\n \"0.50724304\",\n \"0.50228596\",\n \"0.50203246\",\n \"0.49639764\",\n \"0.49526194\",\n \"0.4949708\",\n \"0.4940785\",\n \"0.49291757\",\n \"0.49172798\",\n \"0.49058458\",\n \"0.4897888\",\n \"0.48855814\",\n \"0.48768264\",\n \"0.4864428\",\n \"0.48502633\",\n \"0.48249426\",\n \"0.48182994\",\n \"0.4804644\",\n \"0.48045143\",\n \"0.47801688\",\n \"0.47782722\",\n \"0.47777024\",\n \"0.4767871\",\n \"0.4763715\",\n \"0.47587383\",\n \"0.47530723\",\n \"0.47439238\",\n \"0.47422954\",\n \"0.47267964\",\n \"0.47267964\",\n \"0.4723276\",\n \"0.47218397\",\n \"0.47073862\",\n \"0.47026408\",\n \"0.470226\",\n \"0.46942756\",\n \"0.46874663\",\n \"0.46858197\",\n \"0.46832135\",\n \"0.4680241\",\n \"0.4677669\",\n \"0.4654831\",\n \"0.4646262\",\n \"0.46403694\",\n \"0.4632295\",\n \"0.46202978\",\n \"0.4617836\",\n \"0.46044743\",\n \"0.46022782\",\n \"0.46016476\",\n \"0.45998123\",\n \"0.45983458\",\n \"0.45876184\",\n \"0.45870328\",\n \"0.45811445\",\n \"0.45778966\",\n \"0.45624867\",\n \"0.45611835\",\n \"0.45524386\",\n \"0.45481065\",\n \"0.45416248\",\n \"0.45258176\",\n \"0.45250815\",\n \"0.45231616\",\n \"0.45223185\",\n \"0.45210096\",\n \"0.4519205\",\n \"0.45186624\",\n \"0.45110184\",\n \"0.45089728\",\n \"0.4508167\",\n \"0.45012054\",\n \"0.44986123\",\n \"0.44960204\",\n \"0.44953912\",\n \"0.44923568\",\n \"0.44916716\",\n \"0.44897673\",\n \"0.44853786\",\n \"0.4484834\",\n \"0.44813824\",\n \"0.44686326\",\n \"0.4461513\",\n \"0.44597298\",\n \"0.4451591\",\n \"0.44506124\",\n \"0.44499603\",\n \"0.4435414\",\n \"0.44312897\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.46996704"},"document_rank":{"kind":"string","value":"46"}}},{"rowIdx":17094,"cells":{"query":{"kind":"string","value":"Adds ability to filter by origin note this is exclusive to the ability to filter by quantity"},"document":{"kind":"string","value":"def flowables(self, search=None, origin=None, new=False, **kwargs):\n if origin is None:\n _iter = super(LciaEngine, self).flowables(search=search, **kwargs)\n else:\n if search is None:\n _iter = self._fb_by_origin[origin]\n else:\n _iter = (str(x) for x in self._fm.objects_with_string(search) if x in self._fb_by_origin[origin])\n\n for k in _iter:\n if new:\n if k in self._fb_by_origin[None]:\n continue\n yield k"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_restriction_filters(self):\n self.restriction_filters[\"pk__exact\"] = self.request.user.pk","def filter(self, *args, **kwargs):","def _custom_filter(self, query):\r\n return query","def filter_disputes_notes_grid(self, column_name, filter_item):\n self.grid_filter_with_textbox(self.disputes_notes_grid_div_id, column_name, filter_item, 6)","def filter(self):\n _filter = self.ask_filter.text()\n if _filter:\n self.parent().artists = dmla.list_artists(_filter)\n else:\n self.parent().artists = self.parent().all_artists\n self.parent().artist_filter = _filter\n self.parent().do_select()","def filter(self, observable):","def filterRansac():\n pass","def mine(self, request, *args, **kwargs):\n qs = self.queryset\n if request.user.is_anonymous():\n qs = self.queryset.none()\n elif not self.is_admin(request.user):\n perms = OperatorPermission.objects.filter(user=request.user)\n if perms:\n query = Q()\n for perm in perms:\n query |= Q(carrier=perm.carrier, region=perm.region)\n qs = self.queryset.filter(query)\n else:\n qs = self.queryset.none()\n self.object_list = self.filter_queryset(qs)\n serializer = self.get_serializer(self.object_list, many=True)\n return Response(serializer.data)","def manual(self):\n\n\t\tfilter = [\"January\", \"February\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\", \"World War II\"],\n\n\t\tself.index[\"authorities\"] = [auth for auth in self.index[\"authorities\"] if auth not in filter]\n\n\t\tfor item in self.index[\"items\"]:\n\t\t\tself.index[\"items\"][item] = [auth for auth in self.index[\"items\"][item] if auth in self.index[\"authorities\"]]","def filter_available(self, queryset, name, value):\n if str2bool(value):\n # The 'quantity' field is greater than the calculated 'allocated' field\n # Note that the item must also be \"in stock\"\n return queryset.filter(StockItem.IN_STOCK_FILTER).filter(Q(quantity__gt=F('allocated')))\n else:\n # The 'quantity' field is less than (or equal to) the calculated 'allocated' field\n return queryset.filter(Q(quantity__lte=F('allocated')))","def filter(self, filters):","def filter_query(self, query, request, resource):\n raise NotImplementedError()","def add_filter():\n # reads the session\n session = request.args.get('session', type=str)\n # reads the requested process name\n process = request.args.get('process', default='receipt', type=str)\n\n if check_session_validity(session):\n user = get_user_from_session(session)\n if lh.check_user_log_visibility(user, process):\n # reads the specific filter to add\n filter = request.json['filter']\n # reads all the filters\n all_filters = request.json['all_filters']\n\n new_handler = lh.get_handler_for_process_and_session(process, session).add_filter(filter, all_filters)\n lh.set_handler_for_process_and_session(process, session, new_handler)\n return jsonify({\"status\": \"OK\"})\n\n return jsonify({\"status\": \"FAIL\"})","def pre_filter(self, qs):\n return qs","def details_filter(self):\n return self._details_filter","def _filter_in_request(self):\n pass","def queryset(self, request, queryset):\n if self.value() == '1':\n return queryset.exclude(moyen_id=24)\n if self.value() == '0':\n return queryset.filter(moyen_id=24)","def related_view_filter():\n pass","def step_filter(self, qs):\n return qs","def filter_by_query_params(self, request):\n items = self\n project = request.GET.get('project', None)\n customer = request.GET.get('customer', None)\n company = request.GET.get('company', None)\n engineer = request.GET.get('engineer', None)\n q = request.GET.get('q', None)\n sort_by = request.GET.get('sort_by', None)\n str = request.GET.get('str', None)\n\n if project:\n items = items.filter(project=project).distinct()\n if engineer:\n items = items.filter(lead__sales_engineer=engineer).distinct()\n if customer:\n items = items.filter(lead__customer=customer).distinct()\n if company:\n items = items.filter(company=company).distinct()\n # sort\n if q == 'asc' and sort_by:\n items = items.order_by(sort_by).distinct()\n\n if q == 'des' and sort_by:\n items = items.order_by('-' + sort_by).distinct()\n\n if str:\n # str = str.strip().lower()\n items = items.filter(Q(reference_no__icontains=str) |\n Q(erp_reference__icontains=str)).distinct()\n return items","def filter_flag_present(self, req, qs):\n return qs","def filter_by_query_params(self, request):\n items = self\n q = request.GET.get('q', None)\n customer = request.GET.get('customer', None)\n assigned_to = request.GET.get('assigned_to', None)\n project = request.GET.get('project', None)\n received_by = request.GET.get('received_by', None)\n str = request.GET.get('str', None)\n\n if customer:\n items = items.filter(customer=customer).distinct()\n\n if assigned_to:\n items = items.filter(assigned_to=assigned_to).distinct()\n\n if received_by:\n items = items.filter(sales_engineer=received_by).distinct()\n\n if project:\n items = items.filter(project=project).distinct()\n\n if q == 'asc':\n items = items.order_by('due_date').distinct()\n\n if q == 'des':\n items = items.order_by('-due_date').distinct()\n\n if str:\n # str = str.strip().lower()\n items = items.filter(Q(reference_no__icontains=str) |\n Q(customer__name__icontains=str) |\n Q(project__name__icontains=str) |\n Q(company__name__icontains=str) |\n Q(contact_name__icontains=str) |\n Q(email__icontains=str) |\n Q(description__icontains=str) |\n Q(assigned_to__first_name__icontains=str) |\n Q(sales_engineer__first_name__icontains=str)).distinct()\n return items","def add_filter(self, f):\n raise NotImplementedError","def filter_record(self, record):\n raise NotImplementedError(\"Override in subclass\")","async def filter(self, **kwargs):\n\n pass","def filter_depleted(self, queryset, name, value):\n if str2bool(value):\n return queryset.filter(quantity__lte=0)\n else:\n return queryset.exclude(quantity__lte=0)","def filter_by_query_params(self, request):\n items = self\n project = request.GET.get('project', None)\n quote = request.GET.get('quote', None)\n added_by = request.GET.get('added_by', None)\n customer = request.GET.get('customer', None)\n\n if project:\n items = items.filter(project=project).distinct()\n if customer:\n items = items.filter(customer=customer).distinct()\n if quote:\n items = items.filter(quote=quote).distinct()\n if added_by:\n items = items.filter(added_by=added_by).distinct()\n\n return items","def filter(self, *args, **kwargs):\n # *args are `Q` objects\n for q in args:\n self.query.add_q(q)\n if kwargs:\n self.query.add_q(ql.Q(**kwargs))\n return self","def queryset(self, request, queryset):\n if self.value():\n return queryset.filter(\n workacknowledgement__society_code=self.value()).distinct()\n return queryset","def filter_queryset(self, request, queryset, view):\n if request.user.is_anonymous:\n return queryset.filter(Q(shared_data=True))\n return queryset","def _add_filter(self, type, args):\r\n if isinstance(args, pylastica.filter.abstractfilter.AbstractFilter):\r\n args = args.to_dict()\r\n assert isinstance(args, dict), \"Invalid parameter. Must be a dict or instance of implementation of AbstractFilter.\"\r\n var_name = '_' + type\r\n self.__dict__[var_name].append(args)\r\n return self","def filter_queryset(self, request, queryset, view):\n if request and request.user.is_anonymous:\n return queryset.filter(shared=True)\n\n return queryset","def filter_by_query_params(self, request):\n items = self\n company = request.GET.get('company', None)\n main_contractor = request.GET.get('main_contractor', None)\n main_sub_contractor = request.GET.get('main_sub_contractor', None)\n client = request.GET.get('client', None)\n q = request.GET.get('q', None)\n sort_by = request.GET.get('sort_by', None)\n str = request.GET.get('str', None)\n\n # filter\n if main_contractor:\n items = items.filter(main_contractor=main_contractor).distinct()\n if main_sub_contractor:\n items = items.filter(main_sub_contractor=main_sub_contractor).distinct()\n if client:\n items = items.filter(client=client).distinct()\n if company:\n items = items.filter(companies_linked__in=[company]).distinct()\n # sort\n if q == 'asc' and sort_by:\n items = items.order_by(sort_by).distinct()\n\n if q == 'des' and sort_by:\n items = items.order_by('-' + sort_by).distinct()\n\n if str:\n # str = str.strip().lower()\n items = items.filter(Q(reference_no__icontains=str) |\n Q(name__icontains=str)).distinct()\n return items","def filter(self, filter):\n self._filter = filter","def filter_queryset(self, request, queryset, view):\n owner = request.query_params.get(\"owner\")\n\n if owner:\n kwargs = {self.owner_prefix + \"__username__iexact\": owner}\n\n return queryset.filter(**kwargs)\n\n return queryset","def get_queryset(self):\n\n fl = self.request.QUERY_PARAMS.get('fl', None)\n win = self.request.QUERY_PARAMS.get('win', None)\n win_filter = Q(orderstatus__in=['Shipped', 'Unshipped', 'Processing'], fulfillmentchannel='MFN')\n #win_filter = Q(orderstatus__in=['Unshipped', 'Processing'], fulfillmentchannel='MFN')\n\n queryset = None\n if fl is not None and fl.isdigit():\n logger.info(\"Got filter id: %s\", fl)\n try:\n filter = Filter.objects.get(pk=int(fl))\n if filter:\n ancestor_logic = Q() #Create Q object to hold other query\n #If filter is only root node\n if filter.is_root_node():\n ancestor_logic = pickle.loads(filter.logic) #Deserilize the filter logic\n logger.info(\"Filter has only root node, Logic: %s\", ancestor_logic)\n\n #If filter has parents\n else:\n for filter_data in filter.get_ancestors(False, True): #Get all parents including self\n filter_logic = pickle.loads(filter_data.logic) #Deserilize the filter logic\n if ancestor_logic.__len__()==0:\n ancestor_logic = filter_logic\n else:\n ancestor_logic = ancestor_logic & filter_logic\n logger.info(\"Filter has parents, Logic: %s\", ancestor_logic)\n\n if ancestor_logic:\n queryset = AmazonOrders.objects.filter(ancestor_logic & win_filter) #pass the query object to filter\n logger.info(\"Filter query, Query: %s\", queryset.query)\n\n except Exception as e:\n logger.error(\"In queryset exception : %s\",e)\n elif win is not None:\n logic = None\n if win == 'AFN':\n logic = Q(fulfillmentchannel=win, orderstatus='Shipped')\n elif win in ['Pending', 'Canceled']:\n logic = Q(orderstatus=win)\n elif win == 'Unshipped':\n logic = Q(orderstatus=win)\n\n if logic:\n queryset = AmazonOrders.objects.filter(logic)\n logger.info(\"Win query, Query: %s\", queryset.query)\n\n else:\n #queryset = AmazonOrders.objects.all()\n queryset = AmazonOrders.objects.filter(win_filter)\n logger.info(\"Filter not passed, Processing full Query: %s\", queryset.query)\n\n return queryset","def filter(self, filter_dict):\n pass","def filter_wrap_up_notes(self, filter_wrap_up_notes):\n \n self._filter_wrap_up_notes = filter_wrap_up_notes","def filter_query(self, request, query, view):\n raise NotImplementedError('.filter_query() must be implemented.') # pragma: no cover","def contributors_filter(self, **kwargs):\n return None","def filter(self) -> Optional[pulumi.Input['FilterArgs']]:\n return pulumi.get(self, \"filter\")","def filter_allocated(self, queryset, name, value):\n\n if str2bool(value):\n # Filter StockItem with either build allocations or sales order allocations\n return queryset.filter(Q(sales_order_allocations__isnull=False) | Q(allocations__isnull=False))\n else:\n # Filter StockItem without build allocations or sales order allocations\n return queryset.filter(Q(sales_order_allocations__isnull=True) & Q(allocations__isnull=True))","def filter(self, *args, **kwargs):\n self._expand_pk(kwargs)\n return self._filter_or_exclude(False, *args, **kwargs)","def filter_tracked(self, queryset, name, value):\n q_batch = Q(batch=None) | Q(batch='')\n q_serial = Q(serial=None) | Q(serial='')\n\n if str2bool(value):\n return queryset.exclude(q_batch & q_serial)\n else:\n return queryset.filter(q_batch & q_serial)","def get_queryset(self):\n qs = super(RetiresmartzViewSet, self).get_queryset()\n # Check user object permissions\n user = SupportRequest.target_user(self.request)\n return qs.filter_by_user(user)","def filter(self, **args ):\n query = TXLOG.select('*')\n for key, value in args.items():\n if '__' in key:\n key, op = key.split('__')\n else:\n op = 'eq'\n\n if not key in self.schema:\n raise BadArgument(\"Key %s not a valid argument\" % key )\n\n if not isinstance(value, basestring ):\n value = str(value)\n\n query = query.where({key:value}, self.operators[op])\n\n items = query.list()\n return items","def filter(self, **kwargs):\n kwargs['query'] += ' FROM {0}'\n return kwargs","def query_filters_restricted (self) :\n user = self.user_restriction\n if user is not None :\n return Q.created_by == user","def AddFilter(self, priority, predicates, action, reason_trail=None):\n if reason_trail is None:\n reason_trail = []\n\n assert isinstance(reason_trail, list)\n\n reason_trail.append((\"gnt:client\", \"\", EpochNano(),)) # add client reason\n\n body = {\n \"priority\": priority,\n \"predicates\": predicates,\n \"action\": action,\n \"reason\": reason_trail,\n }\n\n query = []\n\n return self._SendRequest(HTTP_POST,\n (\"/%s/filters\" % (GANETI_RAPI_VERSION)),\n query, body)","def search(self, filter):\n return [note for note in self.notes if note.match(filter)]","def append_crds_filter(self, filter):\n if filter not in self.filters:\n self.filters = self.filters + [filter]","def tests_ti_document_get_filter(self):\n super().group_get_filter()","def add_filter(self, filter):\n self._filters.append(filter.as_dict())","def allow_filtering(self):\r\n clone = copy.deepcopy(self)\r\n clone._allow_filtering = True\r\n return clone","def filter(self, *q, **kwargs):\n return self._filter_or_exclude(*q, **kwargs)","def _create_filter_object(form_data: Dict) -> Q:\n filter_object = Q(title__icontains=form_data[\"title\"])\n filter_object &= Q(author__icontains=form_data[\"author\"])\n filter_object &= Q(\n publication_language__icontains=form_data[\"publication_language\"]\n )\n if form_data[\"publication_date_start\"]:\n filter_object &= Q(\n publication_date__gte=form_data[\"publication_date_start\"]\n )\n if form_data[\"publication_date_end\"]:\n filter_object &= Q(publication_date__lte=form_data[\"publication_date_end\"])\n return filter_object","def filter_by_query_params(self, request):\n items = self\n project = request.GET.get('project', None)\n customer = request.GET.get('customer', None)\n quote = request.GET.get('quote', None)\n\n if project:\n items = items.filter(project=project).distinct()\n if customer:\n items = items.filter(customer=customer).distinct()\n if quote:\n items = items.filter(quote=quote).distinct()\n\n return items","def adjust_filter(self, queryset):\n new_queryset = queryset.filter(points__gt=0.0).order_by('-points', 'rate')\n return self.validate_queryset(new_queryset)","def filter(self, *args, **kwargs):\n return FilteredQuery(self, F(*args, **kwargs))","def get_queryset(self):\n qs = super(RetiresmartzAdviceViewSet, self).get_queryset()\n # Check user object permissions\n user = SupportRequest.target_user(self.request)\n return qs.filter_by_user(user)","def filter_req(req, extra):\n if extra and not req.marker:\n return False\n keep_req = True\n if req.marker:\n if not extra:\n extra = None\n keep_req = req.marker.evaluate({\"extra\": extra})\n return keep_req","def test_instrument_inventory_filtering():\n filt = 'GR150R'\n data = mm.instrument_inventory('niriss',\n add_filters={'filter': filt},\n return_data=True)\n\n filters = [row['filter'] for row in data['data']]\n\n assert all([i == filt for i in filters])","def prepend_crds_filter(self, filter):\n if filter not in self.filters:\n self.filters = [filter] + self.filters","def test_rawfilter(self):\n credentials = Mock(base_url=\"\")\n manager = Manager('invoices', credentials)\n uri, params, method, body, headers, singleobject = manager._filter(\n Status=\"VOIDED\",\n raw='Name.ToLower()==\"test contact\"'\n )\n self.assertEqual(\n params,\n {'where': 'Name.ToLower()==\"test contact\"&&Status==\"VOIDED\"'}\n )","def filter(self, *args, **kwargs):\n self._not_support_combined_queries(\"filter\")\n return self._filter_or_exclude(False, args, kwargs)","def notices_for(self, user, archived=False, unseen=None, on_site=None):\r\n if archived:\r\n qs = self.filter(user=user)\r\n else:\r\n qs = self.filter(user=user, archived=archived)\r\n if unseen is not None:\r\n qs = qs.filter(unseen=unseen)\r\n if on_site is not None:\r\n qs = qs.filter(on_site=on_site)\r\n return qs","def queryset(self, request):\n qs = super(ShortURLAdmin, self).queryset(request)\n if request.user.has_perm('deflect.list_all'):\n return qs\n return qs.filter(creator=request.user)","def _update_can_read_query(\n query, user, workspace_filter=None, user_filter=None\n):\n\n accessible_workspaces = _get_read_accessible_workspaces_by_user(user)\n # update query with workspace criteria\n query = django_raw_query.add_access_criteria(\n query, accessible_workspaces, user, workspace_filter, user_filter\n )\n return query","def filter(self, update):\n\n raise NotImplementedError","def filter_query(self, request, query, view):\n\n raise NotImplementedError('.filter_query() must be implemented.') # pragma: no cover","def filter_queryset(self, request, queryset, view):\n\n if view.action == \"list\":\n # Return widgets from xform user has perms to\n return self._xform_filter_queryset(request, queryset, view, \"object_id\")\n\n return super().filter_queryset(request, queryset, view)","def __init__(self, filters, use_include_order):\n self.filters = filters\n self.use_include_order = use_include_order","def filter(self, *args, **kwargs):\n clone = self._clone()\n for f in args:\n clone.filter_obj.add_filter(f)\n for key, value in kwargs.items():\n clone.filter_obj.add_filter_param(key, value)\n return clone","def queryset(self, request, queryset):\n if self.value():\n return queryset.filter(\n workacknowledgement__status=self.value()).distinct()\n return queryset","def principal_order_filter(self, x):\n return self.order_filter([x])","def filter_queryset(self, request, queryset, view):\n if view.action == \"enketo\":\n # noqa pylint: disable=attribute-defined-outside-init\n self.perm_format = \"%(app_label)s.report_%(model_name)s\"\n\n return super().filter_queryset(request, queryset, view)","def addAutoSaveFilter(filter):","def add_filter(process, ed_filter):\n\n if not hasattr(process, \"mps_filters\"): process.mps_filters = cms.Sequence()\n process.mps_filters += ed_filter\n return process.mps_filters","def filt(rec):\n return True # Show everything","def filter(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"filter\")","def queryset(self, request, queryset):\n # Compare the requested value (either '80s' or '90s')\n # to decide how to filter the queryset.\n if self.value() == 'yes':\n return queryset.exclude(image__exact='')\n if self.value() == 'no':\n return queryset.filter(image__exact='')","def get_queryset(self):\n queryset = IntakeDistributionCoordinates.objects.all().order_by('nutrient')\n\n # Dramatically improves performance\n queryset = queryset.prefetch_related('age_group')\n\n sex = self.request.query_params.get('sex', None)\n nutrient = self.request.query_params.get('nutrient', None)\n age_group_value = self.request.query_params.get('age_group_value', None)\n\n if sex is not None:\n queryset = queryset.filter(sex=sex)\n if nutrient is not None:\n queryset = queryset.filter(nutrient__icontains=nutrient)\n if age_group_value is not None:\n queryset = queryset.filter(age_group__age_group__icontains=age_group_value)\n return queryset","def get_queryset(self, request):\n qs = super(MaterialAdmin, self).get_queryset(request)\n if request.user.is_superuser:\n return qs.filter(content_type__lt=3)\n return qs.filter(topic_id__in=request.user.profile.topics.all(), content_type__lt=3)","def findNotes(self, authenticationToken, filter, offset, maxNotes):\r\n pass","def queryset(self, request, queryset):\n if self.value() == 'ignore':\n return queryset.filter(ignored_at__isnull=False)\n if self.value() == 'active':\n return queryset.filter(ignored_at=None)","def filter_in_stock(self, queryset, name, value):\n if str2bool(value):\n return queryset.filter(StockItem.IN_STOCK_FILTER)\n else:\n return queryset.exclude(StockItem.IN_STOCK_FILTER)","def type_filter(self, items, types=None):","def Filter(self, info):\n\n add_item = True\n \n if add_item and (self.use_only_ids != None) and (uid not in self.use_only_ids):\n add_item = False\n \n if add_item and (info['latlong'] == None):\n add_item = False\n \n if add_item and (self.size != None) and (info['size'] < self.size):\n add_item = False\n \n if add_item and (self.expert_rank != None) and (info['expert_rank'] < self.expert_rank):\n add_item = False\n \n if add_item and (self.kosher != None) and (self.kosher == True and info['kosher'] == False):\n add_item = False\n \n if add_item and (self.visiting_center != None) and (self.visiting_center == True and info['visiting_center'] == False):\n add_item = False\n \n if add_item and (self.visiting_center_free_admission != None) and (self.visiting_center_free_admission == True and info['visiting_center_free_admission'] == False):\n add_item = False\n \n if add_item and self.visit_time != None:\n day_of_visit = time.strftime(\"%A\", time.localtime(self.visit_time)).lower()\n if info['hours'][day_of_visit] != None:\n closing_at_that_day = time.mktime(time.strptime(time.strftime(\"%A, %d %b %Y\", time.localtime(self.visit_time)) + \" %d:00:00\" % (info['hours'][day_of_visit]), \"%A, %d %b %Y %H:%M:%S\"))\n if self.visit_time > (closing_at_that_day - self._delta_time_before_close):\n add_item = False\n if day_of_visit == 'saturday' and self.kosher == True:\n add_item = False\n \n if add_item and self.use_weather: \n if not self.weather_client.GoodForWinery(self.weather_client.GetCondition(info['latlong'])):\n add_item = False\n \n return add_item","def filter(*args, name: Union[AnyStr, bool]=\"\", type: Union[AnyStr, bool]=\"\", q=True,\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def test_filter_by_atribute(admin_client, public_resource_with_metadata, private_resource_with_metadata):\n query_filter = {\"availability\": [\"public\"]}\n djangoresponse = admin_client.get('/discoverapi/?filter={}'.format(json.dumps(query_filter)), follow=True)\n response = json.loads(djangoresponse.content.decode(\"utf-8\"))\n short_ids = [x['short_id'] for x in json.loads(response['resources'])]\n assert djangoresponse.status_code == 200\n assert public_resource_with_metadata.short_id in short_ids\n assert private_resource_with_metadata.short_id not in short_ids","def queryset(self, request, queryset):\n if self.value() == 'p':\n return queryset.filter(pointe=True)\n if self.value() == 'rapp':\n return queryset.filter(rapp__isnull=False)\n if self.value() == 'rien':\n return queryset.filter(rapp__isnull=True, pointe=False)\n if self.value() == 'pr':\n # comme il y a trois position, si l'on exclue les ni rapproche ni pointe on a les rapproche ou pointe\n return queryset.exclude(rapp__isnull=True, pointe=False)\n if self.value() == 'nrapp':\n return queryset.filter(rapp__isnull=True)","def queryset(self, request, queryset):\n if self.value() == 'examine':\n return queryset.filter(ignored_at=None, address_1__isnull=False, longitude_position=None).exclude(address_1='')\n if self.value() == 'done':\n return queryset.filter(longitude_position__isnull=False)\n if self.value() == 'ignore':\n return queryset.filter(ignored_at__isnull=False)","def filter_intent(self, intent: Intent):\n return True","def queryset(self, request, queryset):\n if self.value() == 'Y':\n return queryset.exclude(cwr_exports__count=0)\n elif self.value() == 'N':\n return queryset.filter(cwr_exports__count=0)","def filter(self):\n return self._filter","def filter(self, request, queryset): # NOQA: A003\n pro = request.GET.get(\"production\")\n\n if pro:\n queryset = queryset.filter(production=pro)\n\n queryset = queryset.prefetch_related(\"production\")\n\n return queryset","def getRecordFilter(self):\n\n # Replace dots with double underscore to get the notation that is\n # required by `Q`. Note that we could use that notation right away, but\n # IMHO dot notation, is nicer to read.\n key = self.record_field.replace(\".\", \"__\").lower()\n return Q(**{key: self.value})","def addAutoSaveDeleteFilter(filter):","def prepare_filter(self, ):\n if not self._parent.connected():\n return\n papers = self._parent.model.list_papers([\"name\"])\n upps = map(lambda a: (a[\"id\"], a[\"name\"]), papers)\n accounts = self._parent.model.list_accounts([\"name\"])\n uaccs = map(lambda a: (a[\"id\"], a[\"name\"]), accounts)\n self.dialog.update_widget(count_range = self._parent.model.get_deals_count_range(),\n price_range = self._parent.model.get_deals_price_range(),\n comm_range = self._parent.model.get_deals_commission_range(),\n volume_range = self._parent.model.get_deals_volume_range(),\n stock_list = upps,\n accounts_list = uaccs)","def complex_filter(self, filter_obj):\n if isinstance(filter_obj, Q):\n clone = self._chain()\n clone.query.add_q(filter_obj)\n return clone\n else:\n return self._filter_or_exclude(False, args=(), kwargs=filter_obj)","def get_queryset(self):\n filter_kwargs = {self.bound_to_user_field_name: self.request.auth.user}\n return super(BoundToUserMixin, self).get_queryset().filter(**filter_kwargs)"],"string":"[\n \"def set_restriction_filters(self):\\n self.restriction_filters[\\\"pk__exact\\\"] = self.request.user.pk\",\n \"def filter(self, *args, **kwargs):\",\n \"def _custom_filter(self, query):\\r\\n return query\",\n \"def filter_disputes_notes_grid(self, column_name, filter_item):\\n self.grid_filter_with_textbox(self.disputes_notes_grid_div_id, column_name, filter_item, 6)\",\n \"def filter(self):\\n _filter = self.ask_filter.text()\\n if _filter:\\n self.parent().artists = dmla.list_artists(_filter)\\n else:\\n self.parent().artists = self.parent().all_artists\\n self.parent().artist_filter = _filter\\n self.parent().do_select()\",\n \"def filter(self, observable):\",\n \"def filterRansac():\\n pass\",\n \"def mine(self, request, *args, **kwargs):\\n qs = self.queryset\\n if request.user.is_anonymous():\\n qs = self.queryset.none()\\n elif not self.is_admin(request.user):\\n perms = OperatorPermission.objects.filter(user=request.user)\\n if perms:\\n query = Q()\\n for perm in perms:\\n query |= Q(carrier=perm.carrier, region=perm.region)\\n qs = self.queryset.filter(query)\\n else:\\n qs = self.queryset.none()\\n self.object_list = self.filter_queryset(qs)\\n serializer = self.get_serializer(self.object_list, many=True)\\n return Response(serializer.data)\",\n \"def manual(self):\\n\\n\\t\\tfilter = [\\\"January\\\", \\\"February\\\", \\\"March\\\", \\\"April\\\", \\\"May\\\", \\\"June\\\", \\\"July\\\", \\\"August\\\", \\\"September\\\", \\\"October\\\", \\\"November\\\", \\\"December\\\", \\\"World War II\\\"],\\n\\n\\t\\tself.index[\\\"authorities\\\"] = [auth for auth in self.index[\\\"authorities\\\"] if auth not in filter]\\n\\n\\t\\tfor item in self.index[\\\"items\\\"]:\\n\\t\\t\\tself.index[\\\"items\\\"][item] = [auth for auth in self.index[\\\"items\\\"][item] if auth in self.index[\\\"authorities\\\"]]\",\n \"def filter_available(self, queryset, name, value):\\n if str2bool(value):\\n # The 'quantity' field is greater than the calculated 'allocated' field\\n # Note that the item must also be \\\"in stock\\\"\\n return queryset.filter(StockItem.IN_STOCK_FILTER).filter(Q(quantity__gt=F('allocated')))\\n else:\\n # The 'quantity' field is less than (or equal to) the calculated 'allocated' field\\n return queryset.filter(Q(quantity__lte=F('allocated')))\",\n \"def filter(self, filters):\",\n \"def filter_query(self, query, request, resource):\\n raise NotImplementedError()\",\n \"def add_filter():\\n # reads the session\\n session = request.args.get('session', type=str)\\n # reads the requested process name\\n process = request.args.get('process', default='receipt', type=str)\\n\\n if check_session_validity(session):\\n user = get_user_from_session(session)\\n if lh.check_user_log_visibility(user, process):\\n # reads the specific filter to add\\n filter = request.json['filter']\\n # reads all the filters\\n all_filters = request.json['all_filters']\\n\\n new_handler = lh.get_handler_for_process_and_session(process, session).add_filter(filter, all_filters)\\n lh.set_handler_for_process_and_session(process, session, new_handler)\\n return jsonify({\\\"status\\\": \\\"OK\\\"})\\n\\n return jsonify({\\\"status\\\": \\\"FAIL\\\"})\",\n \"def pre_filter(self, qs):\\n return qs\",\n \"def details_filter(self):\\n return self._details_filter\",\n \"def _filter_in_request(self):\\n pass\",\n \"def queryset(self, request, queryset):\\n if self.value() == '1':\\n return queryset.exclude(moyen_id=24)\\n if self.value() == '0':\\n return queryset.filter(moyen_id=24)\",\n \"def related_view_filter():\\n pass\",\n \"def step_filter(self, qs):\\n return qs\",\n \"def filter_by_query_params(self, request):\\n items = self\\n project = request.GET.get('project', None)\\n customer = request.GET.get('customer', None)\\n company = request.GET.get('company', None)\\n engineer = request.GET.get('engineer', None)\\n q = request.GET.get('q', None)\\n sort_by = request.GET.get('sort_by', None)\\n str = request.GET.get('str', None)\\n\\n if project:\\n items = items.filter(project=project).distinct()\\n if engineer:\\n items = items.filter(lead__sales_engineer=engineer).distinct()\\n if customer:\\n items = items.filter(lead__customer=customer).distinct()\\n if company:\\n items = items.filter(company=company).distinct()\\n # sort\\n if q == 'asc' and sort_by:\\n items = items.order_by(sort_by).distinct()\\n\\n if q == 'des' and sort_by:\\n items = items.order_by('-' + sort_by).distinct()\\n\\n if str:\\n # str = str.strip().lower()\\n items = items.filter(Q(reference_no__icontains=str) |\\n Q(erp_reference__icontains=str)).distinct()\\n return items\",\n \"def filter_flag_present(self, req, qs):\\n return qs\",\n \"def filter_by_query_params(self, request):\\n items = self\\n q = request.GET.get('q', None)\\n customer = request.GET.get('customer', None)\\n assigned_to = request.GET.get('assigned_to', None)\\n project = request.GET.get('project', None)\\n received_by = request.GET.get('received_by', None)\\n str = request.GET.get('str', None)\\n\\n if customer:\\n items = items.filter(customer=customer).distinct()\\n\\n if assigned_to:\\n items = items.filter(assigned_to=assigned_to).distinct()\\n\\n if received_by:\\n items = items.filter(sales_engineer=received_by).distinct()\\n\\n if project:\\n items = items.filter(project=project).distinct()\\n\\n if q == 'asc':\\n items = items.order_by('due_date').distinct()\\n\\n if q == 'des':\\n items = items.order_by('-due_date').distinct()\\n\\n if str:\\n # str = str.strip().lower()\\n items = items.filter(Q(reference_no__icontains=str) |\\n Q(customer__name__icontains=str) |\\n Q(project__name__icontains=str) |\\n Q(company__name__icontains=str) |\\n Q(contact_name__icontains=str) |\\n Q(email__icontains=str) |\\n Q(description__icontains=str) |\\n Q(assigned_to__first_name__icontains=str) |\\n Q(sales_engineer__first_name__icontains=str)).distinct()\\n return items\",\n \"def add_filter(self, f):\\n raise NotImplementedError\",\n \"def filter_record(self, record):\\n raise NotImplementedError(\\\"Override in subclass\\\")\",\n \"async def filter(self, **kwargs):\\n\\n pass\",\n \"def filter_depleted(self, queryset, name, value):\\n if str2bool(value):\\n return queryset.filter(quantity__lte=0)\\n else:\\n return queryset.exclude(quantity__lte=0)\",\n \"def filter_by_query_params(self, request):\\n items = self\\n project = request.GET.get('project', None)\\n quote = request.GET.get('quote', None)\\n added_by = request.GET.get('added_by', None)\\n customer = request.GET.get('customer', None)\\n\\n if project:\\n items = items.filter(project=project).distinct()\\n if customer:\\n items = items.filter(customer=customer).distinct()\\n if quote:\\n items = items.filter(quote=quote).distinct()\\n if added_by:\\n items = items.filter(added_by=added_by).distinct()\\n\\n return items\",\n \"def filter(self, *args, **kwargs):\\n # *args are `Q` objects\\n for q in args:\\n self.query.add_q(q)\\n if kwargs:\\n self.query.add_q(ql.Q(**kwargs))\\n return self\",\n \"def queryset(self, request, queryset):\\n if self.value():\\n return queryset.filter(\\n workacknowledgement__society_code=self.value()).distinct()\\n return queryset\",\n \"def filter_queryset(self, request, queryset, view):\\n if request.user.is_anonymous:\\n return queryset.filter(Q(shared_data=True))\\n return queryset\",\n \"def _add_filter(self, type, args):\\r\\n if isinstance(args, pylastica.filter.abstractfilter.AbstractFilter):\\r\\n args = args.to_dict()\\r\\n assert isinstance(args, dict), \\\"Invalid parameter. Must be a dict or instance of implementation of AbstractFilter.\\\"\\r\\n var_name = '_' + type\\r\\n self.__dict__[var_name].append(args)\\r\\n return self\",\n \"def filter_queryset(self, request, queryset, view):\\n if request and request.user.is_anonymous:\\n return queryset.filter(shared=True)\\n\\n return queryset\",\n \"def filter_by_query_params(self, request):\\n items = self\\n company = request.GET.get('company', None)\\n main_contractor = request.GET.get('main_contractor', None)\\n main_sub_contractor = request.GET.get('main_sub_contractor', None)\\n client = request.GET.get('client', None)\\n q = request.GET.get('q', None)\\n sort_by = request.GET.get('sort_by', None)\\n str = request.GET.get('str', None)\\n\\n # filter\\n if main_contractor:\\n items = items.filter(main_contractor=main_contractor).distinct()\\n if main_sub_contractor:\\n items = items.filter(main_sub_contractor=main_sub_contractor).distinct()\\n if client:\\n items = items.filter(client=client).distinct()\\n if company:\\n items = items.filter(companies_linked__in=[company]).distinct()\\n # sort\\n if q == 'asc' and sort_by:\\n items = items.order_by(sort_by).distinct()\\n\\n if q == 'des' and sort_by:\\n items = items.order_by('-' + sort_by).distinct()\\n\\n if str:\\n # str = str.strip().lower()\\n items = items.filter(Q(reference_no__icontains=str) |\\n Q(name__icontains=str)).distinct()\\n return items\",\n \"def filter(self, filter):\\n self._filter = filter\",\n \"def filter_queryset(self, request, queryset, view):\\n owner = request.query_params.get(\\\"owner\\\")\\n\\n if owner:\\n kwargs = {self.owner_prefix + \\\"__username__iexact\\\": owner}\\n\\n return queryset.filter(**kwargs)\\n\\n return queryset\",\n \"def get_queryset(self):\\n\\n fl = self.request.QUERY_PARAMS.get('fl', None)\\n win = self.request.QUERY_PARAMS.get('win', None)\\n win_filter = Q(orderstatus__in=['Shipped', 'Unshipped', 'Processing'], fulfillmentchannel='MFN')\\n #win_filter = Q(orderstatus__in=['Unshipped', 'Processing'], fulfillmentchannel='MFN')\\n\\n queryset = None\\n if fl is not None and fl.isdigit():\\n logger.info(\\\"Got filter id: %s\\\", fl)\\n try:\\n filter = Filter.objects.get(pk=int(fl))\\n if filter:\\n ancestor_logic = Q() #Create Q object to hold other query\\n #If filter is only root node\\n if filter.is_root_node():\\n ancestor_logic = pickle.loads(filter.logic) #Deserilize the filter logic\\n logger.info(\\\"Filter has only root node, Logic: %s\\\", ancestor_logic)\\n\\n #If filter has parents\\n else:\\n for filter_data in filter.get_ancestors(False, True): #Get all parents including self\\n filter_logic = pickle.loads(filter_data.logic) #Deserilize the filter logic\\n if ancestor_logic.__len__()==0:\\n ancestor_logic = filter_logic\\n else:\\n ancestor_logic = ancestor_logic & filter_logic\\n logger.info(\\\"Filter has parents, Logic: %s\\\", ancestor_logic)\\n\\n if ancestor_logic:\\n queryset = AmazonOrders.objects.filter(ancestor_logic & win_filter) #pass the query object to filter\\n logger.info(\\\"Filter query, Query: %s\\\", queryset.query)\\n\\n except Exception as e:\\n logger.error(\\\"In queryset exception : %s\\\",e)\\n elif win is not None:\\n logic = None\\n if win == 'AFN':\\n logic = Q(fulfillmentchannel=win, orderstatus='Shipped')\\n elif win in ['Pending', 'Canceled']:\\n logic = Q(orderstatus=win)\\n elif win == 'Unshipped':\\n logic = Q(orderstatus=win)\\n\\n if logic:\\n queryset = AmazonOrders.objects.filter(logic)\\n logger.info(\\\"Win query, Query: %s\\\", queryset.query)\\n\\n else:\\n #queryset = AmazonOrders.objects.all()\\n queryset = AmazonOrders.objects.filter(win_filter)\\n logger.info(\\\"Filter not passed, Processing full Query: %s\\\", queryset.query)\\n\\n return queryset\",\n \"def filter(self, filter_dict):\\n pass\",\n \"def filter_wrap_up_notes(self, filter_wrap_up_notes):\\n \\n self._filter_wrap_up_notes = filter_wrap_up_notes\",\n \"def filter_query(self, request, query, view):\\n raise NotImplementedError('.filter_query() must be implemented.') # pragma: no cover\",\n \"def contributors_filter(self, **kwargs):\\n return None\",\n \"def filter(self) -> Optional[pulumi.Input['FilterArgs']]:\\n return pulumi.get(self, \\\"filter\\\")\",\n \"def filter_allocated(self, queryset, name, value):\\n\\n if str2bool(value):\\n # Filter StockItem with either build allocations or sales order allocations\\n return queryset.filter(Q(sales_order_allocations__isnull=False) | Q(allocations__isnull=False))\\n else:\\n # Filter StockItem without build allocations or sales order allocations\\n return queryset.filter(Q(sales_order_allocations__isnull=True) & Q(allocations__isnull=True))\",\n \"def filter(self, *args, **kwargs):\\n self._expand_pk(kwargs)\\n return self._filter_or_exclude(False, *args, **kwargs)\",\n \"def filter_tracked(self, queryset, name, value):\\n q_batch = Q(batch=None) | Q(batch='')\\n q_serial = Q(serial=None) | Q(serial='')\\n\\n if str2bool(value):\\n return queryset.exclude(q_batch & q_serial)\\n else:\\n return queryset.filter(q_batch & q_serial)\",\n \"def get_queryset(self):\\n qs = super(RetiresmartzViewSet, self).get_queryset()\\n # Check user object permissions\\n user = SupportRequest.target_user(self.request)\\n return qs.filter_by_user(user)\",\n \"def filter(self, **args ):\\n query = TXLOG.select('*')\\n for key, value in args.items():\\n if '__' in key:\\n key, op = key.split('__')\\n else:\\n op = 'eq'\\n\\n if not key in self.schema:\\n raise BadArgument(\\\"Key %s not a valid argument\\\" % key )\\n\\n if not isinstance(value, basestring ):\\n value = str(value)\\n\\n query = query.where({key:value}, self.operators[op])\\n\\n items = query.list()\\n return items\",\n \"def filter(self, **kwargs):\\n kwargs['query'] += ' FROM {0}'\\n return kwargs\",\n \"def query_filters_restricted (self) :\\n user = self.user_restriction\\n if user is not None :\\n return Q.created_by == user\",\n \"def AddFilter(self, priority, predicates, action, reason_trail=None):\\n if reason_trail is None:\\n reason_trail = []\\n\\n assert isinstance(reason_trail, list)\\n\\n reason_trail.append((\\\"gnt:client\\\", \\\"\\\", EpochNano(),)) # add client reason\\n\\n body = {\\n \\\"priority\\\": priority,\\n \\\"predicates\\\": predicates,\\n \\\"action\\\": action,\\n \\\"reason\\\": reason_trail,\\n }\\n\\n query = []\\n\\n return self._SendRequest(HTTP_POST,\\n (\\\"/%s/filters\\\" % (GANETI_RAPI_VERSION)),\\n query, body)\",\n \"def search(self, filter):\\n return [note for note in self.notes if note.match(filter)]\",\n \"def append_crds_filter(self, filter):\\n if filter not in self.filters:\\n self.filters = self.filters + [filter]\",\n \"def tests_ti_document_get_filter(self):\\n super().group_get_filter()\",\n \"def add_filter(self, filter):\\n self._filters.append(filter.as_dict())\",\n \"def allow_filtering(self):\\r\\n clone = copy.deepcopy(self)\\r\\n clone._allow_filtering = True\\r\\n return clone\",\n \"def filter(self, *q, **kwargs):\\n return self._filter_or_exclude(*q, **kwargs)\",\n \"def _create_filter_object(form_data: Dict) -> Q:\\n filter_object = Q(title__icontains=form_data[\\\"title\\\"])\\n filter_object &= Q(author__icontains=form_data[\\\"author\\\"])\\n filter_object &= Q(\\n publication_language__icontains=form_data[\\\"publication_language\\\"]\\n )\\n if form_data[\\\"publication_date_start\\\"]:\\n filter_object &= Q(\\n publication_date__gte=form_data[\\\"publication_date_start\\\"]\\n )\\n if form_data[\\\"publication_date_end\\\"]:\\n filter_object &= Q(publication_date__lte=form_data[\\\"publication_date_end\\\"])\\n return filter_object\",\n \"def filter_by_query_params(self, request):\\n items = self\\n project = request.GET.get('project', None)\\n customer = request.GET.get('customer', None)\\n quote = request.GET.get('quote', None)\\n\\n if project:\\n items = items.filter(project=project).distinct()\\n if customer:\\n items = items.filter(customer=customer).distinct()\\n if quote:\\n items = items.filter(quote=quote).distinct()\\n\\n return items\",\n \"def adjust_filter(self, queryset):\\n new_queryset = queryset.filter(points__gt=0.0).order_by('-points', 'rate')\\n return self.validate_queryset(new_queryset)\",\n \"def filter(self, *args, **kwargs):\\n return FilteredQuery(self, F(*args, **kwargs))\",\n \"def get_queryset(self):\\n qs = super(RetiresmartzAdviceViewSet, self).get_queryset()\\n # Check user object permissions\\n user = SupportRequest.target_user(self.request)\\n return qs.filter_by_user(user)\",\n \"def filter_req(req, extra):\\n if extra and not req.marker:\\n return False\\n keep_req = True\\n if req.marker:\\n if not extra:\\n extra = None\\n keep_req = req.marker.evaluate({\\\"extra\\\": extra})\\n return keep_req\",\n \"def test_instrument_inventory_filtering():\\n filt = 'GR150R'\\n data = mm.instrument_inventory('niriss',\\n add_filters={'filter': filt},\\n return_data=True)\\n\\n filters = [row['filter'] for row in data['data']]\\n\\n assert all([i == filt for i in filters])\",\n \"def prepend_crds_filter(self, filter):\\n if filter not in self.filters:\\n self.filters = [filter] + self.filters\",\n \"def test_rawfilter(self):\\n credentials = Mock(base_url=\\\"\\\")\\n manager = Manager('invoices', credentials)\\n uri, params, method, body, headers, singleobject = manager._filter(\\n Status=\\\"VOIDED\\\",\\n raw='Name.ToLower()==\\\"test contact\\\"'\\n )\\n self.assertEqual(\\n params,\\n {'where': 'Name.ToLower()==\\\"test contact\\\"&&Status==\\\"VOIDED\\\"'}\\n )\",\n \"def filter(self, *args, **kwargs):\\n self._not_support_combined_queries(\\\"filter\\\")\\n return self._filter_or_exclude(False, args, kwargs)\",\n \"def notices_for(self, user, archived=False, unseen=None, on_site=None):\\r\\n if archived:\\r\\n qs = self.filter(user=user)\\r\\n else:\\r\\n qs = self.filter(user=user, archived=archived)\\r\\n if unseen is not None:\\r\\n qs = qs.filter(unseen=unseen)\\r\\n if on_site is not None:\\r\\n qs = qs.filter(on_site=on_site)\\r\\n return qs\",\n \"def queryset(self, request):\\n qs = super(ShortURLAdmin, self).queryset(request)\\n if request.user.has_perm('deflect.list_all'):\\n return qs\\n return qs.filter(creator=request.user)\",\n \"def _update_can_read_query(\\n query, user, workspace_filter=None, user_filter=None\\n):\\n\\n accessible_workspaces = _get_read_accessible_workspaces_by_user(user)\\n # update query with workspace criteria\\n query = django_raw_query.add_access_criteria(\\n query, accessible_workspaces, user, workspace_filter, user_filter\\n )\\n return query\",\n \"def filter(self, update):\\n\\n raise NotImplementedError\",\n \"def filter_query(self, request, query, view):\\n\\n raise NotImplementedError('.filter_query() must be implemented.') # pragma: no cover\",\n \"def filter_queryset(self, request, queryset, view):\\n\\n if view.action == \\\"list\\\":\\n # Return widgets from xform user has perms to\\n return self._xform_filter_queryset(request, queryset, view, \\\"object_id\\\")\\n\\n return super().filter_queryset(request, queryset, view)\",\n \"def __init__(self, filters, use_include_order):\\n self.filters = filters\\n self.use_include_order = use_include_order\",\n \"def filter(self, *args, **kwargs):\\n clone = self._clone()\\n for f in args:\\n clone.filter_obj.add_filter(f)\\n for key, value in kwargs.items():\\n clone.filter_obj.add_filter_param(key, value)\\n return clone\",\n \"def queryset(self, request, queryset):\\n if self.value():\\n return queryset.filter(\\n workacknowledgement__status=self.value()).distinct()\\n return queryset\",\n \"def principal_order_filter(self, x):\\n return self.order_filter([x])\",\n \"def filter_queryset(self, request, queryset, view):\\n if view.action == \\\"enketo\\\":\\n # noqa pylint: disable=attribute-defined-outside-init\\n self.perm_format = \\\"%(app_label)s.report_%(model_name)s\\\"\\n\\n return super().filter_queryset(request, queryset, view)\",\n \"def addAutoSaveFilter(filter):\",\n \"def add_filter(process, ed_filter):\\n\\n if not hasattr(process, \\\"mps_filters\\\"): process.mps_filters = cms.Sequence()\\n process.mps_filters += ed_filter\\n return process.mps_filters\",\n \"def filt(rec):\\n return True # Show everything\",\n \"def filter(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"filter\\\")\",\n \"def queryset(self, request, queryset):\\n # Compare the requested value (either '80s' or '90s')\\n # to decide how to filter the queryset.\\n if self.value() == 'yes':\\n return queryset.exclude(image__exact='')\\n if self.value() == 'no':\\n return queryset.filter(image__exact='')\",\n \"def get_queryset(self):\\n queryset = IntakeDistributionCoordinates.objects.all().order_by('nutrient')\\n\\n # Dramatically improves performance\\n queryset = queryset.prefetch_related('age_group')\\n\\n sex = self.request.query_params.get('sex', None)\\n nutrient = self.request.query_params.get('nutrient', None)\\n age_group_value = self.request.query_params.get('age_group_value', None)\\n\\n if sex is not None:\\n queryset = queryset.filter(sex=sex)\\n if nutrient is not None:\\n queryset = queryset.filter(nutrient__icontains=nutrient)\\n if age_group_value is not None:\\n queryset = queryset.filter(age_group__age_group__icontains=age_group_value)\\n return queryset\",\n \"def get_queryset(self, request):\\n qs = super(MaterialAdmin, self).get_queryset(request)\\n if request.user.is_superuser:\\n return qs.filter(content_type__lt=3)\\n return qs.filter(topic_id__in=request.user.profile.topics.all(), content_type__lt=3)\",\n \"def findNotes(self, authenticationToken, filter, offset, maxNotes):\\r\\n pass\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'ignore':\\n return queryset.filter(ignored_at__isnull=False)\\n if self.value() == 'active':\\n return queryset.filter(ignored_at=None)\",\n \"def filter_in_stock(self, queryset, name, value):\\n if str2bool(value):\\n return queryset.filter(StockItem.IN_STOCK_FILTER)\\n else:\\n return queryset.exclude(StockItem.IN_STOCK_FILTER)\",\n \"def type_filter(self, items, types=None):\",\n \"def Filter(self, info):\\n\\n add_item = True\\n \\n if add_item and (self.use_only_ids != None) and (uid not in self.use_only_ids):\\n add_item = False\\n \\n if add_item and (info['latlong'] == None):\\n add_item = False\\n \\n if add_item and (self.size != None) and (info['size'] < self.size):\\n add_item = False\\n \\n if add_item and (self.expert_rank != None) and (info['expert_rank'] < self.expert_rank):\\n add_item = False\\n \\n if add_item and (self.kosher != None) and (self.kosher == True and info['kosher'] == False):\\n add_item = False\\n \\n if add_item and (self.visiting_center != None) and (self.visiting_center == True and info['visiting_center'] == False):\\n add_item = False\\n \\n if add_item and (self.visiting_center_free_admission != None) and (self.visiting_center_free_admission == True and info['visiting_center_free_admission'] == False):\\n add_item = False\\n \\n if add_item and self.visit_time != None:\\n day_of_visit = time.strftime(\\\"%A\\\", time.localtime(self.visit_time)).lower()\\n if info['hours'][day_of_visit] != None:\\n closing_at_that_day = time.mktime(time.strptime(time.strftime(\\\"%A, %d %b %Y\\\", time.localtime(self.visit_time)) + \\\" %d:00:00\\\" % (info['hours'][day_of_visit]), \\\"%A, %d %b %Y %H:%M:%S\\\"))\\n if self.visit_time > (closing_at_that_day - self._delta_time_before_close):\\n add_item = False\\n if day_of_visit == 'saturday' and self.kosher == True:\\n add_item = False\\n \\n if add_item and self.use_weather: \\n if not self.weather_client.GoodForWinery(self.weather_client.GetCondition(info['latlong'])):\\n add_item = False\\n \\n return add_item\",\n \"def filter(*args, name: Union[AnyStr, bool]=\\\"\\\", type: Union[AnyStr, bool]=\\\"\\\", q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def test_filter_by_atribute(admin_client, public_resource_with_metadata, private_resource_with_metadata):\\n query_filter = {\\\"availability\\\": [\\\"public\\\"]}\\n djangoresponse = admin_client.get('/discoverapi/?filter={}'.format(json.dumps(query_filter)), follow=True)\\n response = json.loads(djangoresponse.content.decode(\\\"utf-8\\\"))\\n short_ids = [x['short_id'] for x in json.loads(response['resources'])]\\n assert djangoresponse.status_code == 200\\n assert public_resource_with_metadata.short_id in short_ids\\n assert private_resource_with_metadata.short_id not in short_ids\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'p':\\n return queryset.filter(pointe=True)\\n if self.value() == 'rapp':\\n return queryset.filter(rapp__isnull=False)\\n if self.value() == 'rien':\\n return queryset.filter(rapp__isnull=True, pointe=False)\\n if self.value() == 'pr':\\n # comme il y a trois position, si l'on exclue les ni rapproche ni pointe on a les rapproche ou pointe\\n return queryset.exclude(rapp__isnull=True, pointe=False)\\n if self.value() == 'nrapp':\\n return queryset.filter(rapp__isnull=True)\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'examine':\\n return queryset.filter(ignored_at=None, address_1__isnull=False, longitude_position=None).exclude(address_1='')\\n if self.value() == 'done':\\n return queryset.filter(longitude_position__isnull=False)\\n if self.value() == 'ignore':\\n return queryset.filter(ignored_at__isnull=False)\",\n \"def filter_intent(self, intent: Intent):\\n return True\",\n \"def queryset(self, request, queryset):\\n if self.value() == 'Y':\\n return queryset.exclude(cwr_exports__count=0)\\n elif self.value() == 'N':\\n return queryset.filter(cwr_exports__count=0)\",\n \"def filter(self):\\n return self._filter\",\n \"def filter(self, request, queryset): # NOQA: A003\\n pro = request.GET.get(\\\"production\\\")\\n\\n if pro:\\n queryset = queryset.filter(production=pro)\\n\\n queryset = queryset.prefetch_related(\\\"production\\\")\\n\\n return queryset\",\n \"def getRecordFilter(self):\\n\\n # Replace dots with double underscore to get the notation that is\\n # required by `Q`. Note that we could use that notation right away, but\\n # IMHO dot notation, is nicer to read.\\n key = self.record_field.replace(\\\".\\\", \\\"__\\\").lower()\\n return Q(**{key: self.value})\",\n \"def addAutoSaveDeleteFilter(filter):\",\n \"def prepare_filter(self, ):\\n if not self._parent.connected():\\n return\\n papers = self._parent.model.list_papers([\\\"name\\\"])\\n upps = map(lambda a: (a[\\\"id\\\"], a[\\\"name\\\"]), papers)\\n accounts = self._parent.model.list_accounts([\\\"name\\\"])\\n uaccs = map(lambda a: (a[\\\"id\\\"], a[\\\"name\\\"]), accounts)\\n self.dialog.update_widget(count_range = self._parent.model.get_deals_count_range(),\\n price_range = self._parent.model.get_deals_price_range(),\\n comm_range = self._parent.model.get_deals_commission_range(),\\n volume_range = self._parent.model.get_deals_volume_range(),\\n stock_list = upps,\\n accounts_list = uaccs)\",\n \"def complex_filter(self, filter_obj):\\n if isinstance(filter_obj, Q):\\n clone = self._chain()\\n clone.query.add_q(filter_obj)\\n return clone\\n else:\\n return self._filter_or_exclude(False, args=(), kwargs=filter_obj)\",\n \"def get_queryset(self):\\n filter_kwargs = {self.bound_to_user_field_name: self.request.auth.user}\\n return super(BoundToUserMixin, self).get_queryset().filter(**filter_kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59470046","0.56179065","0.5568572","0.55291736","0.55232686","0.550949","0.5477399","0.5416927","0.53570306","0.5337462","0.5325544","0.524886","0.52306837","0.52302957","0.5215678","0.52031213","0.5201506","0.51735073","0.51728815","0.51467144","0.514203","0.5136353","0.51243895","0.51184905","0.5105488","0.50855577","0.50736","0.5051021","0.5033821","0.5028863","0.502849","0.5025777","0.5023414","0.5022275","0.50111127","0.4993075","0.4990055","0.49724847","0.49640092","0.4962335","0.49551862","0.49400976","0.49360558","0.49253955","0.4924366","0.4922427","0.49158987","0.49073175","0.49056283","0.48947698","0.48932886","0.48752245","0.4872461","0.4864137","0.48638833","0.48576975","0.4856809","0.4853644","0.48467976","0.4846225","0.48408517","0.48394668","0.48245826","0.48244023","0.482019","0.48094317","0.4806345","0.4805388","0.4804936","0.47923684","0.47870794","0.4779239","0.4774144","0.47634006","0.4752381","0.475111","0.47386074","0.47349185","0.47346047","0.47321168","0.47299352","0.47286278","0.47254416","0.47204906","0.47204342","0.47142357","0.46926835","0.4690832","0.46863842","0.467578","0.46708626","0.46668637","0.466422","0.46624312","0.46537164","0.46496692","0.46492952","0.46469197","0.46456078","0.46449947","0.46416983"],"string":"[\n \"0.59470046\",\n \"0.56179065\",\n \"0.5568572\",\n \"0.55291736\",\n \"0.55232686\",\n \"0.550949\",\n \"0.5477399\",\n \"0.5416927\",\n \"0.53570306\",\n \"0.5337462\",\n \"0.5325544\",\n \"0.524886\",\n \"0.52306837\",\n \"0.52302957\",\n \"0.5215678\",\n \"0.52031213\",\n \"0.5201506\",\n \"0.51735073\",\n \"0.51728815\",\n \"0.51467144\",\n \"0.514203\",\n \"0.5136353\",\n \"0.51243895\",\n \"0.51184905\",\n \"0.5105488\",\n \"0.50855577\",\n \"0.50736\",\n \"0.5051021\",\n \"0.5033821\",\n \"0.5028863\",\n \"0.502849\",\n \"0.5025777\",\n \"0.5023414\",\n \"0.5022275\",\n \"0.50111127\",\n \"0.4993075\",\n \"0.4990055\",\n \"0.49724847\",\n \"0.49640092\",\n \"0.4962335\",\n \"0.49551862\",\n \"0.49400976\",\n \"0.49360558\",\n \"0.49253955\",\n \"0.4924366\",\n \"0.4922427\",\n \"0.49158987\",\n \"0.49073175\",\n \"0.49056283\",\n \"0.48947698\",\n \"0.48932886\",\n \"0.48752245\",\n \"0.4872461\",\n \"0.4864137\",\n \"0.48638833\",\n \"0.48576975\",\n \"0.4856809\",\n \"0.4853644\",\n \"0.48467976\",\n \"0.4846225\",\n \"0.48408517\",\n \"0.48394668\",\n \"0.48245826\",\n \"0.48244023\",\n \"0.482019\",\n \"0.48094317\",\n \"0.4806345\",\n \"0.4805388\",\n \"0.4804936\",\n \"0.47923684\",\n \"0.47870794\",\n \"0.4779239\",\n \"0.4774144\",\n \"0.47634006\",\n \"0.4752381\",\n \"0.475111\",\n \"0.47386074\",\n \"0.47349185\",\n \"0.47346047\",\n \"0.47321168\",\n \"0.47299352\",\n \"0.47286278\",\n \"0.47254416\",\n \"0.47204906\",\n \"0.47204342\",\n \"0.47142357\",\n \"0.46926835\",\n \"0.4690832\",\n \"0.46863842\",\n \"0.467578\",\n \"0.46708626\",\n \"0.46668637\",\n \"0.466422\",\n \"0.46624312\",\n \"0.46537164\",\n \"0.46496692\",\n \"0.46492952\",\n \"0.46469197\",\n \"0.46456078\",\n \"0.46449947\",\n \"0.46416983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17095,"cells":{"query":{"kind":"string","value":"We assume that all biogenic CO2 flows will be detected via add_flow, and will have their names set to something"},"document":{"kind":"string","value":"def _quell_co2(self, flowable, context):\n if self._quell_biogenic is False:\n return False\n if flowable in self._bio_co2:\n if context.is_subcompartment(self._cm['from air']):\n return True\n if context.is_subcompartment(self._cm['Emissions']):\n return True\n return False"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _dup_pipeline_name_cfg(self):","def _configure_flowables(self, flowables):\n if flowables is None:\n flowables = DEFAULT_FLOWABLES\n\n # FlowablesDict-- mainly to upsample CAS numbers for matching\n self._fm = FlowablesDict()\n\n self._fm.new_entry('carbon dioxide', '124-38-9')\n self._fm.new_entry('Water', '7732-18-5')\n # we store the child object and use it to signify biogenic CO2 to optionally quell\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\n\n # now load + merge from file\n self._fm.load(flowables)\n\n # now add all known \"biotic\" synonyms for CO2 to the biotic child\n for k in self._fm.synonyms('124-38-9'):\n if bool(biogenic.search(k)):\n self._bio_co2.add_term(k)\n self._fq_map = {fb: set() for fb in self._fm.objects}","def add_flow(self, flow: \"Flow\") -> str:\n self.flows = {flow.name: flow.name} # type: Dict[str, str]\n self._flows = {flow.name: flow} # type: Dict[str, Flow]\n return flow.name","def test_update_flow_classifier_name(self):\n resource = 'flow_classifier'\n cmd = fc.FlowClassifierUpdate(test_cli20.MyApp(sys.stdout), None)\n self._test_update_resource(resource, cmd, 'myid',\n ['myid', '--name', 'myname'],\n {'name': 'myname'})","def __init__(self, lines=[], people=[], name=''):\n\n self.name=repr(name)\n self.relable=defaultdict(str)\n self.people=set(people + self.keys())\n self.new_names=list(set(people)-set(self.keys())) #New People being added.\n self.process_lines(lines)\n self.concepts=set(self.relable.keys())\n# have to store all concepts and then check for each concept (before adding it to a causal graph) if it already exists in the set or not; if it exists, I find the representative label with which it is labelled in the first causal graph to which it was added. Also, this set of concepts is the raw material of the data set of concepts wherein 3000 or so concepts that are identical in meaning are paired by hand and then a machiene learning algorithm will be trained on the training set (the first x paired concepts) to learn which concepts are in meaning identical. Later, the causal-belief-graphs will be simplified, using this tool. The concepts are also stored in each node, under the key \"concept\". The greatest advantage of using networkx is that all kinds of information, including affective information, can be stored in each link and each concept, making these cognitive maps greatly extendable beyond the causal!\n\n for name in self.new_names:\n self[name]=CausalGraph()","def setCaptainNames(self):\n self.captainNames = anwp.func.names.getNames('system_names.txt',self.maxCaptainNames+100, self.rand.randint(1,100))\n self.currentCaptainName = 0","def __init__(self):\n self._names = []\n self._forwardFactories = []\n self._inputs = []\n self._inputFilters = {}\n self._outputFilters = []\n self._inputCheckers = []\n pass","def _genBlocksByName(self):\n self.blocksByName = {\n block.getName(): block for block in self.getBlocks(includeAll=True)\n }","def _initNames(self):\n self.outselect = os.path.join(self.workpath, 'FT1_selected'+self.suffix+'.fits')\n self.outmktime = os.path.join(self.workpath, 'FT1_filtered'+self.suffix+'.fits')\n self.outltcube = os.path.join(self.workpath, 'LtCube'+self.suffix+'.fits')\n self.outbincub = os.path.join(self.workpath, 'BinCube'+self.suffix+'.fits')\n self.outbinmap = os.path.join(self.workpath, 'CMAP'+self.suffix+'.fits')\n self.outbinexp = os.path.join(self.workpath, 'BinExpMap'+self.suffix+'.fits')\n self.outexpmap = os.path.join(self.workpath, 'ExpMap'+self.suffix+'.fits')\n self.outsrcmap = os.path.join(self.workpath, 'SrcMaps'+self.suffix+'.fits')\n self.outgtlike = os.path.join(self.workpath, 'Results'+self.suffix+'.dat')\n self.outmodel = os.path.join(self.workpath, 'OutModel'+self.suffix+'.xml')\n self.outapert = os.path.join(self.workpath, 'LC_ApPhoto'+self.suffix+'.fits')\n self.outgtmod = os.path.join(self.workpath, 'GtModel'+self.suffix+'.fits')\n self.outresid = os.path.join(self.workpath, 'Resid'+self.suffix+'.fits')\n self.outresig = os.path.join(self.workpath, 'ResSigma'+self.suffix+'.fits')\n self.outtsmap = os.path.join(self.workpath, 'TSMmap'+self.suffix+'.fits')\n return\n # self.outfind = self.dir + self.src + '_FindSrc'+self.suffix+'.txt'","def init_name(self):\r\n try:\r\n rval = self.name\r\n except AttributeError:\r\n if 0:\r\n l = []\r\n for n in self.fgraph.toposort():\r\n if hasattr(n.op, \"name\") and n.op.name is not None:\r\n v = n.op.name\r\n if v.startswith(\"Composite\"):\r\n v = v[len(\"Composite\"):]\r\n else:\r\n v = n.op.__class__.__name__\r\n l.append(v)\r\n rval = \"Composite{\" + \",\".join(l) + \"}\"\r\n else:\r\n for i, r in enumerate(self.fgraph.inputs):\r\n r.name = 'i%i' % i\r\n for i, r in enumerate(self.fgraph.outputs):\r\n r.name = 'o%i' % i\r\n io = set(self.fgraph.inputs + self.fgraph.outputs)\r\n for i, r in enumerate(self.fgraph.variables):\r\n if r not in io and len(r.clients) > 1:\r\n r.name = 't%i' % i\r\n rval = \"Composite{%s}\" % str(self.fgraph)\r\n self.name = rval","def setup(self):\n ### Set Names\n # Name of the pipeline reduction step\n self.name='sortobs'\n # Shortcut for pipeline reduction step and identifier for\n # saved file names.\n self.procname = 'RAW'\n # Set Logger for this pipe step\n self.log = logging.getLogger('pipe.step.%s' % self.name)\n ### Set Parameter list\n # Clear Parameter list\n self.paramlist = []\n # Append Parameters\n self.paramlist.append(['pattern', '(^.+_([gri]-band|oiii|sii|clear|h-alpha))',\n 'Regex pattern used to get name by matching name_filter'])\n # Confirm end of setup\n self.log.debug('Setup: done')","def __addNewASG2Tracker( self, metaModelName, ASGgraph ): \r\n self.__trackASG[ self.__sanitizeMetaModelName( metaModelName ) ] = \\\r\n [ASGgraph, cloningMachine(ASGgraph.nodeTypes)]","def _get_next_name(self, flow):\n parent_ref = '%s ASSEMBLY' % flow.external_ref\n try:\n self.fg.get(parent_ref)\n except EntityNotFound:\n return parent_ref\n _ac = 0\n while True:\n parent_ref = '%s ASSEMBLY alt %d' % (flow.external_ref, _ac)\n try:\n self.fg.get(parent_ref)\n _ac += 1\n except EntityNotFound:\n return parent_ref","def __init__(self) -> None:\n super().__init__()\n self._flows = {} # type: Dict[str, str]","def update_flow(self, flow):\r\n self.flow = flow","def normalize(self):\n\n # modify from this:\n #\n # \"workflow\": {\n # \"test-and-deploy\": {\n # \"resolves\": \"deploy\"\n # }\n # }\n #\n # to this:\n #\n # \"workflow\": {\n # \"name\": \"test-and-deploy\",\n # \"on\": \"push\",\n # \"resolves\": \"deploy\"\n # }\n for wf_name, wf_block in dict(self.wf['workflow']).items():\n self.wf['name'] = wf_name\n self.wf['on'] = wf_block.get('on', 'push')\n self.wf['resolves'] = wf_block['resolves']\n\n # python 2 to 3 compatibility\n try:\n basestring\n except UnboundLocalError:\n basestring = str\n\n # create a list for all attributes that can be either string or list\n if isinstance(self.wf['resolves'], basestring):\n self.wf['resolves'] = [self.wf['resolves']]\n elif not self.is_list_of_strings(self.wf['resolves']):\n pu.fail('[resolves] must be a list of strings or a string\\n')\n if not isinstance(self.wf['on'], basestring):\n pu.fail('[on] attribute must be a string\\n')\n for _, a_block in self.wf['action'].items():\n if not isinstance(a_block['uses'], basestring):\n pu.fail('[uses] attribute must be a string\\n')\n if a_block.get('needs', None):\n if isinstance(a_block['needs'], basestring):\n a_block['needs'] = [a_block['needs']]\n elif not self.is_list_of_strings(a_block['needs']):\n pu.fail(\n '[needs] attribute must be a list of strings \\\n or a string\\n')\n if a_block.get('runs', None):\n if isinstance(a_block['runs'], basestring):\n a_block['runs'] = [a_block['runs']]\n elif not self.is_list_of_strings(a_block['runs']):\n pu.fail(\n '[runs] attribute must be a list of strings \\\n or a string\\n')\n if a_block.get('args', None):\n if isinstance(a_block['args'], basestring):\n a_block['args'] = a_block['args'].split()\n elif not self.is_list_of_strings(a_block['args']):\n pu.fail(\n '[args] attribute must be a list of strings \\\n or a string\\n')\n if a_block.get('env', None):\n if not isinstance(a_block['env'], dict):\n pu.fail('[env] attribute must be a dict\\n')\n if a_block.get('secrets', None):\n if not self.is_list_of_strings(a_block['secrets']):\n pu.fail('[secrets] attribute must be a list of strings\\n')","def __init__(self, name):\n self.name = name\n self._edges = []","def pipeline_name_conventions(self):\n passed = []\n warned = []\n failed = []\n\n if self.pipeline_name.islower() and self.pipeline_name.isalnum():\n passed.append(\"Name adheres to nf-core convention\")\n if not self.pipeline_name.islower():\n warned.append(\"Naming does not adhere to nf-core conventions: Contains uppercase letters\")\n if not self.pipeline_name.isalnum():\n warned.append(\"Naming does not adhere to nf-core conventions: Contains non alphanumeric characters\")\n\n return {\"passed\": passed, \"warned\": warned, \"failed\": failed}","def generateTaskName(self):\n brokenComponent = ['head','hand','leg','body','hand','leg']\n for component in brokenComponent:\n self.enqueue(Task(component))","def __init__(self, name):\n self._name = name\n self._arcsFrom = set()\n self._arcsTo = set()","def __init__(self, file_benign, file_unknown):\n # Load data\n self.data_benign = self.load(file_benign)\n self.data_unknown = self.load(file_unknown)\n\n # Transform to flows\n self.flows_benign , self.labels_benign = self.flows(self.data_benign )\n self.flows_unknown, self.labels_unknown = self.flows(self.data_unknown)","def resolveNames(self):\n client.resolveNames(self)\n # TODO: Do any name resolutions here.\n # The names of other objects this object refers to, either intrinsically or in its parameters, should be checked here.","def flow_name(self):\n # This never changes (so no read locking needed).\n return self._flowdetail.name","def _name_changed(self):\n self._named = True","def populate_with_empty_descriptions(self):\n for baction in self.behaviour():\n if isinstance(baction, Behaviour) and not baction.description:\n desc = baction.kind(baction.name)\n self[baction.name] = desc","def test_device_states_device_name_put(self):\n pass","def __init__(\n self, name: str, first_phase: str, inherits: Optional[str] = None\n ) -> None:\n self.name = name\n self.first_phase = first_phase\n self.inherits = inherits","def doName(self):\n _short = self.p_nameShort\n _str_func = '[{0}] doName'.format(_short)\n log.debug(cgmGEN.logString_start(_str_func))\n\n _d = NAMETOOLS.returnObjectGeneratedNameDict(_short)\n\n _direction = self.getEnumValueString('side')\n if _direction != 'none':\n log.debug(\"|{0}| >> direction: {1}\".format(_str_func,_direction))\n _d['cgmDirection'] = _direction \n self.doStore('cgmDirection',_direction)\n else:\n if _d.get('cgmDirection'):_d.pop('cgmDirection')\n self.doStore('cgmDirection','')\n log.debug(\"|{0}| >> cgmDirection: {1}\".format(_str_func,self.cgmDirection))\n \n\n _position = self.getMayaAttr('position')#self.getEnumValueString('position')\n if _position and _position != '':\n _d['cgmPosition'] = _position \n self.doStore('cgmPosition',_position)\n else:self.cgmPosition = ''\n\n #Get Raw name\n\n for a in 'cgmName','baseName','puppetName',:\n if self.hasAttr(a):\n _d['cgmName'] = ATTR.get(_short,a)\n continue\n \"\"\"\n if self.hasAttr('blockProfile'):\n _blockProfile = self.getMayaAttr('blockProfile') or ''\n if _d.get('cgmName','') not in _blockProfile:\n #if _d.get('cgmName','') in _blockProfile:\n _blockProfile = _blockProfile.replace(_d['cgmName'],'')\n if len(_blockProfile):\n _d['cgmNameModifier'] = STR.camelCase(_blockProfile)\n \"\"\"\n _blockType = ATTR.get(_short,'blockType')\n _d['cgmType'] = _blockType + 'Block'\n \n pprint.pprint(_d)\n \"\"\"\n if self.getMayaAttr('position'):\n _d['cgmPosition'] = self.getEnumValueString('position')\n if self.getMayaAttr('side'):\n _value = self.getEnumValueString('side')\n _d['cgmDirection'] = _value\n self.doStore('cgmDirection',_value)\"\"\"\n #pprint.pprint(vars())\n #Check for special attributes to replace data, name\n _d_new = {}\n for k,v in _d.iteritems():\n if v in ['none','None','NONE',None]:\n continue\n _d_new[k] = v\n log.debug(\"|{0}| >> dict: {1}\".format(_str_func,_d_new))\n self.rename(NAMETOOLS.returnCombinedNameFromDict(_d_new))\n \n \n if self.getMessage('moduleTarget'):\n log.debug(\"|{0}| >> Module target naming...\".format(_str_func)) \n self.moduleTarget.doName()\n \n \n ml_objs = get_blockDagNodes(self)\n for mObj in ml_objs:\n if mObj != self:\n mObj.doName()\n \n for plug in ['formNull','noTransFormNull',\n 'prerigNull','noTransPrerigNull',\n 'defineNull','noTransDefineNull',\n 'moduleTarget']:\n mPlug = self.getMessageAsMeta(plug)\n if mPlug:\n mPlug.doName()","def __init__(self, name):\n composites.Composite.__init__(self, name)\n self.p.flags = Flags.fromStringIgnoreErrors(name)\n self.assembliesByName = {}\n self.circularRingList = {}\n self.blocksByName = {} # lookup tables\n self.numRings = 0\n self.spatialGrid = None\n self.xsIndex = {}\n self.p.numMoves = 0\n self._lib = None # placeholder for ISOTXS object\n self.locParams = {} # location-based parameters\n # overridden in case.py to include pre-reactor time.\n self.timeOfStart = time.time()\n self.zones = zones.Zones() # initialize with empty Zones object\n # initialize the list that holds all shuffles\n self.moveList = {}\n self.scalarVals = {}\n self._nuclideCategories = {}\n self.typeList = [] # list of block types to convert name - to -number.\n\n # leftover default \"settings\" that are intended to eventually be elsewhere.\n self._freshFeedType = \"feed fuel\"\n self._trackAssems = False\n self._circularRingMode = False\n self._circularRingPitch = 1.0\n self._automaticVariableMesh = False\n self._minMeshSizeRatio = 0.15\n self._detailedAxialExpansion = False","def input_names(self):\n raise NotImplementedError(\n 'Derived ExternalGreyBoxModel classes need to implement the method: input_names'\n )","def _maybe_set_name(self) -> None:\n if not self.name:\n if isinstance(self.github, dict):\n if self.github.get(\"commit\"):\n self.name = f\"{self.reason}: {self.github['commit']}\"","def __init__(self, name):\n self.name = name\n self.atoms = {}","def setUpFormData(self):\n super(InconsistentNameCSID, self).setUpFormData()\n self.formData['name'] = 'Pyrazine'","def __init__(__self__, *,\n name: pulumi.Input[str]):\n pulumi.set(__self__, \"name\", name)","def __init__(self, type, name, verbose):\n self._name = name\n self._verbose = verbose\n self.__fdev_id = _cantera.flowdev_new(type)","def new_flow(self, data):\n\n try:\n self.logger.debug(\"new_flow data: {}\".format(data))\n if len(self.pp2ofi) == 0:\n self.obtain_port_correspondence()\n\n # We have to build the data for the opendaylight call from the generic data\n flow = {\n 'id': data['name'],\n 'flow-name': data['name'],\n 'idle-timeout': 0,\n 'hard-timeout': 0,\n 'table_id': 0,\n 'priority': data.get('priority'),\n 'match': {}\n }\n sdata = {'flow-node-inventory:flow': [flow]}\n if not data['ingress_port'] in self.pp2ofi:\n error_text = 'Error. Port ' + data['ingress_port'] + ' is not present in the switch'\n self.logger.warning(\"new_flow \" + error_text)\n raise OpenflowConnUnexpectedResponse(error_text)\n flow['match']['in-port'] = self.pp2ofi[data['ingress_port']]\n if data.get('dst_mac'):\n flow['match']['ethernet-match'] = {\n 'ethernet-destination': {'address': data['dst_mac']}\n }\n if data.get('vlan_id'):\n flow['match']['vlan-match'] = {\n 'vlan-id': {\n 'vlan-id-present': True,\n 'vlan-id': int(data['vlan_id'])\n }\n }\n actions = []\n flow['instructions'] = {\n 'instruction': [{\n 'order': 1,\n 'apply-actions': {'action': actions}\n }]\n }\n\n order = 0\n for action in data['actions']:\n new_action = {'order': order}\n if action[0] == \"vlan\":\n if action[1] is None:\n # strip vlan\n new_action['strip-vlan-action'] = {}\n else:\n new_action['set-field'] = {\n 'vlan-match': {\n 'vlan-id': {\n 'vlan-id-present': True,\n 'vlan-id': int(action[1])\n }\n }\n }\n elif action[0] == 'out':\n new_action['output-action'] = {}\n if not action[1] in self.pp2ofi:\n error_msg = 'Port ' + action[1] + ' is not present in the switch'\n raise OpenflowConnUnexpectedResponse(error_msg)\n\n new_action['output-action']['output-node-connector'] = self.pp2ofi[action[1]]\n else:\n error_msg = \"Unknown item '{}' in action list\".format(action[0])\n self.logger.error(\"new_flow \" + error_msg)\n raise OpenflowConnUnexpectedResponse(error_msg)\n\n actions.append(new_action)\n order += 1\n\n # print json.dumps(sdata)\n of_response = requests.put(self.url + \"restconf/config/opendaylight-inventory:nodes/node/\" + self.id +\n \"/table/0/flow/\" + data['name'], headers=self.headers, data=json.dumps(sdata))\n error_text = \"Openflow response {}: {}\".format(of_response.status_code, of_response.text)\n if of_response.status_code != 200:\n self.logger.warning(\"new_flow \" + error_text)\n raise OpenflowConnUnexpectedResponse(error_text)\n self.logger.debug(\"new_flow OK \" + error_text)\n return None\n\n except requests.exceptions.RequestException as e:\n # raise an exception in case of contection error\n error_text = type(e).__name__ + \": \" + str(e)\n self.logger.error(\"new_flow \" + error_text)\n raise OpenflowConnConnectionException(error_text)","def __init__(self, name, direction, core):\n self.name = name\n self.direction = direction\n self.signals = {}\n self.core = core\n self.endpoints = []\n self.interface_type = None","def __init__(self,\r\n name: str,\r\n pipeline: PipelineBase,\r\n is_deterministic: bool = True):\r\n self.name = name\r\n self.is_deterministic = is_deterministic\r\n self.pipeline = pipeline","def __init__(self, name):\r\n super(Structure, self).__init__()\r\n self.name = name","def __init__(self, manager, name):\n FarmDescriptor.__init__(self,manager,'Trigger')\n #Online.DatapointLoader.DatapointLoader.__init__(self,manager,name)\n self.typeMgr = self.manager.typeMgr()\n setup = 'RECO'\n setup = 'ONLINE'\n if setup=='RECO':\n self.allocatePartition = self.allocRecoPartition\n self.getPartition = self.getRecoPartition\n self.freePartition = self.freeRecoPartition\n self.loadRunInfo = self.loadRecoRunInfo\n self.runInfo_type = self.typeMgr.type('RunFarmInfo')\n self.runinfos = Online.PVSS.DpVectorActor(self.manager)\n self.runinfos.lookupOriginal(self.name+'_Farm??.general.partName',self.runInfo_type)\n else:\n self.allocatePartition = self.allocateSlice\n self.getPartition = self.getSlice\n self.freePartition = self.freeSlice\n self.loadRunInfo = self.loadRecoRunInfo\n self.sliceType = self.typeMgr.type('FarmSlice')\n self.runInfo_type = self.typeMgr.type('FarmRunInfo')\n \n self.writer = self.manager.devWriter()\n self.fsm_typ = self.typeMgr.type('_FwFsmDevice')\n subinfo_typ = self.typeMgr.type('FarmSubInfo')\n self.allsubfarms = Online.PVSS.DpVectorActor(self.manager)\n self.allsubfarms.lookupOriginal(self.name+'_*.UsedBy',subinfo_typ)","def __init__(self,name,direction=RIGHT,isFinal=False):\n\t\tself.name = name\n\t\tself.trans= {}\n\t\t# self.outputs = {}\n\t\tself.direction = direction\n\t\tself.isFinal = isFinal","def name(self, name):\n pass","def createUsedBy( self ):\n for aChunk in self.chunkSeq:\n #usage = (self.fullNameFor(aChunk.name), aChunk.seq)\n for aRefName in aChunk.genReferences( self ):\n for c in self.getchunk( aRefName ):\n c.referencedBy.append( aChunk )\n c.refCount += 1\n \n for nm in self.no_reference():\n self.logger.warn( \"No reference to {!r}\".format(nm) )\n for nm in self.multi_reference():\n self.logger.warn( \"Multiple references to {!r}\".format(nm) )\n for nm in self.no_definition():\n self.logger.error( \"No definition for {!r}\".format(nm) )\n self.errors += 1","def __init__(self, name):\n self.nodes = []\n self.name = str(name)","def get_comp_names(self, names):\n names = names[:]\n comp_names = {}\n for r_block in self.frd.result_blocks:\n if r_block.name in names and r_block.name not in comp_names:\n comp_names[r_block.name] = []\n for ent in r_block.entities:\n if ent.ictype == 2 and ent.icind1 == 0:\n continue\n comp_names[r_block.name].append(ent.name)\n names.remove(r_block.name)\n if not names:\n break\n return comp_names","def names(self, channel, *args, **kwargs):\n pass","def store_names(self):\n # clear the text buffer, or create new buffer\n try:\n namestxt = bpy.data.texts[\"FullNames\"]\n namestxt.clear()\n except KeyError:\n namestxt = bpy.data.texts.new(\"FullNames\")\n \n # write the names to the text buffer\n for block, shortname in self.nif_import.dict_names.items():\n block_name = block.name.decode()\n if block_name and shortname != block_name:\n namestxt.write('%s;%s\\n' % (shortname, block_name))","def test_update_flow_classifier_description(self):\n resource = 'flow_classifier'\n cmd = fc.FlowClassifierUpdate(test_cli20.MyApp(sys.stdout), None)\n myid = 'myid'\n args = [myid, '--description', 'flow_classifier1', '--description',\n 'flow_classifier2']\n updatefields = {'description': 'flow_classifier2'}\n self._test_update_resource(resource, cmd, myid, args, updatefields)","def build_stage2_6(self):\n paf, cfm = self.stage2_6.values()\n for i in range(2, 7):\n paf_ = OrderedDict([(k.replace('i', str(i)),paf[k]) for k in paf])\n cfm_ = OrderedDict([(k.replace('i', str(i)),cfm[k]) for k in cfm])\n stage_ = OrderedDict(PAF=paf_, CFM=cfm_)\n setattr(self, f'stage{i}', stage_)","def __init__(self, name, fave_football_team):\n self.name = name\n self.fave_football_team = fave_football_team","def setUpFormData(self):\n super(InconsistentCASName, self).setUpFormData()\n self.formData['CAS_ID'] = '290-37-9'\n self.formData['CSID'] = '8904' # consistent values for pyrazine.","def create_label(self, org, name):\n pass","def _setup_pipeline_cfg(self):","def _replace_init_name(self, cr, uid, organisation_function_child_ids, context=None):\r\n for item in organisation_function_child_ids:\r\n if len(item) == 3 and item[2] and 'function_type_id' in item[2]:\r\n function_type_obj = self.pool.get('res.function.type').browse(cr,uid,item[2]['function_type_id'])\r\n #reformat name\r\n item[2]['name'] = function_type_obj.name\r\n yield item","def get_all_flow(self, conf, dpid):\n\t\tpass","def __init__(self, name, attributes, incident_edges):\n self.name = name # initialize all necessary fields\n self.attributes = attributes\n self.incident_edges = incident_edges","def __init__(self, name, attributes, incident_edges):\n self.name = name # initialize all necessary fields\n self.attributes = attributes\n self.incident_edges = incident_edges","def setup(self):\n ### Set Names\n # Name of the pipeline reduction step\n self.name='coadd'\n # Shortcut for pipeline reduction step and identifier for\n # saved file names.\n self.procname = 'coadd'\n # Set Logger for this pipe step\n self.log = logging.getLogger('pipe.step.%s' % self.name)\n ### Set Parameter list\n # Clear Parameter list\n self.paramlist = []\n # Append parameters\n self.paramlist.append(['kernel','square',\n 'Specifies the kernel used to determine spreading of input pixels onto output pixels \\\n - options are square, point, gaussian, smoothing, tophat'])\n self.paramlist.append(['pixfrac', 1.,\n 'The fraction of an output pixel(s) that an input pixel\\'s flux is confined to'])\n self.paramlist.append(['resolution', 1.,\n 'Pixel scale divisor for output image (higher gives more resolution, lower gives less)'])\n self.paramlist.append(['pad', 0,\n 'Extra padding outside maximum extent of inputs'])\n self.paramlist.append(['fillval', np.nan,\n 'Value for filling in the area(s) in the output where there is no input data'])\n self.paramlist.append(['drizzleweights','exptime',\n 'How each input image should be weighted when added to the output \\\n - options are exptime, expsq and uniform'])\n self.paramlist.append(['outangle',0.,\n 'Output angle of drizzled image (currently not functional)'])","def map_activity_name2(self, name):\n newname = self.amappings2.get(name)\n if newname is None:\n return 'Other'\n else:\n return newname","def _gather_components(self):\n comps = set()\n for data in self._collection:\n for c in data.components:\n if c in comps:\n continue\n label = \"%s (%s)\" % (c, data.label)\n label = disambiguate(label, self._labels)\n self._labels[label] = c\n comps.add(c)","def so_attributes(self):\n try:\n self.channels\n except AttributeError:\n # create if doesn't exist\n self.channels = [x[0] for x in self.data.columns]\n \n dfs = ['sofiltEEG', 'spsofiltEEG']\n [setattr(self, df, pd.DataFrame(index=self.data.index)) for df in dfs]\n self.so_events = {}\n self.so_rejects = {}","def __init__(self, name, summary, branch, new_owner, user):\n self.name = name\n self.summary = summary\n self.branch = [branch]\n self.new_owner = new_owner\n self.user = user","def __init__(self, name):\n self.name = name\n self.difficulty = 0\n self.description = \"\"\n self.prerequisites = {}\n self.cost = {}\n self.effects = {}\n self.strings = {}","def __init__(self, name):\n\n self.name = name\n self.exits = {}\n self.inventory= []\n self.objects = []\n self.description = ''","def audit_names_in_metadata(self):\n\n # Iterate over commits....\n for commit in self.repository.commits.values():\n for name in [ commit.committer_name, commit.author_name ]:\n # Is the name whitelisted?\n if name in self.FullNameWhitelist:\n continue\n\n # As a special case, allow the name 'GitHub' for certain repositories\n if name == 'GitHub' and self.repository.path in self.GitHubPRWhitelist:\n self.__log_warning(commit.sha1, \"Commit has username 'GitHub' (web merge of PR); allowing anyway\")\n continue\n\n # Check to see if the name contains spaces - if not - it is probably misconfigured....\n if \" \" not in name.strip():\n self.__log_failure(commit.sha1, \"Non-full name: \" + name)\n continue","def _create_parameter_names(self):\n self._parameter_names = self.parameter_schema[\"problem\"][\"names\"]","def __init__(self, name: str, createStepName: str, fields: str = \"\"):\n pass","def flow(self, flow):\n\n self._flow = flow","def setup(self):\n declared = []\n spec = get_specs_for_module(self.module_name)\n\n # Inputs\n for entry in spec.cpacs_inout.inputs:\n if entry.var_name in declared:\n log.info(\"Already declared\")\n elif entry.var_name in Rt.optim_var_dict:\n var = Rt.optim_var_dict[entry.var_name]\n if entry.var_name in Rt.optim_var_dict:\n self.add_input(entry.var_name, val=var[1][0])\n declared.append(entry.var_name)\n\n if declared == []:\n self.add_input(self.module_name + \"_in\")\n declared = []\n\n for entry in spec.cpacs_inout.outputs:\n # Replace special characters from the name of the entry and checks for accronyms\n entry.var_name = change_var_name(entry.var_name)\n\n if entry.var_name in declared:\n log.info(\"Already declared\")\n elif entry.var_name in Rt.optim_var_dict:\n var = Rt.optim_var_dict[entry.var_name]\n self.add_output(entry.var_name, val=var[1][0])\n declared.append(entry.var_name)\n elif (\n \"aeromap\" in entry.var_name and self.module_name == Rt.last_am_module\n ): # == 'PyTornado': #not skf^is_skf:\n # Condition to avoid any conflict with skinfriction\n for name in PARAMS:\n if name in Rt.optim_var_dict:\n var = Rt.optim_var_dict[name]\n self.add_input(name, val=var[1][0])\n declared.append(entry.var_name)\n for name in COEFS:\n if name in Rt.optim_var_dict:\n var = Rt.optim_var_dict[name]\n if is_digit(var[1][0]):\n self.add_output(name, val=var[1][0])\n else:\n self.add_output(name)\n declared.append(entry.var_name)\n\n if declared == []:\n self.add_output(self.module_name + \"_out\")","def __init__(self, name, graph, plugs=None):\n self.name = name\n self.graph = graph\n self.plugs = plugs or []\n self.graph.inputs[self.name] = self","def __init__(self, flow, register=True):\n\n self.flow = flow\n self.domain = flow.domain\n self.version = '1.0'\n self.activities = activity.find_workflow_activities(flow)\n self.task_list = flow.name\n super(DeciderWorker, self).__init__()\n\n if register:\n self.register()","def __init__(self, name, process_step=None, **attributes):\n self.name = name\n self.process_step = process_step\n # Check the config file for the process metadata if process step not provided\n if process_step is None:\n cfg_def = cfg.read_procedures()[name]\n self.process_step = cfg_def['process_step']\n attributes = cfg_def.copy()\n \n\n #self.source = source\n self.attributes = attributes\n #self.attributes['standard_name'] = 'source'","def name_test(item):\n return f\"{item['params']['interface']}:{item['expected']['state']}\"","def __init__(self, in_channels, ofp_name='Optical Flow Predictor'):\n super(OFPredictor, self).__init__()\n self.ofp_name = ofp_name\n\n # definition of all layer channels\n self.layer_out_channels = {1: 128,\n 2: 64,\n 3: 32,\n 4: 16,\n 5: 2}\n self.layer_in_channels = {1: in_channels,\n 2: self.layer_out_channels[1],\n 3: self.layer_out_channels[2],\n 4: self.layer_out_channels[3],\n 5: self.layer_out_channels[4]}\n\n self.layers = self.build_layers()\n\n # print('%s Model Successfully Built \\n' % self.kpp_name)","def make_output_names(self):\n yaml_names = []\n fits_names = []\n\n if self.use_nonstsci_names:\n for i in range(len(self.info['Module'])):\n act = str(self.info['act_id'][i]).zfill(2)\n if self.info['Instrument'][i].lower() == 'niriss':\n det = 'NIS'\n elif self.info['Instrument'][i].lower() == 'fgs':\n det = 'FGS'\n else:\n det = self.info['detector'][i]\n mode = self.info['Mode'][i]\n dither = str(self.info['dither'][i]).zfill(2)\n\n yaml_names.append(os.path.abspath(os.path.join(self.output_dir, 'Act{}_{}_{}_Dither{}.yaml'\n .format(act, det, mode, dither))))\n fits_names.append('Act{}_{}_{}_Dither{}_uncal.fits'.format(act, det, mode, dither))\n\n else:\n for i in range(len(self.info['Module'])):\n if self.info['Instrument'][i].upper() == 'NIRCAM':\n fulldetector = 'nrc{}'.format(self.info['detector'][i].lower())\n else:\n fulldetector = self.info['detector'][i].lower()\n outfilebase = self.create_output_name(self.info, index=i)\n outfile = \"{}{}{}\".format(outfilebase, fulldetector, '_uncal.fits')\n yamlout = \"{}{}{}\".format(outfilebase, fulldetector, '.yaml')\n\n yaml_names.append(yamlout)\n fits_names.append(outfile)\n\n self.info['yamlfile'] = yaml_names\n self.info['outputfits'] = fits_names\n # Table([self.info['yamlfile']]).pprint()","def __init__(self, name, description=None):\n super(ArtifactDefinition, self).__init__()\n self.collectors = []\n self.conditions = []\n self.description = description\n self.name = name\n self.labels = []\n self.provides = []\n self.supported_os = []\n self.urls = []","def test_rename_to_mlflow(mlflow):\n atom = ATOMClassifier(X_bin, y_bin, experiment=\"test\", random_state=1)\n atom.run(\"GNB\")\n atom.scoring()\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training","def __init__(self):\n\n\n f = open(datapath + '/Data/companylist.csv', 'r')\n\n\n for line in f:\n reg = line.split(',')\n if reg[0] != 'Symbol':\n if reg[0] not in self.cnames:\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\n else:\n if reg[4].strip() != 'ASX':\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]","def _generate_flow_xml(self):\n model = self.model\n\n flow_dict = OrderedDict()\n flow_dict['oml:flow'] = OrderedDict()\n flow_dict['oml:flow']['@xmlns:oml'] = 'http://openml.org/openml'\n flow_dict['oml:flow']['oml:name'] = self._get_name()\n flow_dict['oml:flow']['oml:external_version'] = self.external_version\n flow_dict['oml:flow']['oml:description'] = self.description\n\n clf_params = model.get_params()\n flow_parameters = []\n for k, v in clf_params.items():\n # data_type, default_value, description, recommendedRange\n # type = v.__class__.__name__ Not using this because it doesn't conform standards\n # eg. int instead of integer\n param_dict = {'oml:name': k}\n flow_parameters.append(param_dict)\n\n flow_dict['oml:flow']['oml:parameter'] = flow_parameters\n\n flow_xml = xmltodict.unparse(flow_dict, pretty=True)\n\n # A flow may not be uploaded with the encoding specification..\n flow_xml = flow_xml.split('\\n', 1)[-1]\n return flow_xml","def init(self, *, flow: int = -1) -> int:","def update_species_frames(self):\n pass","def __init__(self, name, f):\r\n self.FailedIds = []\r\n self.Name = name\r\n self.F = f","def _process_name(self):\n if not isinstance(self.transform, GroupTransformModel):\n return\n\n name = self._transform_value(self.transform.name)\n\n if name is None:\n self.log.error(\n 'feature=ti-transform, event=process-group-name, message=no-name-found, '\n f'path={self.transform.name.path}'\n )\n raise RuntimeError('At least one indicator value must be provided.')\n\n self.add_name(name)","def __init__(self, name, pre_action_des, in_action_des, post_action_des, actionable, usable, state, feature_id):\n self.name = name\n self.pre_action_des = pre_action_des\n self.in_action_des = in_action_des\n self.post_action_des = post_action_des\n self.actionable = actionable\n self.usable = usable\n self.state = state\n self.feature_id = feature_id","def create_flow(self, conf, dpid, params):\n\t\tpass","def _fix_chainID(self):\n\n from string import ascii_uppercase\n\n # get the current names\n data = self.get('chainID')\n natom = len(data)\n\n #get uniques\n chainID = []\n for c in data:\n if c not in chainID:\n chainID.append(c)\n\n if chainID == ['A','B']:\n return\n\n if len(chainID)>26:\n print(\"Warning more than 26 chains have been detected. This is so far not supported\")\n sys.exit()\n\n # declare the new names\n newID = [''] * natom\n\n # fill in the new names\n for ic,chain in enumerate(chainID):\n index = self.get('rowID',chainID=chain)\n for ind in index:\n newID[ind] = ascii_uppercase[ic]\n\n # update the new name\n self.update_column('chainID',newID)","def formal_step(self):\n return f\"Added the obstructions {self.new_obs()}.\"","def _add_to_existing_flowable(self, fb, new_terms):\n biog = ('124-38-9' in fb)\n for term in new_terms:\n self._fm.add_synonym(fb, term)\n if biog and bool(biogenic.search(term)):\n self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym","def __init__(self, name='Custom_Q1'):\n self.equity_alive = 0\n self.actions = []\n self.last_action_in_stage = ''\n self.temp_stack = []\n self.name = name\n self.autoplay = True\n self.model = None","def _augment_pipeline_cfg(self):","def __init__(self, cfg, tops_type=[3, 5, 10]):\n\n attr_cloth_file = open(cfg.attr_cloth_file).readlines()\n self.attr_idx2name = {}\n for i, line in enumerate(attr_cloth_file[2:]):\n self.attr_idx2name[i] = line.strip('\\n').split()[0]","def __init__(self, incomings, a=tf.identity, name='ConcatLayer'):\n super(ConcatLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incomings = []\n self.incoming_shapes = []\n \n for incoming in incomings:\n incoming, incoming_shape = get_input(incoming)\n self.incomings.append(incoming)\n self.incoming_shapes.append(incoming_shape)\n self.name = name\n self.a = a","def __init__(self):\n self.name = ''\n self.variables = []\n self.assumptions = []\n self.guarantees = []","def fix_label_names():\n\n assert trace.cpu.trace_done\n binary_addr = memorymanager.BinaryAddr(0)\n while binary_addr < len(classifications):\n c = classifications[binary_addr]\n if c is not None:\n dummy = [str(x) for x in c.as_string_list(binary_addr, None)]\n binary_addr += c.length()\n else:\n binary_addr += 1","def __init__(self, name, bases):\n self.name = name\n self.bases = bases","def __init__(self,path_exp,path_forcing=None,globaldata=None,refetch_records=False,end_state=True,refetch_stations=True,inputkeys = ['cveg','wg','w2','cc','sp','wwilt','Tsoil','T2','z0m','alpha','LAI',],obs_filter=False,tendencies_revised=False):\n \n # set the ground\n self.globaldata = globaldata\n\n \n self.obs_filter = obs_filter\n print(self.obs_filter)\n self.tendencies_revised = tendencies_revised\n self.path_exp = path_exp\n self.path_forcing = path_forcing\n self.end_state = end_state\n self.exp_files = glob.glob(self.path_exp+'/?????.yaml')\n\n # # get the list of stations\n # stationsfile = self.path_exp+'/stations_list.csv'\n # if (os.path.isfile(stationsfile)) and (not refetch_stations):\n # stations = pd.read_csv(stationsfile)\n # else:\n # stations = get_stations(self.path_exp)\n # stations.to_csv(stationsfile)\n\n # stations = stations.set_index('STNID')\n\n self.frames = {}\n\n self.frames['stats'] = {}\n self.frames['worldmap'] = {}\n \n self.frames['profiles'] = {}\n self.frames['profiles'] = {}\n self.frames['profiles']['DT'] = None\n self.frames['profiles']['STNID'] = None\n\n #self.frames['worldmap']['stationsfile'] = stationsfile\n self.frames['worldmap']['stations'] = stations(self.path_exp, \\\n suffix='ini',\\\n refetch_stations=refetch_stations)\n\n # Initially, the stats frame inherets the values/iterators of\n # worldmap\n for key in self.frames['worldmap'].keys():\n self.frames['stats'][key] = self.frames['worldmap'][key]\n\n # get its records and load it into the stats frame\n self.frames['stats']['records_all_stations_ini'] =\\\n get_records(self.frames['stats']['stations'].table,\\\n self.path_exp,\\\n subset='ini',\\\n refetch_records=refetch_records\n )\n print(self.frames['stats']['records_all_stations_ini'])\n # get its records and load it into the stats frame\n\n\n self.frames['stats']['records_all_stations_end_mod'] =\\\n get_records(self.frames['stats']['stations'].table,\\\n self.path_exp,\\\n subset='end',\\\n refetch_records=refetch_records\n )\n\n if self.path_forcing is not None:\n # get its records and load it into the stats frame\n self.frames['stats']['records_all_stations_end_obs'] =\\\n get_records(self.frames['stats']['stations'].table,\\\n self.path_forcing,\\\n subset='end',\\\n refetch_records=refetch_records\n )\n if self.end_state:\n if len(self.frames['stats']['records_all_stations_end_mod']) == 0:\n raise IOError ('No end state records found. If you want to ignore end states, please use the option end_state = False')\n self.frames['stats']['records_all_stations_end_mod'].index = \\\n self.frames['stats']['records_all_stations_ini'].index \n\n else:\n self.frames['stats']['records_all_stations_end_mod'] = \\\n self.frames['stats']['records_all_stations_ini']\n\n \n if len(self.frames['stats']['records_all_stations_ini']) ==0:\n raise ValueError('no class records found. Aborting')\n\n self.frames['stats']['records_all_stations_ini']['dates'] = \\\n self.frames['stats']['records_all_stations_ini']['ldatetime'].dt.date\n\n if self.path_forcing is not None:\n self.frames['stats']['records_all_stations_end_obs']['dates'] = \\\n self.frames['stats']['records_all_stations_end_obs']['ldatetime'].dt.date\n\n self.frames['stats']['records_all_stations_end_obs'].set_index(['STNID','dates'],inplace=True)\n\n\n ini_index_dates = self.frames['stats']['records_all_stations_ini'].set_index(['STNID','dates']).index\n\n self.frames['stats']['records_all_stations_end_obs'] = \\\n self.frames['stats']['records_all_stations_end_obs'].loc[ini_index_dates]\n\n self.frames['stats']['records_all_stations_end_obs'].index = \\\n self.frames['stats']['records_all_stations_ini'].index \n\n self.frames['stats']['viewkeys'] = ['h','theta','q']\n print('Calculating table statistics')\n\n if self.tendencies_revised:\n self.frames['stats']['records_all_stations_end_mod_stats'] = \\\n tendencies_rev(self.frames['stats']['records_all_stations_end_mod'],\\\n self.frames['stats']['records_all_stations_ini'],\\\n self.frames['stats']['viewkeys']\\\n )\n self.frames['stats']['records_all_stations_end_obs_stats'] = \\\n tendencies_rev(self.frames['stats']['records_all_stations_end_obs'],\\\n self.frames['stats']['records_all_stations_ini'],\\\n self.frames['stats']['viewkeys']\\\n )\n\n else:\n self.frames['stats']['records_all_stations_end_mod_stats'] = \\\n tendencies(self.frames['stats']['records_all_stations_end_mod'],\\\n self.frames['stats']['records_all_stations_end_obs'],\\\n self.frames['stats']['records_all_stations_ini'],\\\n self.frames['stats']['viewkeys']\\\n )\n self.frames['stats']['records_all_stations_end_obs_stats'] = \\\n tendencies(self.frames['stats']['records_all_stations_end_obs'],\\\n self.frames['stats']['records_all_stations_end_obs'],\\\n self.frames['stats']['records_all_stations_ini'],\\\n self.frames['stats']['viewkeys']\\\n )\n\n self.frames['stats']['inputkeys'] = inputkeys\n \n # self.frames['stats']['inputkeys'] = \\\n # [ key for key in \\\n # self.globaldata.datasets.keys() \\\n # if key in \\\n # list(self.frames['stats']['records_all_stations_obs'].columns)]\n\n\n # get units from the class4gl units database\n self.units = dict(units)\n # for those that don't have a definition yet, we just ask a question\n # mark\n for var in self.frames['stats']['inputkeys']:\n self.units[var] = '?'\n\n self.frames['worldmap']['inputkeys'] = self.frames['stats']['inputkeys'] \n self.frames['stats']['records_all_stations_ini_pct'] = \\\n pct(self.frames['stats']['records_all_stations_ini'], \\\n columns = self.frames['stats']['inputkeys'])\n\n # pd.DataFrame(columns = self.frames['stats']['viewkeys'])\n # for ikey,key in enumerate(self.frames['stats']['viewkeys']):\n # mod['\n\n # \n # \n # \\\n # self.frames['stats']['records_all_stations_end_mod'], \\\n\n\n\n # self.frames['stats']['records_all_stations_end_mod_stats_stdrel'] = \\\n # stdrel(mod = self.frames['stats']['records_all_stations_end_mod_stats'], \\\n # obs = self.frames['stats']['records_all_stations_end_obs_stats'], \\\n # columns = [ 'd'+key+'dt' for key in \\\n # self.frames['stats']['viewkeys']], \\\n # )\n\n # self.frames['stats']['records_all_stations_end_obs_stats_stdrel'] = \\\n # stdrel(mod = self.frames['stats']['records_all_stations_ini'], \\\n # obs = self.frames['stats']['records_all_stations_ini'], \\\n # columns = self.frames['stats']['viewkeys'], \\\n # )\n\n \n\n if self.path_forcing is not None:\n print('filtering pathological data')\n indextype = self.frames['stats']['records_all_stations_end_mod_stats'].index.names\n # some observational sounding still seem problematic, which needs to be\n # investigated. In the meantime, we filter them\n\n print('hello',self.obs_filter)\n print ((self.path_forcing is not None) and (self.obs_filter))\n if ((self.path_forcing is not None) and (self.obs_filter)) is True:\n print('hallohallo')\n if ((self.path_forcing is not None) and (self.obs_filter)) is True:\n print('exclude exceptional observations')\n print('exclude unrealistic model output -> should be investigated!')\n valid = (\\\n (self.frames['stats']['records_all_stations_end_mod'].theta > 273.) & \n (self.frames['stats']['records_all_stations_end_obs'].theta > 273.) & \n #(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.25) & \n (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.) & \n #(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > 0.25000) & \n #(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 1.8000) & \n # (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 2.0000) & \n #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 50.0000) & \n (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt > 0.0000) & \n # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 400.) & \n # (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt < 350.) & \n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < .0003) & \n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt > -.0006) & \n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < .0003) & \n\n # filter 'extreme' model output -> should be investigated!\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0006) & \n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt > -.0006) & \n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .0) & \n # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 40.) & \n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .0) & \n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 2.3) & \n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0003) & \n # (self.frames['stats']['records_all_stations_ini'].KGC != 'Cwb') & \n # (self.frames['stats']['records_all_stations_ini'].KGC != 'Dfc') & \n ~np.isnan(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt) & \n ~np.isnan(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt))\n# \n# \n# \n# \n# # (self.frames['stats']['records_all_stations_ini'].lat >-2. ) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.00) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.25000) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 3.0000) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 1.8000) & \n# #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 50.0000) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt > 40.0000) & \n# #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 350.) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt < 450.) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt > -0.0006) & \n# (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < 0.0003) & \n# # ((self.frames['stats']['records_all_stations_ini'].ldatetime-\n# # self.frames['stats']['records_all_stations_ini'].lSunset).total_seconds()\n# # <= -2.*3600.) & \n# # filter 'extreme' model output -> should be investigated!\n# (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0005) & \n# (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt > -.0006) & \n# (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .2) & \n# (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 2.) & \n# # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 400.) & \n# # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0003) & \n# # (self.frames['stats']['records_all_stations_ini'].KGC != 'Cwb') & \n# # (self.frames['stats']['records_all_stations_ini'].KGC != 'Dfc') & \n# ~np.isnan(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt) & \n# ~np.isnan(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt))\n\n for key in self.frames['stats'].keys():\n if (type(self.frames['stats'][key]) == pd.DataFrame) and \\\n (self.frames['stats'][key].index.names == indextype):\n self.frames['stats'][key] = self.frames['stats'][key][valid]\n print(\"WARNING WARNING!: \"+ str(len(valid) - np.sum(valid))+' soundings are filtered')\n\n self.frames['stats']['records_all_stations_index'] = self.frames['stats']['records_all_stations_end_mod'].index\n\n\n print(\"filtering stations from interface that have no records\")\n for STNID,station in self.frames['worldmap']['stations'].table.iterrows():\n if ((self.frames['stats']['records_all_stations_index'].get_level_values('STNID')\\\n == STNID).sum() == 0):\n print(\"dropping\", STNID)\n self.frames['worldmap']['stations'].table = \\\n self.frames['worldmap']['stations'].table.drop(STNID)\n \n self.frames['worldmap']['stations_iterator'] = stations_iterator(self.frames['worldmap']['stations']) \n \n # TO TEST: should be removed, since it's is also done just below\n self.frames['stats']['stations_iterator'] = \\\n self.frames['worldmap']['stations_iterator'] \n\n self.frames['worldmap']['inputkey'] = self.frames['worldmap']['inputkeys'][0]\n self.frames['worldmap']['inputkey'] = self.frames['worldmap']['inputkey']\n self.next_station()\n\n # self.goto_datetime_worldmap(\n # self.frames['profiles']['current_record_obs'].datetime.to_pydatetime(),\n # 'after')","def get_param_names(self):\n # Sort the FIO parameter names to generate consistent fio commands\n all_param_names = super(FioCommand, self).get_param_names()\n # move the 'name' option as the first option of fio job\n all_param_names.remove(\"name\")\n all_param_names.insert(0, \"name\")\n\n return all_param_names","def change_names (fixed_structure, moving_structure, index):\n for chain in moving_structure[0]:\n chain.id = utilities.merged_list[index]+\"-\"+chain.id\n index +=1\n return (fixed_structure, moving_structure, index)","def _break_pipeline_cfg(self):","def names():\n pass","def __init__(self, name):\n\n self.name = name\n self.rules = []\n self._watched_files = []"],"string":"[\n \"def _dup_pipeline_name_cfg(self):\",\n \"def _configure_flowables(self, flowables):\\n if flowables is None:\\n flowables = DEFAULT_FLOWABLES\\n\\n # FlowablesDict-- mainly to upsample CAS numbers for matching\\n self._fm = FlowablesDict()\\n\\n self._fm.new_entry('carbon dioxide', '124-38-9')\\n self._fm.new_entry('Water', '7732-18-5')\\n # we store the child object and use it to signify biogenic CO2 to optionally quell\\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\\n\\n # now load + merge from file\\n self._fm.load(flowables)\\n\\n # now add all known \\\"biotic\\\" synonyms for CO2 to the biotic child\\n for k in self._fm.synonyms('124-38-9'):\\n if bool(biogenic.search(k)):\\n self._bio_co2.add_term(k)\\n self._fq_map = {fb: set() for fb in self._fm.objects}\",\n \"def add_flow(self, flow: \\\"Flow\\\") -> str:\\n self.flows = {flow.name: flow.name} # type: Dict[str, str]\\n self._flows = {flow.name: flow} # type: Dict[str, Flow]\\n return flow.name\",\n \"def test_update_flow_classifier_name(self):\\n resource = 'flow_classifier'\\n cmd = fc.FlowClassifierUpdate(test_cli20.MyApp(sys.stdout), None)\\n self._test_update_resource(resource, cmd, 'myid',\\n ['myid', '--name', 'myname'],\\n {'name': 'myname'})\",\n \"def __init__(self, lines=[], people=[], name=''):\\n\\n self.name=repr(name)\\n self.relable=defaultdict(str)\\n self.people=set(people + self.keys())\\n self.new_names=list(set(people)-set(self.keys())) #New People being added.\\n self.process_lines(lines)\\n self.concepts=set(self.relable.keys())\\n# have to store all concepts and then check for each concept (before adding it to a causal graph) if it already exists in the set or not; if it exists, I find the representative label with which it is labelled in the first causal graph to which it was added. Also, this set of concepts is the raw material of the data set of concepts wherein 3000 or so concepts that are identical in meaning are paired by hand and then a machiene learning algorithm will be trained on the training set (the first x paired concepts) to learn which concepts are in meaning identical. Later, the causal-belief-graphs will be simplified, using this tool. The concepts are also stored in each node, under the key \\\"concept\\\". The greatest advantage of using networkx is that all kinds of information, including affective information, can be stored in each link and each concept, making these cognitive maps greatly extendable beyond the causal!\\n\\n for name in self.new_names:\\n self[name]=CausalGraph()\",\n \"def setCaptainNames(self):\\n self.captainNames = anwp.func.names.getNames('system_names.txt',self.maxCaptainNames+100, self.rand.randint(1,100))\\n self.currentCaptainName = 0\",\n \"def __init__(self):\\n self._names = []\\n self._forwardFactories = []\\n self._inputs = []\\n self._inputFilters = {}\\n self._outputFilters = []\\n self._inputCheckers = []\\n pass\",\n \"def _genBlocksByName(self):\\n self.blocksByName = {\\n block.getName(): block for block in self.getBlocks(includeAll=True)\\n }\",\n \"def _initNames(self):\\n self.outselect = os.path.join(self.workpath, 'FT1_selected'+self.suffix+'.fits')\\n self.outmktime = os.path.join(self.workpath, 'FT1_filtered'+self.suffix+'.fits')\\n self.outltcube = os.path.join(self.workpath, 'LtCube'+self.suffix+'.fits')\\n self.outbincub = os.path.join(self.workpath, 'BinCube'+self.suffix+'.fits')\\n self.outbinmap = os.path.join(self.workpath, 'CMAP'+self.suffix+'.fits')\\n self.outbinexp = os.path.join(self.workpath, 'BinExpMap'+self.suffix+'.fits')\\n self.outexpmap = os.path.join(self.workpath, 'ExpMap'+self.suffix+'.fits')\\n self.outsrcmap = os.path.join(self.workpath, 'SrcMaps'+self.suffix+'.fits')\\n self.outgtlike = os.path.join(self.workpath, 'Results'+self.suffix+'.dat')\\n self.outmodel = os.path.join(self.workpath, 'OutModel'+self.suffix+'.xml')\\n self.outapert = os.path.join(self.workpath, 'LC_ApPhoto'+self.suffix+'.fits')\\n self.outgtmod = os.path.join(self.workpath, 'GtModel'+self.suffix+'.fits')\\n self.outresid = os.path.join(self.workpath, 'Resid'+self.suffix+'.fits')\\n self.outresig = os.path.join(self.workpath, 'ResSigma'+self.suffix+'.fits')\\n self.outtsmap = os.path.join(self.workpath, 'TSMmap'+self.suffix+'.fits')\\n return\\n # self.outfind = self.dir + self.src + '_FindSrc'+self.suffix+'.txt'\",\n \"def init_name(self):\\r\\n try:\\r\\n rval = self.name\\r\\n except AttributeError:\\r\\n if 0:\\r\\n l = []\\r\\n for n in self.fgraph.toposort():\\r\\n if hasattr(n.op, \\\"name\\\") and n.op.name is not None:\\r\\n v = n.op.name\\r\\n if v.startswith(\\\"Composite\\\"):\\r\\n v = v[len(\\\"Composite\\\"):]\\r\\n else:\\r\\n v = n.op.__class__.__name__\\r\\n l.append(v)\\r\\n rval = \\\"Composite{\\\" + \\\",\\\".join(l) + \\\"}\\\"\\r\\n else:\\r\\n for i, r in enumerate(self.fgraph.inputs):\\r\\n r.name = 'i%i' % i\\r\\n for i, r in enumerate(self.fgraph.outputs):\\r\\n r.name = 'o%i' % i\\r\\n io = set(self.fgraph.inputs + self.fgraph.outputs)\\r\\n for i, r in enumerate(self.fgraph.variables):\\r\\n if r not in io and len(r.clients) > 1:\\r\\n r.name = 't%i' % i\\r\\n rval = \\\"Composite{%s}\\\" % str(self.fgraph)\\r\\n self.name = rval\",\n \"def setup(self):\\n ### Set Names\\n # Name of the pipeline reduction step\\n self.name='sortobs'\\n # Shortcut for pipeline reduction step and identifier for\\n # saved file names.\\n self.procname = 'RAW'\\n # Set Logger for this pipe step\\n self.log = logging.getLogger('pipe.step.%s' % self.name)\\n ### Set Parameter list\\n # Clear Parameter list\\n self.paramlist = []\\n # Append Parameters\\n self.paramlist.append(['pattern', '(^.+_([gri]-band|oiii|sii|clear|h-alpha))',\\n 'Regex pattern used to get name by matching name_filter'])\\n # Confirm end of setup\\n self.log.debug('Setup: done')\",\n \"def __addNewASG2Tracker( self, metaModelName, ASGgraph ): \\r\\n self.__trackASG[ self.__sanitizeMetaModelName( metaModelName ) ] = \\\\\\r\\n [ASGgraph, cloningMachine(ASGgraph.nodeTypes)]\",\n \"def _get_next_name(self, flow):\\n parent_ref = '%s ASSEMBLY' % flow.external_ref\\n try:\\n self.fg.get(parent_ref)\\n except EntityNotFound:\\n return parent_ref\\n _ac = 0\\n while True:\\n parent_ref = '%s ASSEMBLY alt %d' % (flow.external_ref, _ac)\\n try:\\n self.fg.get(parent_ref)\\n _ac += 1\\n except EntityNotFound:\\n return parent_ref\",\n \"def __init__(self) -> None:\\n super().__init__()\\n self._flows = {} # type: Dict[str, str]\",\n \"def update_flow(self, flow):\\r\\n self.flow = flow\",\n \"def normalize(self):\\n\\n # modify from this:\\n #\\n # \\\"workflow\\\": {\\n # \\\"test-and-deploy\\\": {\\n # \\\"resolves\\\": \\\"deploy\\\"\\n # }\\n # }\\n #\\n # to this:\\n #\\n # \\\"workflow\\\": {\\n # \\\"name\\\": \\\"test-and-deploy\\\",\\n # \\\"on\\\": \\\"push\\\",\\n # \\\"resolves\\\": \\\"deploy\\\"\\n # }\\n for wf_name, wf_block in dict(self.wf['workflow']).items():\\n self.wf['name'] = wf_name\\n self.wf['on'] = wf_block.get('on', 'push')\\n self.wf['resolves'] = wf_block['resolves']\\n\\n # python 2 to 3 compatibility\\n try:\\n basestring\\n except UnboundLocalError:\\n basestring = str\\n\\n # create a list for all attributes that can be either string or list\\n if isinstance(self.wf['resolves'], basestring):\\n self.wf['resolves'] = [self.wf['resolves']]\\n elif not self.is_list_of_strings(self.wf['resolves']):\\n pu.fail('[resolves] must be a list of strings or a string\\\\n')\\n if not isinstance(self.wf['on'], basestring):\\n pu.fail('[on] attribute must be a string\\\\n')\\n for _, a_block in self.wf['action'].items():\\n if not isinstance(a_block['uses'], basestring):\\n pu.fail('[uses] attribute must be a string\\\\n')\\n if a_block.get('needs', None):\\n if isinstance(a_block['needs'], basestring):\\n a_block['needs'] = [a_block['needs']]\\n elif not self.is_list_of_strings(a_block['needs']):\\n pu.fail(\\n '[needs] attribute must be a list of strings \\\\\\n or a string\\\\n')\\n if a_block.get('runs', None):\\n if isinstance(a_block['runs'], basestring):\\n a_block['runs'] = [a_block['runs']]\\n elif not self.is_list_of_strings(a_block['runs']):\\n pu.fail(\\n '[runs] attribute must be a list of strings \\\\\\n or a string\\\\n')\\n if a_block.get('args', None):\\n if isinstance(a_block['args'], basestring):\\n a_block['args'] = a_block['args'].split()\\n elif not self.is_list_of_strings(a_block['args']):\\n pu.fail(\\n '[args] attribute must be a list of strings \\\\\\n or a string\\\\n')\\n if a_block.get('env', None):\\n if not isinstance(a_block['env'], dict):\\n pu.fail('[env] attribute must be a dict\\\\n')\\n if a_block.get('secrets', None):\\n if not self.is_list_of_strings(a_block['secrets']):\\n pu.fail('[secrets] attribute must be a list of strings\\\\n')\",\n \"def __init__(self, name):\\n self.name = name\\n self._edges = []\",\n \"def pipeline_name_conventions(self):\\n passed = []\\n warned = []\\n failed = []\\n\\n if self.pipeline_name.islower() and self.pipeline_name.isalnum():\\n passed.append(\\\"Name adheres to nf-core convention\\\")\\n if not self.pipeline_name.islower():\\n warned.append(\\\"Naming does not adhere to nf-core conventions: Contains uppercase letters\\\")\\n if not self.pipeline_name.isalnum():\\n warned.append(\\\"Naming does not adhere to nf-core conventions: Contains non alphanumeric characters\\\")\\n\\n return {\\\"passed\\\": passed, \\\"warned\\\": warned, \\\"failed\\\": failed}\",\n \"def generateTaskName(self):\\n brokenComponent = ['head','hand','leg','body','hand','leg']\\n for component in brokenComponent:\\n self.enqueue(Task(component))\",\n \"def __init__(self, name):\\n self._name = name\\n self._arcsFrom = set()\\n self._arcsTo = set()\",\n \"def __init__(self, file_benign, file_unknown):\\n # Load data\\n self.data_benign = self.load(file_benign)\\n self.data_unknown = self.load(file_unknown)\\n\\n # Transform to flows\\n self.flows_benign , self.labels_benign = self.flows(self.data_benign )\\n self.flows_unknown, self.labels_unknown = self.flows(self.data_unknown)\",\n \"def resolveNames(self):\\n client.resolveNames(self)\\n # TODO: Do any name resolutions here.\\n # The names of other objects this object refers to, either intrinsically or in its parameters, should be checked here.\",\n \"def flow_name(self):\\n # This never changes (so no read locking needed).\\n return self._flowdetail.name\",\n \"def _name_changed(self):\\n self._named = True\",\n \"def populate_with_empty_descriptions(self):\\n for baction in self.behaviour():\\n if isinstance(baction, Behaviour) and not baction.description:\\n desc = baction.kind(baction.name)\\n self[baction.name] = desc\",\n \"def test_device_states_device_name_put(self):\\n pass\",\n \"def __init__(\\n self, name: str, first_phase: str, inherits: Optional[str] = None\\n ) -> None:\\n self.name = name\\n self.first_phase = first_phase\\n self.inherits = inherits\",\n \"def doName(self):\\n _short = self.p_nameShort\\n _str_func = '[{0}] doName'.format(_short)\\n log.debug(cgmGEN.logString_start(_str_func))\\n\\n _d = NAMETOOLS.returnObjectGeneratedNameDict(_short)\\n\\n _direction = self.getEnumValueString('side')\\n if _direction != 'none':\\n log.debug(\\\"|{0}| >> direction: {1}\\\".format(_str_func,_direction))\\n _d['cgmDirection'] = _direction \\n self.doStore('cgmDirection',_direction)\\n else:\\n if _d.get('cgmDirection'):_d.pop('cgmDirection')\\n self.doStore('cgmDirection','')\\n log.debug(\\\"|{0}| >> cgmDirection: {1}\\\".format(_str_func,self.cgmDirection))\\n \\n\\n _position = self.getMayaAttr('position')#self.getEnumValueString('position')\\n if _position and _position != '':\\n _d['cgmPosition'] = _position \\n self.doStore('cgmPosition',_position)\\n else:self.cgmPosition = ''\\n\\n #Get Raw name\\n\\n for a in 'cgmName','baseName','puppetName',:\\n if self.hasAttr(a):\\n _d['cgmName'] = ATTR.get(_short,a)\\n continue\\n \\\"\\\"\\\"\\n if self.hasAttr('blockProfile'):\\n _blockProfile = self.getMayaAttr('blockProfile') or ''\\n if _d.get('cgmName','') not in _blockProfile:\\n #if _d.get('cgmName','') in _blockProfile:\\n _blockProfile = _blockProfile.replace(_d['cgmName'],'')\\n if len(_blockProfile):\\n _d['cgmNameModifier'] = STR.camelCase(_blockProfile)\\n \\\"\\\"\\\"\\n _blockType = ATTR.get(_short,'blockType')\\n _d['cgmType'] = _blockType + 'Block'\\n \\n pprint.pprint(_d)\\n \\\"\\\"\\\"\\n if self.getMayaAttr('position'):\\n _d['cgmPosition'] = self.getEnumValueString('position')\\n if self.getMayaAttr('side'):\\n _value = self.getEnumValueString('side')\\n _d['cgmDirection'] = _value\\n self.doStore('cgmDirection',_value)\\\"\\\"\\\"\\n #pprint.pprint(vars())\\n #Check for special attributes to replace data, name\\n _d_new = {}\\n for k,v in _d.iteritems():\\n if v in ['none','None','NONE',None]:\\n continue\\n _d_new[k] = v\\n log.debug(\\\"|{0}| >> dict: {1}\\\".format(_str_func,_d_new))\\n self.rename(NAMETOOLS.returnCombinedNameFromDict(_d_new))\\n \\n \\n if self.getMessage('moduleTarget'):\\n log.debug(\\\"|{0}| >> Module target naming...\\\".format(_str_func)) \\n self.moduleTarget.doName()\\n \\n \\n ml_objs = get_blockDagNodes(self)\\n for mObj in ml_objs:\\n if mObj != self:\\n mObj.doName()\\n \\n for plug in ['formNull','noTransFormNull',\\n 'prerigNull','noTransPrerigNull',\\n 'defineNull','noTransDefineNull',\\n 'moduleTarget']:\\n mPlug = self.getMessageAsMeta(plug)\\n if mPlug:\\n mPlug.doName()\",\n \"def __init__(self, name):\\n composites.Composite.__init__(self, name)\\n self.p.flags = Flags.fromStringIgnoreErrors(name)\\n self.assembliesByName = {}\\n self.circularRingList = {}\\n self.blocksByName = {} # lookup tables\\n self.numRings = 0\\n self.spatialGrid = None\\n self.xsIndex = {}\\n self.p.numMoves = 0\\n self._lib = None # placeholder for ISOTXS object\\n self.locParams = {} # location-based parameters\\n # overridden in case.py to include pre-reactor time.\\n self.timeOfStart = time.time()\\n self.zones = zones.Zones() # initialize with empty Zones object\\n # initialize the list that holds all shuffles\\n self.moveList = {}\\n self.scalarVals = {}\\n self._nuclideCategories = {}\\n self.typeList = [] # list of block types to convert name - to -number.\\n\\n # leftover default \\\"settings\\\" that are intended to eventually be elsewhere.\\n self._freshFeedType = \\\"feed fuel\\\"\\n self._trackAssems = False\\n self._circularRingMode = False\\n self._circularRingPitch = 1.0\\n self._automaticVariableMesh = False\\n self._minMeshSizeRatio = 0.15\\n self._detailedAxialExpansion = False\",\n \"def input_names(self):\\n raise NotImplementedError(\\n 'Derived ExternalGreyBoxModel classes need to implement the method: input_names'\\n )\",\n \"def _maybe_set_name(self) -> None:\\n if not self.name:\\n if isinstance(self.github, dict):\\n if self.github.get(\\\"commit\\\"):\\n self.name = f\\\"{self.reason}: {self.github['commit']}\\\"\",\n \"def __init__(self, name):\\n self.name = name\\n self.atoms = {}\",\n \"def setUpFormData(self):\\n super(InconsistentNameCSID, self).setUpFormData()\\n self.formData['name'] = 'Pyrazine'\",\n \"def __init__(__self__, *,\\n name: pulumi.Input[str]):\\n pulumi.set(__self__, \\\"name\\\", name)\",\n \"def __init__(self, type, name, verbose):\\n self._name = name\\n self._verbose = verbose\\n self.__fdev_id = _cantera.flowdev_new(type)\",\n \"def new_flow(self, data):\\n\\n try:\\n self.logger.debug(\\\"new_flow data: {}\\\".format(data))\\n if len(self.pp2ofi) == 0:\\n self.obtain_port_correspondence()\\n\\n # We have to build the data for the opendaylight call from the generic data\\n flow = {\\n 'id': data['name'],\\n 'flow-name': data['name'],\\n 'idle-timeout': 0,\\n 'hard-timeout': 0,\\n 'table_id': 0,\\n 'priority': data.get('priority'),\\n 'match': {}\\n }\\n sdata = {'flow-node-inventory:flow': [flow]}\\n if not data['ingress_port'] in self.pp2ofi:\\n error_text = 'Error. Port ' + data['ingress_port'] + ' is not present in the switch'\\n self.logger.warning(\\\"new_flow \\\" + error_text)\\n raise OpenflowConnUnexpectedResponse(error_text)\\n flow['match']['in-port'] = self.pp2ofi[data['ingress_port']]\\n if data.get('dst_mac'):\\n flow['match']['ethernet-match'] = {\\n 'ethernet-destination': {'address': data['dst_mac']}\\n }\\n if data.get('vlan_id'):\\n flow['match']['vlan-match'] = {\\n 'vlan-id': {\\n 'vlan-id-present': True,\\n 'vlan-id': int(data['vlan_id'])\\n }\\n }\\n actions = []\\n flow['instructions'] = {\\n 'instruction': [{\\n 'order': 1,\\n 'apply-actions': {'action': actions}\\n }]\\n }\\n\\n order = 0\\n for action in data['actions']:\\n new_action = {'order': order}\\n if action[0] == \\\"vlan\\\":\\n if action[1] is None:\\n # strip vlan\\n new_action['strip-vlan-action'] = {}\\n else:\\n new_action['set-field'] = {\\n 'vlan-match': {\\n 'vlan-id': {\\n 'vlan-id-present': True,\\n 'vlan-id': int(action[1])\\n }\\n }\\n }\\n elif action[0] == 'out':\\n new_action['output-action'] = {}\\n if not action[1] in self.pp2ofi:\\n error_msg = 'Port ' + action[1] + ' is not present in the switch'\\n raise OpenflowConnUnexpectedResponse(error_msg)\\n\\n new_action['output-action']['output-node-connector'] = self.pp2ofi[action[1]]\\n else:\\n error_msg = \\\"Unknown item '{}' in action list\\\".format(action[0])\\n self.logger.error(\\\"new_flow \\\" + error_msg)\\n raise OpenflowConnUnexpectedResponse(error_msg)\\n\\n actions.append(new_action)\\n order += 1\\n\\n # print json.dumps(sdata)\\n of_response = requests.put(self.url + \\\"restconf/config/opendaylight-inventory:nodes/node/\\\" + self.id +\\n \\\"/table/0/flow/\\\" + data['name'], headers=self.headers, data=json.dumps(sdata))\\n error_text = \\\"Openflow response {}: {}\\\".format(of_response.status_code, of_response.text)\\n if of_response.status_code != 200:\\n self.logger.warning(\\\"new_flow \\\" + error_text)\\n raise OpenflowConnUnexpectedResponse(error_text)\\n self.logger.debug(\\\"new_flow OK \\\" + error_text)\\n return None\\n\\n except requests.exceptions.RequestException as e:\\n # raise an exception in case of contection error\\n error_text = type(e).__name__ + \\\": \\\" + str(e)\\n self.logger.error(\\\"new_flow \\\" + error_text)\\n raise OpenflowConnConnectionException(error_text)\",\n \"def __init__(self, name, direction, core):\\n self.name = name\\n self.direction = direction\\n self.signals = {}\\n self.core = core\\n self.endpoints = []\\n self.interface_type = None\",\n \"def __init__(self,\\r\\n name: str,\\r\\n pipeline: PipelineBase,\\r\\n is_deterministic: bool = True):\\r\\n self.name = name\\r\\n self.is_deterministic = is_deterministic\\r\\n self.pipeline = pipeline\",\n \"def __init__(self, name):\\r\\n super(Structure, self).__init__()\\r\\n self.name = name\",\n \"def __init__(self, manager, name):\\n FarmDescriptor.__init__(self,manager,'Trigger')\\n #Online.DatapointLoader.DatapointLoader.__init__(self,manager,name)\\n self.typeMgr = self.manager.typeMgr()\\n setup = 'RECO'\\n setup = 'ONLINE'\\n if setup=='RECO':\\n self.allocatePartition = self.allocRecoPartition\\n self.getPartition = self.getRecoPartition\\n self.freePartition = self.freeRecoPartition\\n self.loadRunInfo = self.loadRecoRunInfo\\n self.runInfo_type = self.typeMgr.type('RunFarmInfo')\\n self.runinfos = Online.PVSS.DpVectorActor(self.manager)\\n self.runinfos.lookupOriginal(self.name+'_Farm??.general.partName',self.runInfo_type)\\n else:\\n self.allocatePartition = self.allocateSlice\\n self.getPartition = self.getSlice\\n self.freePartition = self.freeSlice\\n self.loadRunInfo = self.loadRecoRunInfo\\n self.sliceType = self.typeMgr.type('FarmSlice')\\n self.runInfo_type = self.typeMgr.type('FarmRunInfo')\\n \\n self.writer = self.manager.devWriter()\\n self.fsm_typ = self.typeMgr.type('_FwFsmDevice')\\n subinfo_typ = self.typeMgr.type('FarmSubInfo')\\n self.allsubfarms = Online.PVSS.DpVectorActor(self.manager)\\n self.allsubfarms.lookupOriginal(self.name+'_*.UsedBy',subinfo_typ)\",\n \"def __init__(self,name,direction=RIGHT,isFinal=False):\\n\\t\\tself.name = name\\n\\t\\tself.trans= {}\\n\\t\\t# self.outputs = {}\\n\\t\\tself.direction = direction\\n\\t\\tself.isFinal = isFinal\",\n \"def name(self, name):\\n pass\",\n \"def createUsedBy( self ):\\n for aChunk in self.chunkSeq:\\n #usage = (self.fullNameFor(aChunk.name), aChunk.seq)\\n for aRefName in aChunk.genReferences( self ):\\n for c in self.getchunk( aRefName ):\\n c.referencedBy.append( aChunk )\\n c.refCount += 1\\n \\n for nm in self.no_reference():\\n self.logger.warn( \\\"No reference to {!r}\\\".format(nm) )\\n for nm in self.multi_reference():\\n self.logger.warn( \\\"Multiple references to {!r}\\\".format(nm) )\\n for nm in self.no_definition():\\n self.logger.error( \\\"No definition for {!r}\\\".format(nm) )\\n self.errors += 1\",\n \"def __init__(self, name):\\n self.nodes = []\\n self.name = str(name)\",\n \"def get_comp_names(self, names):\\n names = names[:]\\n comp_names = {}\\n for r_block in self.frd.result_blocks:\\n if r_block.name in names and r_block.name not in comp_names:\\n comp_names[r_block.name] = []\\n for ent in r_block.entities:\\n if ent.ictype == 2 and ent.icind1 == 0:\\n continue\\n comp_names[r_block.name].append(ent.name)\\n names.remove(r_block.name)\\n if not names:\\n break\\n return comp_names\",\n \"def names(self, channel, *args, **kwargs):\\n pass\",\n \"def store_names(self):\\n # clear the text buffer, or create new buffer\\n try:\\n namestxt = bpy.data.texts[\\\"FullNames\\\"]\\n namestxt.clear()\\n except KeyError:\\n namestxt = bpy.data.texts.new(\\\"FullNames\\\")\\n \\n # write the names to the text buffer\\n for block, shortname in self.nif_import.dict_names.items():\\n block_name = block.name.decode()\\n if block_name and shortname != block_name:\\n namestxt.write('%s;%s\\\\n' % (shortname, block_name))\",\n \"def test_update_flow_classifier_description(self):\\n resource = 'flow_classifier'\\n cmd = fc.FlowClassifierUpdate(test_cli20.MyApp(sys.stdout), None)\\n myid = 'myid'\\n args = [myid, '--description', 'flow_classifier1', '--description',\\n 'flow_classifier2']\\n updatefields = {'description': 'flow_classifier2'}\\n self._test_update_resource(resource, cmd, myid, args, updatefields)\",\n \"def build_stage2_6(self):\\n paf, cfm = self.stage2_6.values()\\n for i in range(2, 7):\\n paf_ = OrderedDict([(k.replace('i', str(i)),paf[k]) for k in paf])\\n cfm_ = OrderedDict([(k.replace('i', str(i)),cfm[k]) for k in cfm])\\n stage_ = OrderedDict(PAF=paf_, CFM=cfm_)\\n setattr(self, f'stage{i}', stage_)\",\n \"def __init__(self, name, fave_football_team):\\n self.name = name\\n self.fave_football_team = fave_football_team\",\n \"def setUpFormData(self):\\n super(InconsistentCASName, self).setUpFormData()\\n self.formData['CAS_ID'] = '290-37-9'\\n self.formData['CSID'] = '8904' # consistent values for pyrazine.\",\n \"def create_label(self, org, name):\\n pass\",\n \"def _setup_pipeline_cfg(self):\",\n \"def _replace_init_name(self, cr, uid, organisation_function_child_ids, context=None):\\r\\n for item in organisation_function_child_ids:\\r\\n if len(item) == 3 and item[2] and 'function_type_id' in item[2]:\\r\\n function_type_obj = self.pool.get('res.function.type').browse(cr,uid,item[2]['function_type_id'])\\r\\n #reformat name\\r\\n item[2]['name'] = function_type_obj.name\\r\\n yield item\",\n \"def get_all_flow(self, conf, dpid):\\n\\t\\tpass\",\n \"def __init__(self, name, attributes, incident_edges):\\n self.name = name # initialize all necessary fields\\n self.attributes = attributes\\n self.incident_edges = incident_edges\",\n \"def __init__(self, name, attributes, incident_edges):\\n self.name = name # initialize all necessary fields\\n self.attributes = attributes\\n self.incident_edges = incident_edges\",\n \"def setup(self):\\n ### Set Names\\n # Name of the pipeline reduction step\\n self.name='coadd'\\n # Shortcut for pipeline reduction step and identifier for\\n # saved file names.\\n self.procname = 'coadd'\\n # Set Logger for this pipe step\\n self.log = logging.getLogger('pipe.step.%s' % self.name)\\n ### Set Parameter list\\n # Clear Parameter list\\n self.paramlist = []\\n # Append parameters\\n self.paramlist.append(['kernel','square',\\n 'Specifies the kernel used to determine spreading of input pixels onto output pixels \\\\\\n - options are square, point, gaussian, smoothing, tophat'])\\n self.paramlist.append(['pixfrac', 1.,\\n 'The fraction of an output pixel(s) that an input pixel\\\\'s flux is confined to'])\\n self.paramlist.append(['resolution', 1.,\\n 'Pixel scale divisor for output image (higher gives more resolution, lower gives less)'])\\n self.paramlist.append(['pad', 0,\\n 'Extra padding outside maximum extent of inputs'])\\n self.paramlist.append(['fillval', np.nan,\\n 'Value for filling in the area(s) in the output where there is no input data'])\\n self.paramlist.append(['drizzleweights','exptime',\\n 'How each input image should be weighted when added to the output \\\\\\n - options are exptime, expsq and uniform'])\\n self.paramlist.append(['outangle',0.,\\n 'Output angle of drizzled image (currently not functional)'])\",\n \"def map_activity_name2(self, name):\\n newname = self.amappings2.get(name)\\n if newname is None:\\n return 'Other'\\n else:\\n return newname\",\n \"def _gather_components(self):\\n comps = set()\\n for data in self._collection:\\n for c in data.components:\\n if c in comps:\\n continue\\n label = \\\"%s (%s)\\\" % (c, data.label)\\n label = disambiguate(label, self._labels)\\n self._labels[label] = c\\n comps.add(c)\",\n \"def so_attributes(self):\\n try:\\n self.channels\\n except AttributeError:\\n # create if doesn't exist\\n self.channels = [x[0] for x in self.data.columns]\\n \\n dfs = ['sofiltEEG', 'spsofiltEEG']\\n [setattr(self, df, pd.DataFrame(index=self.data.index)) for df in dfs]\\n self.so_events = {}\\n self.so_rejects = {}\",\n \"def __init__(self, name, summary, branch, new_owner, user):\\n self.name = name\\n self.summary = summary\\n self.branch = [branch]\\n self.new_owner = new_owner\\n self.user = user\",\n \"def __init__(self, name):\\n self.name = name\\n self.difficulty = 0\\n self.description = \\\"\\\"\\n self.prerequisites = {}\\n self.cost = {}\\n self.effects = {}\\n self.strings = {}\",\n \"def __init__(self, name):\\n\\n self.name = name\\n self.exits = {}\\n self.inventory= []\\n self.objects = []\\n self.description = ''\",\n \"def audit_names_in_metadata(self):\\n\\n # Iterate over commits....\\n for commit in self.repository.commits.values():\\n for name in [ commit.committer_name, commit.author_name ]:\\n # Is the name whitelisted?\\n if name in self.FullNameWhitelist:\\n continue\\n\\n # As a special case, allow the name 'GitHub' for certain repositories\\n if name == 'GitHub' and self.repository.path in self.GitHubPRWhitelist:\\n self.__log_warning(commit.sha1, \\\"Commit has username 'GitHub' (web merge of PR); allowing anyway\\\")\\n continue\\n\\n # Check to see if the name contains spaces - if not - it is probably misconfigured....\\n if \\\" \\\" not in name.strip():\\n self.__log_failure(commit.sha1, \\\"Non-full name: \\\" + name)\\n continue\",\n \"def _create_parameter_names(self):\\n self._parameter_names = self.parameter_schema[\\\"problem\\\"][\\\"names\\\"]\",\n \"def __init__(self, name: str, createStepName: str, fields: str = \\\"\\\"):\\n pass\",\n \"def flow(self, flow):\\n\\n self._flow = flow\",\n \"def setup(self):\\n declared = []\\n spec = get_specs_for_module(self.module_name)\\n\\n # Inputs\\n for entry in spec.cpacs_inout.inputs:\\n if entry.var_name in declared:\\n log.info(\\\"Already declared\\\")\\n elif entry.var_name in Rt.optim_var_dict:\\n var = Rt.optim_var_dict[entry.var_name]\\n if entry.var_name in Rt.optim_var_dict:\\n self.add_input(entry.var_name, val=var[1][0])\\n declared.append(entry.var_name)\\n\\n if declared == []:\\n self.add_input(self.module_name + \\\"_in\\\")\\n declared = []\\n\\n for entry in spec.cpacs_inout.outputs:\\n # Replace special characters from the name of the entry and checks for accronyms\\n entry.var_name = change_var_name(entry.var_name)\\n\\n if entry.var_name in declared:\\n log.info(\\\"Already declared\\\")\\n elif entry.var_name in Rt.optim_var_dict:\\n var = Rt.optim_var_dict[entry.var_name]\\n self.add_output(entry.var_name, val=var[1][0])\\n declared.append(entry.var_name)\\n elif (\\n \\\"aeromap\\\" in entry.var_name and self.module_name == Rt.last_am_module\\n ): # == 'PyTornado': #not skf^is_skf:\\n # Condition to avoid any conflict with skinfriction\\n for name in PARAMS:\\n if name in Rt.optim_var_dict:\\n var = Rt.optim_var_dict[name]\\n self.add_input(name, val=var[1][0])\\n declared.append(entry.var_name)\\n for name in COEFS:\\n if name in Rt.optim_var_dict:\\n var = Rt.optim_var_dict[name]\\n if is_digit(var[1][0]):\\n self.add_output(name, val=var[1][0])\\n else:\\n self.add_output(name)\\n declared.append(entry.var_name)\\n\\n if declared == []:\\n self.add_output(self.module_name + \\\"_out\\\")\",\n \"def __init__(self, name, graph, plugs=None):\\n self.name = name\\n self.graph = graph\\n self.plugs = plugs or []\\n self.graph.inputs[self.name] = self\",\n \"def __init__(self, flow, register=True):\\n\\n self.flow = flow\\n self.domain = flow.domain\\n self.version = '1.0'\\n self.activities = activity.find_workflow_activities(flow)\\n self.task_list = flow.name\\n super(DeciderWorker, self).__init__()\\n\\n if register:\\n self.register()\",\n \"def __init__(self, name, process_step=None, **attributes):\\n self.name = name\\n self.process_step = process_step\\n # Check the config file for the process metadata if process step not provided\\n if process_step is None:\\n cfg_def = cfg.read_procedures()[name]\\n self.process_step = cfg_def['process_step']\\n attributes = cfg_def.copy()\\n \\n\\n #self.source = source\\n self.attributes = attributes\\n #self.attributes['standard_name'] = 'source'\",\n \"def name_test(item):\\n return f\\\"{item['params']['interface']}:{item['expected']['state']}\\\"\",\n \"def __init__(self, in_channels, ofp_name='Optical Flow Predictor'):\\n super(OFPredictor, self).__init__()\\n self.ofp_name = ofp_name\\n\\n # definition of all layer channels\\n self.layer_out_channels = {1: 128,\\n 2: 64,\\n 3: 32,\\n 4: 16,\\n 5: 2}\\n self.layer_in_channels = {1: in_channels,\\n 2: self.layer_out_channels[1],\\n 3: self.layer_out_channels[2],\\n 4: self.layer_out_channels[3],\\n 5: self.layer_out_channels[4]}\\n\\n self.layers = self.build_layers()\\n\\n # print('%s Model Successfully Built \\\\n' % self.kpp_name)\",\n \"def make_output_names(self):\\n yaml_names = []\\n fits_names = []\\n\\n if self.use_nonstsci_names:\\n for i in range(len(self.info['Module'])):\\n act = str(self.info['act_id'][i]).zfill(2)\\n if self.info['Instrument'][i].lower() == 'niriss':\\n det = 'NIS'\\n elif self.info['Instrument'][i].lower() == 'fgs':\\n det = 'FGS'\\n else:\\n det = self.info['detector'][i]\\n mode = self.info['Mode'][i]\\n dither = str(self.info['dither'][i]).zfill(2)\\n\\n yaml_names.append(os.path.abspath(os.path.join(self.output_dir, 'Act{}_{}_{}_Dither{}.yaml'\\n .format(act, det, mode, dither))))\\n fits_names.append('Act{}_{}_{}_Dither{}_uncal.fits'.format(act, det, mode, dither))\\n\\n else:\\n for i in range(len(self.info['Module'])):\\n if self.info['Instrument'][i].upper() == 'NIRCAM':\\n fulldetector = 'nrc{}'.format(self.info['detector'][i].lower())\\n else:\\n fulldetector = self.info['detector'][i].lower()\\n outfilebase = self.create_output_name(self.info, index=i)\\n outfile = \\\"{}{}{}\\\".format(outfilebase, fulldetector, '_uncal.fits')\\n yamlout = \\\"{}{}{}\\\".format(outfilebase, fulldetector, '.yaml')\\n\\n yaml_names.append(yamlout)\\n fits_names.append(outfile)\\n\\n self.info['yamlfile'] = yaml_names\\n self.info['outputfits'] = fits_names\\n # Table([self.info['yamlfile']]).pprint()\",\n \"def __init__(self, name, description=None):\\n super(ArtifactDefinition, self).__init__()\\n self.collectors = []\\n self.conditions = []\\n self.description = description\\n self.name = name\\n self.labels = []\\n self.provides = []\\n self.supported_os = []\\n self.urls = []\",\n \"def test_rename_to_mlflow(mlflow):\\n atom = ATOMClassifier(X_bin, y_bin, experiment=\\\"test\\\", random_state=1)\\n atom.run(\\\"GNB\\\")\\n atom.scoring()\\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training\",\n \"def __init__(self):\\n\\n\\n f = open(datapath + '/Data/companylist.csv', 'r')\\n\\n\\n for line in f:\\n reg = line.split(',')\\n if reg[0] != 'Symbol':\\n if reg[0] not in self.cnames:\\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\\n else:\\n if reg[4].strip() != 'ASX':\\n self.cnames[reg[0]] = [reg[1], reg[2], reg[3], reg[4].strip()]\",\n \"def _generate_flow_xml(self):\\n model = self.model\\n\\n flow_dict = OrderedDict()\\n flow_dict['oml:flow'] = OrderedDict()\\n flow_dict['oml:flow']['@xmlns:oml'] = 'http://openml.org/openml'\\n flow_dict['oml:flow']['oml:name'] = self._get_name()\\n flow_dict['oml:flow']['oml:external_version'] = self.external_version\\n flow_dict['oml:flow']['oml:description'] = self.description\\n\\n clf_params = model.get_params()\\n flow_parameters = []\\n for k, v in clf_params.items():\\n # data_type, default_value, description, recommendedRange\\n # type = v.__class__.__name__ Not using this because it doesn't conform standards\\n # eg. int instead of integer\\n param_dict = {'oml:name': k}\\n flow_parameters.append(param_dict)\\n\\n flow_dict['oml:flow']['oml:parameter'] = flow_parameters\\n\\n flow_xml = xmltodict.unparse(flow_dict, pretty=True)\\n\\n # A flow may not be uploaded with the encoding specification..\\n flow_xml = flow_xml.split('\\\\n', 1)[-1]\\n return flow_xml\",\n \"def init(self, *, flow: int = -1) -> int:\",\n \"def update_species_frames(self):\\n pass\",\n \"def __init__(self, name, f):\\r\\n self.FailedIds = []\\r\\n self.Name = name\\r\\n self.F = f\",\n \"def _process_name(self):\\n if not isinstance(self.transform, GroupTransformModel):\\n return\\n\\n name = self._transform_value(self.transform.name)\\n\\n if name is None:\\n self.log.error(\\n 'feature=ti-transform, event=process-group-name, message=no-name-found, '\\n f'path={self.transform.name.path}'\\n )\\n raise RuntimeError('At least one indicator value must be provided.')\\n\\n self.add_name(name)\",\n \"def __init__(self, name, pre_action_des, in_action_des, post_action_des, actionable, usable, state, feature_id):\\n self.name = name\\n self.pre_action_des = pre_action_des\\n self.in_action_des = in_action_des\\n self.post_action_des = post_action_des\\n self.actionable = actionable\\n self.usable = usable\\n self.state = state\\n self.feature_id = feature_id\",\n \"def create_flow(self, conf, dpid, params):\\n\\t\\tpass\",\n \"def _fix_chainID(self):\\n\\n from string import ascii_uppercase\\n\\n # get the current names\\n data = self.get('chainID')\\n natom = len(data)\\n\\n #get uniques\\n chainID = []\\n for c in data:\\n if c not in chainID:\\n chainID.append(c)\\n\\n if chainID == ['A','B']:\\n return\\n\\n if len(chainID)>26:\\n print(\\\"Warning more than 26 chains have been detected. This is so far not supported\\\")\\n sys.exit()\\n\\n # declare the new names\\n newID = [''] * natom\\n\\n # fill in the new names\\n for ic,chain in enumerate(chainID):\\n index = self.get('rowID',chainID=chain)\\n for ind in index:\\n newID[ind] = ascii_uppercase[ic]\\n\\n # update the new name\\n self.update_column('chainID',newID)\",\n \"def formal_step(self):\\n return f\\\"Added the obstructions {self.new_obs()}.\\\"\",\n \"def _add_to_existing_flowable(self, fb, new_terms):\\n biog = ('124-38-9' in fb)\\n for term in new_terms:\\n self._fm.add_synonym(fb, term)\\n if biog and bool(biogenic.search(term)):\\n self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym\",\n \"def __init__(self, name='Custom_Q1'):\\n self.equity_alive = 0\\n self.actions = []\\n self.last_action_in_stage = ''\\n self.temp_stack = []\\n self.name = name\\n self.autoplay = True\\n self.model = None\",\n \"def _augment_pipeline_cfg(self):\",\n \"def __init__(self, cfg, tops_type=[3, 5, 10]):\\n\\n attr_cloth_file = open(cfg.attr_cloth_file).readlines()\\n self.attr_idx2name = {}\\n for i, line in enumerate(attr_cloth_file[2:]):\\n self.attr_idx2name[i] = line.strip('\\\\n').split()[0]\",\n \"def __init__(self, incomings, a=tf.identity, name='ConcatLayer'):\\n super(ConcatLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incomings = []\\n self.incoming_shapes = []\\n \\n for incoming in incomings:\\n incoming, incoming_shape = get_input(incoming)\\n self.incomings.append(incoming)\\n self.incoming_shapes.append(incoming_shape)\\n self.name = name\\n self.a = a\",\n \"def __init__(self):\\n self.name = ''\\n self.variables = []\\n self.assumptions = []\\n self.guarantees = []\",\n \"def fix_label_names():\\n\\n assert trace.cpu.trace_done\\n binary_addr = memorymanager.BinaryAddr(0)\\n while binary_addr < len(classifications):\\n c = classifications[binary_addr]\\n if c is not None:\\n dummy = [str(x) for x in c.as_string_list(binary_addr, None)]\\n binary_addr += c.length()\\n else:\\n binary_addr += 1\",\n \"def __init__(self, name, bases):\\n self.name = name\\n self.bases = bases\",\n \"def __init__(self,path_exp,path_forcing=None,globaldata=None,refetch_records=False,end_state=True,refetch_stations=True,inputkeys = ['cveg','wg','w2','cc','sp','wwilt','Tsoil','T2','z0m','alpha','LAI',],obs_filter=False,tendencies_revised=False):\\n \\n # set the ground\\n self.globaldata = globaldata\\n\\n \\n self.obs_filter = obs_filter\\n print(self.obs_filter)\\n self.tendencies_revised = tendencies_revised\\n self.path_exp = path_exp\\n self.path_forcing = path_forcing\\n self.end_state = end_state\\n self.exp_files = glob.glob(self.path_exp+'/?????.yaml')\\n\\n # # get the list of stations\\n # stationsfile = self.path_exp+'/stations_list.csv'\\n # if (os.path.isfile(stationsfile)) and (not refetch_stations):\\n # stations = pd.read_csv(stationsfile)\\n # else:\\n # stations = get_stations(self.path_exp)\\n # stations.to_csv(stationsfile)\\n\\n # stations = stations.set_index('STNID')\\n\\n self.frames = {}\\n\\n self.frames['stats'] = {}\\n self.frames['worldmap'] = {}\\n \\n self.frames['profiles'] = {}\\n self.frames['profiles'] = {}\\n self.frames['profiles']['DT'] = None\\n self.frames['profiles']['STNID'] = None\\n\\n #self.frames['worldmap']['stationsfile'] = stationsfile\\n self.frames['worldmap']['stations'] = stations(self.path_exp, \\\\\\n suffix='ini',\\\\\\n refetch_stations=refetch_stations)\\n\\n # Initially, the stats frame inherets the values/iterators of\\n # worldmap\\n for key in self.frames['worldmap'].keys():\\n self.frames['stats'][key] = self.frames['worldmap'][key]\\n\\n # get its records and load it into the stats frame\\n self.frames['stats']['records_all_stations_ini'] =\\\\\\n get_records(self.frames['stats']['stations'].table,\\\\\\n self.path_exp,\\\\\\n subset='ini',\\\\\\n refetch_records=refetch_records\\n )\\n print(self.frames['stats']['records_all_stations_ini'])\\n # get its records and load it into the stats frame\\n\\n\\n self.frames['stats']['records_all_stations_end_mod'] =\\\\\\n get_records(self.frames['stats']['stations'].table,\\\\\\n self.path_exp,\\\\\\n subset='end',\\\\\\n refetch_records=refetch_records\\n )\\n\\n if self.path_forcing is not None:\\n # get its records and load it into the stats frame\\n self.frames['stats']['records_all_stations_end_obs'] =\\\\\\n get_records(self.frames['stats']['stations'].table,\\\\\\n self.path_forcing,\\\\\\n subset='end',\\\\\\n refetch_records=refetch_records\\n )\\n if self.end_state:\\n if len(self.frames['stats']['records_all_stations_end_mod']) == 0:\\n raise IOError ('No end state records found. If you want to ignore end states, please use the option end_state = False')\\n self.frames['stats']['records_all_stations_end_mod'].index = \\\\\\n self.frames['stats']['records_all_stations_ini'].index \\n\\n else:\\n self.frames['stats']['records_all_stations_end_mod'] = \\\\\\n self.frames['stats']['records_all_stations_ini']\\n\\n \\n if len(self.frames['stats']['records_all_stations_ini']) ==0:\\n raise ValueError('no class records found. Aborting')\\n\\n self.frames['stats']['records_all_stations_ini']['dates'] = \\\\\\n self.frames['stats']['records_all_stations_ini']['ldatetime'].dt.date\\n\\n if self.path_forcing is not None:\\n self.frames['stats']['records_all_stations_end_obs']['dates'] = \\\\\\n self.frames['stats']['records_all_stations_end_obs']['ldatetime'].dt.date\\n\\n self.frames['stats']['records_all_stations_end_obs'].set_index(['STNID','dates'],inplace=True)\\n\\n\\n ini_index_dates = self.frames['stats']['records_all_stations_ini'].set_index(['STNID','dates']).index\\n\\n self.frames['stats']['records_all_stations_end_obs'] = \\\\\\n self.frames['stats']['records_all_stations_end_obs'].loc[ini_index_dates]\\n\\n self.frames['stats']['records_all_stations_end_obs'].index = \\\\\\n self.frames['stats']['records_all_stations_ini'].index \\n\\n self.frames['stats']['viewkeys'] = ['h','theta','q']\\n print('Calculating table statistics')\\n\\n if self.tendencies_revised:\\n self.frames['stats']['records_all_stations_end_mod_stats'] = \\\\\\n tendencies_rev(self.frames['stats']['records_all_stations_end_mod'],\\\\\\n self.frames['stats']['records_all_stations_ini'],\\\\\\n self.frames['stats']['viewkeys']\\\\\\n )\\n self.frames['stats']['records_all_stations_end_obs_stats'] = \\\\\\n tendencies_rev(self.frames['stats']['records_all_stations_end_obs'],\\\\\\n self.frames['stats']['records_all_stations_ini'],\\\\\\n self.frames['stats']['viewkeys']\\\\\\n )\\n\\n else:\\n self.frames['stats']['records_all_stations_end_mod_stats'] = \\\\\\n tendencies(self.frames['stats']['records_all_stations_end_mod'],\\\\\\n self.frames['stats']['records_all_stations_end_obs'],\\\\\\n self.frames['stats']['records_all_stations_ini'],\\\\\\n self.frames['stats']['viewkeys']\\\\\\n )\\n self.frames['stats']['records_all_stations_end_obs_stats'] = \\\\\\n tendencies(self.frames['stats']['records_all_stations_end_obs'],\\\\\\n self.frames['stats']['records_all_stations_end_obs'],\\\\\\n self.frames['stats']['records_all_stations_ini'],\\\\\\n self.frames['stats']['viewkeys']\\\\\\n )\\n\\n self.frames['stats']['inputkeys'] = inputkeys\\n \\n # self.frames['stats']['inputkeys'] = \\\\\\n # [ key for key in \\\\\\n # self.globaldata.datasets.keys() \\\\\\n # if key in \\\\\\n # list(self.frames['stats']['records_all_stations_obs'].columns)]\\n\\n\\n # get units from the class4gl units database\\n self.units = dict(units)\\n # for those that don't have a definition yet, we just ask a question\\n # mark\\n for var in self.frames['stats']['inputkeys']:\\n self.units[var] = '?'\\n\\n self.frames['worldmap']['inputkeys'] = self.frames['stats']['inputkeys'] \\n self.frames['stats']['records_all_stations_ini_pct'] = \\\\\\n pct(self.frames['stats']['records_all_stations_ini'], \\\\\\n columns = self.frames['stats']['inputkeys'])\\n\\n # pd.DataFrame(columns = self.frames['stats']['viewkeys'])\\n # for ikey,key in enumerate(self.frames['stats']['viewkeys']):\\n # mod['\\n\\n # \\n # \\n # \\\\\\n # self.frames['stats']['records_all_stations_end_mod'], \\\\\\n\\n\\n\\n # self.frames['stats']['records_all_stations_end_mod_stats_stdrel'] = \\\\\\n # stdrel(mod = self.frames['stats']['records_all_stations_end_mod_stats'], \\\\\\n # obs = self.frames['stats']['records_all_stations_end_obs_stats'], \\\\\\n # columns = [ 'd'+key+'dt' for key in \\\\\\n # self.frames['stats']['viewkeys']], \\\\\\n # )\\n\\n # self.frames['stats']['records_all_stations_end_obs_stats_stdrel'] = \\\\\\n # stdrel(mod = self.frames['stats']['records_all_stations_ini'], \\\\\\n # obs = self.frames['stats']['records_all_stations_ini'], \\\\\\n # columns = self.frames['stats']['viewkeys'], \\\\\\n # )\\n\\n \\n\\n if self.path_forcing is not None:\\n print('filtering pathological data')\\n indextype = self.frames['stats']['records_all_stations_end_mod_stats'].index.names\\n # some observational sounding still seem problematic, which needs to be\\n # investigated. In the meantime, we filter them\\n\\n print('hello',self.obs_filter)\\n print ((self.path_forcing is not None) and (self.obs_filter))\\n if ((self.path_forcing is not None) and (self.obs_filter)) is True:\\n print('hallohallo')\\n if ((self.path_forcing is not None) and (self.obs_filter)) is True:\\n print('exclude exceptional observations')\\n print('exclude unrealistic model output -> should be investigated!')\\n valid = (\\\\\\n (self.frames['stats']['records_all_stations_end_mod'].theta > 273.) & \\n (self.frames['stats']['records_all_stations_end_obs'].theta > 273.) & \\n #(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.25) & \\n (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.) & \\n #(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > 0.25000) & \\n #(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 1.8000) & \\n # (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 2.0000) & \\n #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 50.0000) & \\n (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt > 0.0000) & \\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 400.) & \\n # (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt < 350.) & \\n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < .0003) & \\n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt > -.0006) & \\n # (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < .0003) & \\n\\n # filter 'extreme' model output -> should be investigated!\\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0006) & \\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt > -.0006) & \\n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .0) & \\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 40.) & \\n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .0) & \\n (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 2.3) & \\n # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0003) & \\n # (self.frames['stats']['records_all_stations_ini'].KGC != 'Cwb') & \\n # (self.frames['stats']['records_all_stations_ini'].KGC != 'Dfc') & \\n ~np.isnan(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt) & \\n ~np.isnan(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt))\\n# \\n# \\n# \\n# \\n# # (self.frames['stats']['records_all_stations_ini'].lat >-2. ) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.00) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt > 0.25000) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 3.0000) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt < 1.8000) & \\n# #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt > 50.0000) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt > 40.0000) & \\n# #(self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 350.) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dhdt < 450.) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt > -0.0006) & \\n# (self.frames['stats']['records_all_stations_end_obs_stats'].dqdt < 0.0003) & \\n# # ((self.frames['stats']['records_all_stations_ini'].ldatetime-\\n# # self.frames['stats']['records_all_stations_ini'].lSunset).total_seconds()\\n# # <= -2.*3600.) & \\n# # filter 'extreme' model output -> should be investigated!\\n# (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0005) & \\n# (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt > -.0006) & \\n# (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt > .2) & \\n# (self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt < 2.) & \\n# # (self.frames['stats']['records_all_stations_end_mod_stats'].dhdt < 400.) & \\n# # (self.frames['stats']['records_all_stations_end_mod_stats'].dqdt < .0003) & \\n# # (self.frames['stats']['records_all_stations_ini'].KGC != 'Cwb') & \\n# # (self.frames['stats']['records_all_stations_ini'].KGC != 'Dfc') & \\n# ~np.isnan(self.frames['stats']['records_all_stations_end_mod_stats'].dthetadt) & \\n# ~np.isnan(self.frames['stats']['records_all_stations_end_obs_stats'].dthetadt))\\n\\n for key in self.frames['stats'].keys():\\n if (type(self.frames['stats'][key]) == pd.DataFrame) and \\\\\\n (self.frames['stats'][key].index.names == indextype):\\n self.frames['stats'][key] = self.frames['stats'][key][valid]\\n print(\\\"WARNING WARNING!: \\\"+ str(len(valid) - np.sum(valid))+' soundings are filtered')\\n\\n self.frames['stats']['records_all_stations_index'] = self.frames['stats']['records_all_stations_end_mod'].index\\n\\n\\n print(\\\"filtering stations from interface that have no records\\\")\\n for STNID,station in self.frames['worldmap']['stations'].table.iterrows():\\n if ((self.frames['stats']['records_all_stations_index'].get_level_values('STNID')\\\\\\n == STNID).sum() == 0):\\n print(\\\"dropping\\\", STNID)\\n self.frames['worldmap']['stations'].table = \\\\\\n self.frames['worldmap']['stations'].table.drop(STNID)\\n \\n self.frames['worldmap']['stations_iterator'] = stations_iterator(self.frames['worldmap']['stations']) \\n \\n # TO TEST: should be removed, since it's is also done just below\\n self.frames['stats']['stations_iterator'] = \\\\\\n self.frames['worldmap']['stations_iterator'] \\n\\n self.frames['worldmap']['inputkey'] = self.frames['worldmap']['inputkeys'][0]\\n self.frames['worldmap']['inputkey'] = self.frames['worldmap']['inputkey']\\n self.next_station()\\n\\n # self.goto_datetime_worldmap(\\n # self.frames['profiles']['current_record_obs'].datetime.to_pydatetime(),\\n # 'after')\",\n \"def get_param_names(self):\\n # Sort the FIO parameter names to generate consistent fio commands\\n all_param_names = super(FioCommand, self).get_param_names()\\n # move the 'name' option as the first option of fio job\\n all_param_names.remove(\\\"name\\\")\\n all_param_names.insert(0, \\\"name\\\")\\n\\n return all_param_names\",\n \"def change_names (fixed_structure, moving_structure, index):\\n for chain in moving_structure[0]:\\n chain.id = utilities.merged_list[index]+\\\"-\\\"+chain.id\\n index +=1\\n return (fixed_structure, moving_structure, index)\",\n \"def _break_pipeline_cfg(self):\",\n \"def names():\\n pass\",\n \"def __init__(self, name):\\n\\n self.name = name\\n self.rules = []\\n self._watched_files = []\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58474296","0.569925","0.56435513","0.53014785","0.52610934","0.5227977","0.5182955","0.5182175","0.5170833","0.5162001","0.5134495","0.51231927","0.5099633","0.50600487","0.50040334","0.5002867","0.49885595","0.4968262","0.49279296","0.49234572","0.49192947","0.4916501","0.48960406","0.4865491","0.48481476","0.4842053","0.48387173","0.48366928","0.48310786","0.48266816","0.48252591","0.48169896","0.4816631","0.48033303","0.47757426","0.47620538","0.47616833","0.4754391","0.47504032","0.4744954","0.47444332","0.47431448","0.47424257","0.4735141","0.4725141","0.4724628","0.4708513","0.4705945","0.46977288","0.46969754","0.46961308","0.46935236","0.4692903","0.4692815","0.4691778","0.46828118","0.46828118","0.46669474","0.4665278","0.46647212","0.46628815","0.46601242","0.4659837","0.46562436","0.46533382","0.4650177","0.4649286","0.46480075","0.46429518","0.4638202","0.46370783","0.4632658","0.4630429","0.46283832","0.46252984","0.46249124","0.46227127","0.4621375","0.4616998","0.4616727","0.46144563","0.4613941","0.46116653","0.46105888","0.46102375","0.46070534","0.46049333","0.46039018","0.45988354","0.4598703","0.45946857","0.45884064","0.45837155","0.4580663","0.45798174","0.45783263","0.4569883","0.45671058","0.45667285","0.4552556","0.45511544"],"string":"[\n \"0.58474296\",\n \"0.569925\",\n \"0.56435513\",\n \"0.53014785\",\n \"0.52610934\",\n \"0.5227977\",\n \"0.5182955\",\n \"0.5182175\",\n \"0.5170833\",\n \"0.5162001\",\n \"0.5134495\",\n \"0.51231927\",\n \"0.5099633\",\n \"0.50600487\",\n \"0.50040334\",\n \"0.5002867\",\n \"0.49885595\",\n \"0.4968262\",\n \"0.49279296\",\n \"0.49234572\",\n \"0.49192947\",\n \"0.4916501\",\n \"0.48960406\",\n \"0.4865491\",\n \"0.48481476\",\n \"0.4842053\",\n \"0.48387173\",\n \"0.48366928\",\n \"0.48310786\",\n \"0.48266816\",\n \"0.48252591\",\n \"0.48169896\",\n \"0.4816631\",\n \"0.48033303\",\n \"0.47757426\",\n \"0.47620538\",\n \"0.47616833\",\n \"0.4754391\",\n \"0.47504032\",\n \"0.4744954\",\n \"0.47444332\",\n \"0.47431448\",\n \"0.47424257\",\n \"0.4735141\",\n \"0.4725141\",\n \"0.4724628\",\n \"0.4708513\",\n \"0.4705945\",\n \"0.46977288\",\n \"0.46969754\",\n \"0.46961308\",\n \"0.46935236\",\n \"0.4692903\",\n \"0.4692815\",\n \"0.4691778\",\n \"0.46828118\",\n \"0.46828118\",\n \"0.46669474\",\n \"0.4665278\",\n \"0.46647212\",\n \"0.46628815\",\n \"0.46601242\",\n \"0.4659837\",\n \"0.46562436\",\n \"0.46533382\",\n \"0.4650177\",\n \"0.4649286\",\n \"0.46480075\",\n \"0.46429518\",\n \"0.4638202\",\n \"0.46370783\",\n \"0.4632658\",\n \"0.4630429\",\n \"0.46283832\",\n \"0.46252984\",\n \"0.46249124\",\n \"0.46227127\",\n \"0.4621375\",\n \"0.4616998\",\n \"0.4616727\",\n \"0.46144563\",\n \"0.4613941\",\n \"0.46116653\",\n \"0.46105888\",\n \"0.46102375\",\n \"0.46070534\",\n \"0.46049333\",\n \"0.46039018\",\n \"0.45988354\",\n \"0.4598703\",\n \"0.45946857\",\n \"0.45884064\",\n \"0.45837155\",\n \"0.4580663\",\n \"0.45798174\",\n \"0.45783263\",\n \"0.4569883\",\n \"0.45671058\",\n \"0.45667285\",\n \"0.4552556\",\n \"0.45511544\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17096,"cells":{"query":{"kind":"string","value":"detach lookup for cleanness. canonical everything"},"document":{"kind":"string","value":"def _factors_for_flowable(self, fb, qq, cx, **kwargs):\n self._check_factors(qq)\n try:\n cl = self._qlookup(qq, fb)\n except NoFQEntry:\n return\n if cx is None:\n for v in cl.cfs():\n yield v\n else:\n for v in cl.find(cx, **kwargs):\n yield v"},"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 applyDemapping(self):\n pass","def cleanup():","def revise():","def cleanup(self):","def cleanup(self):","def cleanup(self):","def clean(_context):","def clean(c):","def horde_cleanup(self):","def _clean_up(self):","def cleanup(self):\n for residue in self.debumper.biomolecule.residues:\n if not isinstance(residue, aa.Amino):\n continue\n if residue.name == \"GLH\" or \"GLH\" in residue.patches:\n if residue.has_atom(\"HE1\") and residue.has_atom(\"HE2\"):\n residue.remove_atom(\"HE1\")\n elif residue.name == \"ASH\" or \"ASH\" in residue.patches:\n if residue.has_atom(\"HD1\") and residue.has_atom(\"HD2\"):\n residue.remove_atom(\"HD1\")","def cleanup():\n for s in [missiles, explosions, bonus]:\n\n set_to_remove = set([])\n for m in s:\n if m.isDead:\n set_to_remove.add(m)\n\n s.difference_update(set_to_remove)","def tearDown(self):\n # remove refs\n self.lattice = None\n self.filter = None\n self.bigClusterIndexes = None\n self.smallClusterIndexes = None","def clean_up(self):\n\t\tpass","def decache(self):","def clean(self):\n raise NotImplementedError","def clear_lookups(namespace):\r\n if namespace in LOOKUP:\r\n del LOOKUP[namespace]","def cleanup (self):\n pass","def cleanup(self):\n\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def cleanup(self):\n pass","def tree_removeDeadBranches():\n nonlocal d_tree\n d_tree = { k : v for k, v in d_tree.items() if v}\n # By creating a new binding for 'd_tree', we have effectively\n # severed the connection back to the original dictionary.\n # We now need to copy this d_tree to the self.d_inputTree\n # self.d_outputTree structures\n self.d_inputTree = d_tree\n self.d_outputTree = self.d_inputTree.copy()","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def deinit(self) -> None:","def _del_derived(self):\n self._der = None # reset of the partial derivatives","def cleanup(self, *args, **kwargs):","def clean(self):","def _cleanup():\n for (\n _,\n transformation,\n transformation_dict,\n _,\n _,\n increfed,\n _,\n ) in _queued_transformations:\n # For some reason, the logic here is different than for the async version\n # (see run_transformation_dict_async)\n if (\n increfed\n and bytes.fromhex(transformation) in transformation_cache.transformations\n ):\n transformation_cache.decref_transformation(transformation_dict, increfed)","def clean_up(self):\n pass","def clean_up(self):\n pass","def cleanUp(self):\r\n pass","def cleanup(adata, del_prediction=False, del_2nd_moments=False):\n\n if \"pca_fit\" in adata.uns_keys():\n adata.uns[\"pca_fit\"] = None\n if \"velocyto_SVR\" in adata.uns_keys():\n adata.uns[\"velocyto_SVR\"][\"SVR\"] = None\n if \"umap_fit\" in adata.uns_keys():\n adata.uns[\"umap_fit\"][\"fit\"] = None\n if \"velocity_pca_fit\" in adata.uns_keys():\n adata.uns[\"velocity_pca_fit\"] = None\n if \"kmc\" in adata.uns_keys():\n adata.uns[\"kmc\"] = None\n if \"kinetics_heatmap\" in adata.uns_keys():\n adata.uns.pop(\"kinetics_heatmap\")\n if \"hdbscan\" in adata.uns_keys():\n adata.uns.pop(\"hdbscan\")\n\n VF_keys = [i if i.startswith(\"VecFld\") else None for i in adata.uns_keys()]\n for i in VF_keys:\n if i is not None and \"VecFld2D\" in adata.uns[i].keys():\n del adata.uns[i][\"VecFld2D\"]\n\n fate_keys = [i if i.startswith(\"fate\") else None for i in adata.uns_keys()]\n for i in fate_keys:\n if i is not None:\n if adata.uns[i][\"init_cells\"] is not None:\n adata.uns[i][\"init_cells\"] = list(adata.uns[i][\"init_cells\"])\n if \"prediction\" in adata.uns[i].keys():\n if del_prediction:\n del adata.uns[i][\"prediction\"]\n if \"VecFld_true\" in adata.uns[i].keys():\n if adata.uns[i][\"VecFld_true\"] is not None:\n del adata.uns[i][\"VecFld_true\"]\n\n if del_2nd_moments:\n from .tools.utils import remove_2nd_moments\n\n remove_2nd_moments(adata)\n\n return adata","def clean_up(self) -> None:\n self.single_device_matches = collections.defaultdict(\n lambda: collections.defaultdict(list)\n )","def cleanup(self, data):\n tmp = copy.copy(data)\n for field in ('log_entries', 'instances',\n 'picked_instances', 'saved_instances',\n 'terminated_instances', 'skipped_instances'):\n if field in tmp:\n del tmp[field]\n return tmp","def clean(self):\n pass","def _clean(self):\n map(self.__delitem__, self.keys())\n self._original = []\n self._columns = {}\n self._modified, self._deleted = {}, {}","def disarm(self):\n pass","def clean(self):\n super(NoneCache, self).clean()","def cleanup(self):\r\n pass","def cleanup(self):\r\n pass","def on_unassign(self):","def destantiate(self, memo):\n raise NotImplementedError()","def clean_up_data(self):\n pass","def deinit(self):\n pass","def deinit(self):\n pass","def clean_up(self):\n while len(self.__refs_for_deletion): \n attr = self.__refs_for_deletion.pop()\n obj = getattr(self, attr)\n if hasattr(obj, 'clean_up'):\n obj.clean_up()\n delattr(self, attr)","def cleanup(self):\r\n pass","def untargeted(self):\n\t\tpass","def drop_reflector(self):\n\n self.reflector = None","def remove():","def reject(self):\n self.new_rom = None\n self.new_reductor = None","def cleanup(self):\n raise NotImplementedError","def unloaded():\n pass","def detach(self) -> ContextManager[None]:","def pruning_routine(self):\n pass","def clean():\n filter_phase_data()\n combine_phase_data()\n remove_duplicates_phase_data()","def clean(self):\n\n pass","def detach(self):\n for h in self._all:\n if h is not None:\n h.detach_()","def lookup():","def _cleanup(self):\n pass","def _unloadone(self):\n self.logger.log('attempting to unload some containers [stub]')\n if not len(self.containers):\n self.logger.log('no %s loaded to unload!' % (self.cname))\n containers = sorted(self.containers, key=lambda container: container.usefulness)\n tounload = containers[0]\n self.containers.remove(tounload)\n tounload.unload()\n self.logger.log('unloaded %s %r' % (self.cname, (tounload,)))","def cleaning (data):","def cleanup(*args, **kwargs): # real signature unknown\n pass","def detach(self):\n raise NotImplementedError()","def cleanup_and_reset(self):\n self.mem.set(self.mem.META_PLAN, None)\n self.mem.set(self.mem.META_GOALS, None)\n self.mem.set(self.mem.META_CURR_GOAL, None)","def _reset_unlinked_constituencies():\n UnlinkedConstituency.objects.all().delete()","def __cleanup(self):\n self.display = None\n self.parent = None\n self.name = None\n self.files = None\n return self","def post_cleanup(self):\n pass","def should_unresolve(self, data):\n raise NotImplementedError","def _repackage_hidden(h: nd.NDArray):\n return h.detach()","def cleanup(self):\n raise NotImplementedError()","def cleanup(self):\n raise NotImplementedError()","def _dealias(self, obj, path=None):\n if path is None:\n path = set()\n\n def _path_string(p):\n return \", \".join([str(entry) for entry in p])\n\n # recurse in basic structures\n if isinstance(obj, list):\n return [self._dealias(o, path=path) for o in obj]\n if isinstance(obj, dict):\n return {k: self._dealias(v, path=path) for k, v in obj.items()}\n if isinstance(obj, tuple):\n return tuple([self._dealias(o, path=path) for o in obj])\n\n if not isinstance(obj, Cacheable):\n raise PipelineException(\"pipeline targets and their dependencies should be cacheable: %s (path=%s)\" % (repr(obj), _path_string(path)))\n\n # dealias object based on its uid\n\n if [o for o in path if o is obj]:\n # produce ordered proof of cycle\n raise PipelineException(\"Cycle in dependency graph detected: %s\", _path_string(path))\n\n path.add(obj)\n\n # fixme modularity -- need a \"getDeps\" interface\n if isinstance(obj, Transform):\n # recurse\n dealiased_deps = [self._dealias(obj.inputs[k].node, path=path) for k in obj.inputs]\n else:\n dealiased_deps = []\n\n path.remove(obj)\n\n build_node = BuildNode(obj)\n dealiased = self.by_uid.get(build_node.uid, None)\n\n if not dealiased:\n # first instance\n dealiased = build_node\n dealiased.deps = dealiased_deps\n\n self.by_uid[dealiased.uid] = dealiased\n self._log_progress(\"building graph\")\n return dealiased","def post_lookup_hook(self):\n pass","def clean(self):\n\t\tfor v in self:\n\t\t\tv.reset_distance()\n\t\t\tv.reset_predecessor()\n\t\t\tv.reset_visited()","def removed(self, comp):\n\t\tpass","def clean(self):\n self.unique_combinations = {}\n self.reverse_combinations = []\n self.label_count = None","def clean():\n new_tree = None","def cleanup(self):\n return self.cleanupNonces(), self.cleanupAssociations()","def clean_object(metadata, analysistype):\n for sample in metadata:\n try:\n delattr(sample[analysistype], \"targetnames\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"targets\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"dnaseq\")\n except AttributeError:\n pass\n try:\n delattr(sample[analysistype], \"protseq\")\n except AttributeError:\n pass","def clean_up(P, c):\n if not P.pairs: return # root case\n P.siblings.pop()\n s,r = P.pairs.pop()\n P.shape_pool.add(s)\n P.resource_pool.add(r)\n if P.r2p:\n pathway_id = P.r2p[P.resources[r]]\n if c and c[pathway_id]:\n c[pathway_id].pop()\n if P.segments[pathway_id]:\n P.segments[pathway_id].pop()","def __del__ ( self ) :\n \n if self.name and self.name in self.__pdf_names :\n self.__pdf_names.remove ( self.name ) \n while self.__local_names :\n a = self.__local_names.pop ()\n if a in self.__var_names :\n self.__var_names.remove ( a )","def _cleanup_spec(spec):\n\n nonreferenced_data = []\n for data in spec[\"data\"]:\n name = data[\"name\"]\n # create a vesion of the spec where this data is removed\n without_this_data = copy.deepcopy(spec)\n without_this_data[\"data\"].remove(data)\n has_reference = name in str(without_this_data)\n if not has_reference:\n nonreferenced_data.append(data)\n\n new = copy.deepcopy(spec)\n new[\"data\"] = [data for data in new[\"data\"] if data not in nonreferenced_data]\n return new","def _cleanup(self):\n\n self.netIns = []\n self.netOuts = []\n self.Gradients = [None]*self.size"],"string":"[\n \"def applyDemapping(self):\\n pass\",\n \"def cleanup():\",\n \"def revise():\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def cleanup(self):\",\n \"def clean(_context):\",\n \"def clean(c):\",\n \"def horde_cleanup(self):\",\n \"def _clean_up(self):\",\n \"def cleanup(self):\\n for residue in self.debumper.biomolecule.residues:\\n if not isinstance(residue, aa.Amino):\\n continue\\n if residue.name == \\\"GLH\\\" or \\\"GLH\\\" in residue.patches:\\n if residue.has_atom(\\\"HE1\\\") and residue.has_atom(\\\"HE2\\\"):\\n residue.remove_atom(\\\"HE1\\\")\\n elif residue.name == \\\"ASH\\\" or \\\"ASH\\\" in residue.patches:\\n if residue.has_atom(\\\"HD1\\\") and residue.has_atom(\\\"HD2\\\"):\\n residue.remove_atom(\\\"HD1\\\")\",\n \"def cleanup():\\n for s in [missiles, explosions, bonus]:\\n\\n set_to_remove = set([])\\n for m in s:\\n if m.isDead:\\n set_to_remove.add(m)\\n\\n s.difference_update(set_to_remove)\",\n \"def tearDown(self):\\n # remove refs\\n self.lattice = None\\n self.filter = None\\n self.bigClusterIndexes = None\\n self.smallClusterIndexes = None\",\n \"def clean_up(self):\\n\\t\\tpass\",\n \"def decache(self):\",\n \"def clean(self):\\n raise NotImplementedError\",\n \"def clear_lookups(namespace):\\r\\n if namespace in LOOKUP:\\r\\n del LOOKUP[namespace]\",\n \"def cleanup (self):\\n pass\",\n \"def cleanup(self):\\n\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def cleanup(self):\\n pass\",\n \"def tree_removeDeadBranches():\\n nonlocal d_tree\\n d_tree = { k : v for k, v in d_tree.items() if v}\\n # By creating a new binding for 'd_tree', we have effectively\\n # severed the connection back to the original dictionary.\\n # We now need to copy this d_tree to the self.d_inputTree\\n # self.d_outputTree structures\\n self.d_inputTree = d_tree\\n self.d_outputTree = self.d_inputTree.copy()\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def deinit(self) -> None:\",\n \"def _del_derived(self):\\n self._der = None # reset of the partial derivatives\",\n \"def cleanup(self, *args, **kwargs):\",\n \"def clean(self):\",\n \"def _cleanup():\\n for (\\n _,\\n transformation,\\n transformation_dict,\\n _,\\n _,\\n increfed,\\n _,\\n ) in _queued_transformations:\\n # For some reason, the logic here is different than for the async version\\n # (see run_transformation_dict_async)\\n if (\\n increfed\\n and bytes.fromhex(transformation) in transformation_cache.transformations\\n ):\\n transformation_cache.decref_transformation(transformation_dict, increfed)\",\n \"def clean_up(self):\\n pass\",\n \"def clean_up(self):\\n pass\",\n \"def cleanUp(self):\\r\\n pass\",\n \"def cleanup(adata, del_prediction=False, del_2nd_moments=False):\\n\\n if \\\"pca_fit\\\" in adata.uns_keys():\\n adata.uns[\\\"pca_fit\\\"] = None\\n if \\\"velocyto_SVR\\\" in adata.uns_keys():\\n adata.uns[\\\"velocyto_SVR\\\"][\\\"SVR\\\"] = None\\n if \\\"umap_fit\\\" in adata.uns_keys():\\n adata.uns[\\\"umap_fit\\\"][\\\"fit\\\"] = None\\n if \\\"velocity_pca_fit\\\" in adata.uns_keys():\\n adata.uns[\\\"velocity_pca_fit\\\"] = None\\n if \\\"kmc\\\" in adata.uns_keys():\\n adata.uns[\\\"kmc\\\"] = None\\n if \\\"kinetics_heatmap\\\" in adata.uns_keys():\\n adata.uns.pop(\\\"kinetics_heatmap\\\")\\n if \\\"hdbscan\\\" in adata.uns_keys():\\n adata.uns.pop(\\\"hdbscan\\\")\\n\\n VF_keys = [i if i.startswith(\\\"VecFld\\\") else None for i in adata.uns_keys()]\\n for i in VF_keys:\\n if i is not None and \\\"VecFld2D\\\" in adata.uns[i].keys():\\n del adata.uns[i][\\\"VecFld2D\\\"]\\n\\n fate_keys = [i if i.startswith(\\\"fate\\\") else None for i in adata.uns_keys()]\\n for i in fate_keys:\\n if i is not None:\\n if adata.uns[i][\\\"init_cells\\\"] is not None:\\n adata.uns[i][\\\"init_cells\\\"] = list(adata.uns[i][\\\"init_cells\\\"])\\n if \\\"prediction\\\" in adata.uns[i].keys():\\n if del_prediction:\\n del adata.uns[i][\\\"prediction\\\"]\\n if \\\"VecFld_true\\\" in adata.uns[i].keys():\\n if adata.uns[i][\\\"VecFld_true\\\"] is not None:\\n del adata.uns[i][\\\"VecFld_true\\\"]\\n\\n if del_2nd_moments:\\n from .tools.utils import remove_2nd_moments\\n\\n remove_2nd_moments(adata)\\n\\n return adata\",\n \"def clean_up(self) -> None:\\n self.single_device_matches = collections.defaultdict(\\n lambda: collections.defaultdict(list)\\n )\",\n \"def cleanup(self, data):\\n tmp = copy.copy(data)\\n for field in ('log_entries', 'instances',\\n 'picked_instances', 'saved_instances',\\n 'terminated_instances', 'skipped_instances'):\\n if field in tmp:\\n del tmp[field]\\n return tmp\",\n \"def clean(self):\\n pass\",\n \"def _clean(self):\\n map(self.__delitem__, self.keys())\\n self._original = []\\n self._columns = {}\\n self._modified, self._deleted = {}, {}\",\n \"def disarm(self):\\n pass\",\n \"def clean(self):\\n super(NoneCache, self).clean()\",\n \"def cleanup(self):\\r\\n pass\",\n \"def cleanup(self):\\r\\n pass\",\n \"def on_unassign(self):\",\n \"def destantiate(self, memo):\\n raise NotImplementedError()\",\n \"def clean_up_data(self):\\n pass\",\n \"def deinit(self):\\n pass\",\n \"def deinit(self):\\n pass\",\n \"def clean_up(self):\\n while len(self.__refs_for_deletion): \\n attr = self.__refs_for_deletion.pop()\\n obj = getattr(self, attr)\\n if hasattr(obj, 'clean_up'):\\n obj.clean_up()\\n delattr(self, attr)\",\n \"def cleanup(self):\\r\\n pass\",\n \"def untargeted(self):\\n\\t\\tpass\",\n \"def drop_reflector(self):\\n\\n self.reflector = None\",\n \"def remove():\",\n \"def reject(self):\\n self.new_rom = None\\n self.new_reductor = None\",\n \"def cleanup(self):\\n raise NotImplementedError\",\n \"def unloaded():\\n pass\",\n \"def detach(self) -> ContextManager[None]:\",\n \"def pruning_routine(self):\\n pass\",\n \"def clean():\\n filter_phase_data()\\n combine_phase_data()\\n remove_duplicates_phase_data()\",\n \"def clean(self):\\n\\n pass\",\n \"def detach(self):\\n for h in self._all:\\n if h is not None:\\n h.detach_()\",\n \"def lookup():\",\n \"def _cleanup(self):\\n pass\",\n \"def _unloadone(self):\\n self.logger.log('attempting to unload some containers [stub]')\\n if not len(self.containers):\\n self.logger.log('no %s loaded to unload!' % (self.cname))\\n containers = sorted(self.containers, key=lambda container: container.usefulness)\\n tounload = containers[0]\\n self.containers.remove(tounload)\\n tounload.unload()\\n self.logger.log('unloaded %s %r' % (self.cname, (tounload,)))\",\n \"def cleaning (data):\",\n \"def cleanup(*args, **kwargs): # real signature unknown\\n pass\",\n \"def detach(self):\\n raise NotImplementedError()\",\n \"def cleanup_and_reset(self):\\n self.mem.set(self.mem.META_PLAN, None)\\n self.mem.set(self.mem.META_GOALS, None)\\n self.mem.set(self.mem.META_CURR_GOAL, None)\",\n \"def _reset_unlinked_constituencies():\\n UnlinkedConstituency.objects.all().delete()\",\n \"def __cleanup(self):\\n self.display = None\\n self.parent = None\\n self.name = None\\n self.files = None\\n return self\",\n \"def post_cleanup(self):\\n pass\",\n \"def should_unresolve(self, data):\\n raise NotImplementedError\",\n \"def _repackage_hidden(h: nd.NDArray):\\n return h.detach()\",\n \"def cleanup(self):\\n raise NotImplementedError()\",\n \"def cleanup(self):\\n raise NotImplementedError()\",\n \"def _dealias(self, obj, path=None):\\n if path is None:\\n path = set()\\n\\n def _path_string(p):\\n return \\\", \\\".join([str(entry) for entry in p])\\n\\n # recurse in basic structures\\n if isinstance(obj, list):\\n return [self._dealias(o, path=path) for o in obj]\\n if isinstance(obj, dict):\\n return {k: self._dealias(v, path=path) for k, v in obj.items()}\\n if isinstance(obj, tuple):\\n return tuple([self._dealias(o, path=path) for o in obj])\\n\\n if not isinstance(obj, Cacheable):\\n raise PipelineException(\\\"pipeline targets and their dependencies should be cacheable: %s (path=%s)\\\" % (repr(obj), _path_string(path)))\\n\\n # dealias object based on its uid\\n\\n if [o for o in path if o is obj]:\\n # produce ordered proof of cycle\\n raise PipelineException(\\\"Cycle in dependency graph detected: %s\\\", _path_string(path))\\n\\n path.add(obj)\\n\\n # fixme modularity -- need a \\\"getDeps\\\" interface\\n if isinstance(obj, Transform):\\n # recurse\\n dealiased_deps = [self._dealias(obj.inputs[k].node, path=path) for k in obj.inputs]\\n else:\\n dealiased_deps = []\\n\\n path.remove(obj)\\n\\n build_node = BuildNode(obj)\\n dealiased = self.by_uid.get(build_node.uid, None)\\n\\n if not dealiased:\\n # first instance\\n dealiased = build_node\\n dealiased.deps = dealiased_deps\\n\\n self.by_uid[dealiased.uid] = dealiased\\n self._log_progress(\\\"building graph\\\")\\n return dealiased\",\n \"def post_lookup_hook(self):\\n pass\",\n \"def clean(self):\\n\\t\\tfor v in self:\\n\\t\\t\\tv.reset_distance()\\n\\t\\t\\tv.reset_predecessor()\\n\\t\\t\\tv.reset_visited()\",\n \"def removed(self, comp):\\n\\t\\tpass\",\n \"def clean(self):\\n self.unique_combinations = {}\\n self.reverse_combinations = []\\n self.label_count = None\",\n \"def clean():\\n new_tree = None\",\n \"def cleanup(self):\\n return self.cleanupNonces(), self.cleanupAssociations()\",\n \"def clean_object(metadata, analysistype):\\n for sample in metadata:\\n try:\\n delattr(sample[analysistype], \\\"targetnames\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"targets\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"dnaseq\\\")\\n except AttributeError:\\n pass\\n try:\\n delattr(sample[analysistype], \\\"protseq\\\")\\n except AttributeError:\\n pass\",\n \"def clean_up(P, c):\\n if not P.pairs: return # root case\\n P.siblings.pop()\\n s,r = P.pairs.pop()\\n P.shape_pool.add(s)\\n P.resource_pool.add(r)\\n if P.r2p:\\n pathway_id = P.r2p[P.resources[r]]\\n if c and c[pathway_id]:\\n c[pathway_id].pop()\\n if P.segments[pathway_id]:\\n P.segments[pathway_id].pop()\",\n \"def __del__ ( self ) :\\n \\n if self.name and self.name in self.__pdf_names :\\n self.__pdf_names.remove ( self.name ) \\n while self.__local_names :\\n a = self.__local_names.pop ()\\n if a in self.__var_names :\\n self.__var_names.remove ( a )\",\n \"def _cleanup_spec(spec):\\n\\n nonreferenced_data = []\\n for data in spec[\\\"data\\\"]:\\n name = data[\\\"name\\\"]\\n # create a vesion of the spec where this data is removed\\n without_this_data = copy.deepcopy(spec)\\n without_this_data[\\\"data\\\"].remove(data)\\n has_reference = name in str(without_this_data)\\n if not has_reference:\\n nonreferenced_data.append(data)\\n\\n new = copy.deepcopy(spec)\\n new[\\\"data\\\"] = [data for data in new[\\\"data\\\"] if data not in nonreferenced_data]\\n return new\",\n \"def _cleanup(self):\\n\\n self.netIns = []\\n self.netOuts = []\\n self.Gradients = [None]*self.size\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6569446","0.58934015","0.5845248","0.57096654","0.57096654","0.57096654","0.56681806","0.5656693","0.565422","0.56260526","0.5572836","0.5460176","0.54530233","0.54232705","0.5409617","0.540709","0.5392803","0.5388027","0.53739077","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5367186","0.5355121","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.53488785","0.5348693","0.5348588","0.5327728","0.53154814","0.5314189","0.5314189","0.53131485","0.5303431","0.5302585","0.53021467","0.5301673","0.5298761","0.5297225","0.5289801","0.5287516","0.5287516","0.52547103","0.52515733","0.52515554","0.5250445","0.5250445","0.5242684","0.52256906","0.52232736","0.5219313","0.5209923","0.52092975","0.5200438","0.5184006","0.5180501","0.51686484","0.51646626","0.5155284","0.5141506","0.5141396","0.5141253","0.51385343","0.5137063","0.51075625","0.5101308","0.5100918","0.50996876","0.5099005","0.5086329","0.50852495","0.5072465","0.5067975","0.5067975","0.50601685","0.5059821","0.5057012","0.5056259","0.5053483","0.5051338","0.5048807","0.5045663","0.5034429","0.50316393","0.50302505","0.50283116"],"string":"[\n \"0.6569446\",\n \"0.58934015\",\n \"0.5845248\",\n \"0.57096654\",\n \"0.57096654\",\n \"0.57096654\",\n \"0.56681806\",\n \"0.5656693\",\n \"0.565422\",\n \"0.56260526\",\n \"0.5572836\",\n \"0.5460176\",\n \"0.54530233\",\n \"0.54232705\",\n \"0.5409617\",\n \"0.540709\",\n \"0.5392803\",\n \"0.5388027\",\n \"0.53739077\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5367186\",\n \"0.5355121\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.53488785\",\n \"0.5348693\",\n \"0.5348588\",\n \"0.5327728\",\n \"0.53154814\",\n \"0.5314189\",\n \"0.5314189\",\n \"0.53131485\",\n \"0.5303431\",\n \"0.5302585\",\n \"0.53021467\",\n \"0.5301673\",\n \"0.5298761\",\n \"0.5297225\",\n \"0.5289801\",\n \"0.5287516\",\n \"0.5287516\",\n \"0.52547103\",\n \"0.52515733\",\n \"0.52515554\",\n \"0.5250445\",\n \"0.5250445\",\n \"0.5242684\",\n \"0.52256906\",\n \"0.52232736\",\n \"0.5219313\",\n \"0.5209923\",\n \"0.52092975\",\n \"0.5200438\",\n \"0.5184006\",\n \"0.5180501\",\n \"0.51686484\",\n \"0.51646626\",\n \"0.5155284\",\n \"0.5141506\",\n \"0.5141396\",\n \"0.5141253\",\n \"0.51385343\",\n \"0.5137063\",\n \"0.51075625\",\n \"0.5101308\",\n \"0.5100918\",\n \"0.50996876\",\n \"0.5099005\",\n \"0.5086329\",\n \"0.50852495\",\n \"0.5072465\",\n \"0.5067975\",\n \"0.5067975\",\n \"0.50601685\",\n \"0.5059821\",\n \"0.5057012\",\n \"0.5056259\",\n \"0.5053483\",\n \"0.5051338\",\n \"0.5048807\",\n \"0.5045663\",\n \"0.5034429\",\n \"0.50316393\",\n \"0.50302505\",\n \"0.50283116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":17097,"cells":{"query":{"kind":"string","value":"Here we deal with water contexts specified as flowables by creating children this is generalizeable (vs for CO2)"},"document":{"kind":"string","value":"def factors_for_flowable(self, flowable, quantity=None, context=None, **kwargs):\n try:\n fb = self._fm[flowable]\n except KeyError:\n return\n ''' # this does not do anything helpful\n if fb == self._fm['Water']:\n try:\n context = self._cm['flow-%s' % flowable]\n except KeyError:\n pass\n '''\n for k in super(LciaEngine, self).factors_for_flowable(flowable, quantity=quantity, context=context, **kwargs):\n if self._quell_co2(flowable, context):\n yield QuelledCF.from_cf(k, flowable=self._bio_co2)\n else:\n yield k"},"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 child_case():\n result = ObjectContainer()\n\n flow1 = Flow(\"flow1\")\n result.flow1 = flow1\n\n with flow1.add_container(\"container1\") as container1:\n result.container1 = container1\n with container1.add_task(\"task1\") as task1:\n result.task1 = task1\n with container1.add_task(\"task2\") as task2:\n result.task2 = task2\n\n flow1.requeue()\n\n return result","def create_child(self):\n raise NotImplementedError","def children(self): # noqa: ANN201","def _addChildren(self, pid, chunks):\n if chunks[pid].type in [0, -1]:\n self._addEntity(pid, chunks)\n else:\n self._addPredicate(pid, chunks)","def setup_children(self):\n # Only generate new children if there are none\n if len(self.children) == 0:\n # Create the encoder and decoder genes\n encoder = EncoderGene(name='encoder',\n parent=self,\n spatial_scale=self.hyperparam(\n 'spatial_scale'))\n self.children = [encoder]\n\n decoder = DecoderGene(name='decoder',\n parent=self,\n spatial_scale=self.hyperparam(\n 'spatial_scale'))\n\n self.children.append(decoder)\n\n pass","def create_children(self):\n actionCount = len(self.availableActions)\n self.children = [None] * actionCount\n\n # Split creation into multiple threads if this is the master node.\n if self.level == 0 and USE_THREADS:\n threads = [None] * actionCount\n for idx in range(actionCount):\n threads[idx] = threading.Thread(target=create_child, args=(self, idx))\n threads[idx].start()\n for t in threads:\n t.join()\n else:\n for idx in range(actionCount):\n create_child(self, idx)\n # Stop making child branches if the most recent child branch already found lethal.\n if self.children[idx].get_max_win_strength() == WIN_VALUE:\n self.children = self.children[:idx+1]\n break","def _instantiate__deferred_inits(self, context=None):\n\n # For each mechanism in the Process, in backwards order through its _mech_tuples\n for item in reversed(self._mech_tuples):\n mech = item[OBJECT_ITEM]\n mech._deferred_init()\n\n # For each inputState of the mechanism\n for input_state in mech.inputStates.values():\n input_state._deferred_init()\n # Restrict projections to those from mechanisms in the current process\n projections = []\n for projection in input_state.receivesFromProjections:\n try:\n if self in projection.sender.owner.processes:\n projections.append(projection)\n except AttributeError:\n pass\n self._instantiate__deferred_init_projections(projections, context=context)\n\n # For each parameterState of the mechanism\n for parameter_state in mech.parameterStates.values():\n parameter_state._deferred_init()\n self._instantiate__deferred_init_projections(parameter_state.receivesFromProjections)\n\n # Label monitoring mechanisms and add _monitoring_mech_tuples to _mech_tuples for execution\n if self._monitoring_mech_tuples:\n\n # Add designations to newly created MonitoringMechanisms:\n for mech_tuple in self._monitoring_mech_tuples:\n mech = mech_tuple[OBJECT_ITEM]\n # If\n # - mech is a TARGET ObjectiveMechanism, and\n # - the mech that projects to mech is a TERMINAL for the current process, and\n # - current process has learning specified\n # then designate mech as a TARGET\n if (isinstance(mech, ObjectiveMechanism) and\n # any(projection.sender.owner.processes[self] == TERMINAL\n # for projection in mech.inputStates[SAMPLE].receivesFromProjections) and\n mech.learning_role is TARGET and\n self.learning\n ):\n mech_tuple[0].processes[self] = TARGET\n else:\n # mech must be a LearningMechanism;\n # If a learning_rate has been specified for the process, assign that to all LearningMechanisms\n # for which a mechanism-specific learning_rate has NOT been assigned\n if (self.learning_rate is not None and\n mech.function_object.learning_rate is None):\n mech.function_object.learning_rate = self.learning_rate\n\n # Assign its label\n mech_tuple[0].processes[self] = MONITORING\n\n # Add _monitoring_mech_tuples to _mech_tuples\n self._mech_tuples.extend(self._monitoring_mech_tuples)\n\n # IMPLEMENTATION NOTE:\n # MonitoringMechanisms for learning are assigned _phaseSpecMax;\n # this is so that they will run after the last ProcessingMechansisms have run","def Children(self) -> _n_1_t_2:","def _setup_children(self):\n\n for i in xrange(self._nhalos):\n self._halos[i+1].properties['children'] = []\n\n for i in xrange(self._nhalos):\n host = self._halos[i+1].properties.get('hostHalo', -2)\n if host > -1:\n try:\n self._halos[host+1].properties['children'].append(i+1)\n except KeyError:\n pass","def _setup_children(self):\n\n for i in xrange(self._nhalos):\n self._halos[i + 1].properties['children'] = []\n\n for i in xrange(self._nhalos):\n host = self._halos[i + 1].properties.get('hostHalo', -2)\n if host > -1:\n try:\n self._halos[host + 1].properties['children'].append(i + 1)\n except KeyError:\n pass","def create_hierarchy(self):\n\t\tpass","def _configure_flowables(self, flowables):\n if flowables is None:\n flowables = DEFAULT_FLOWABLES\n\n # FlowablesDict-- mainly to upsample CAS numbers for matching\n self._fm = FlowablesDict()\n\n self._fm.new_entry('carbon dioxide', '124-38-9')\n self._fm.new_entry('Water', '7732-18-5')\n # we store the child object and use it to signify biogenic CO2 to optionally quell\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\n\n # now load + merge from file\n self._fm.load(flowables)\n\n # now add all known \"biotic\" synonyms for CO2 to the biotic child\n for k in self._fm.synonyms('124-38-9'):\n if bool(biogenic.search(k)):\n self._bio_co2.add_term(k)\n self._fq_map = {fb: set() for fb in self._fm.objects}","def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\r\n # pylint: disable=no-member\r\n if depth == 0:\r\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\r\n else:\r\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)","def consolidate(self, final_context='adapter'):\n\n for context in ORDERED_CONTEXTS:\n block = getattr(self, context)\n parent_context = CONTEXTS[context]['parent']\n\n # End of parents chain reached\n if parent_context is None:\n if block is not None and context == 'adapter':\n self.adapters.append(block)\n break\n\n parent = getattr(self, parent_context)\n if block is not None:\n parent['childs'].append(block)\n setattr(self, context, None)\n\n if context == final_context:\n break","def _child_init(self):\n self._create_init_gp()","def _init_inherit_physical_attributes(self):\n config = self.person.cosmos.config\n mother, father = self.person.biological_mother, self.person.biological_father\n parents = (mother.body, father.body)\n # Handedness\n if random.random() < config.heritability_of_handedness:\n takes_after = random.choice(parents)\n self.left_handed = Feature(value=takes_after.left_handed, inherited_from=takes_after)\n self.right_handed = Feature(value=takes_after.right_handed, inherited_from=takes_after)\n # Hustle\n if random.random() < config.heritability_of_hustle:\n takes_after = random.choice(parents)\n inherited_hustle = takes_after.hustle\n mutated_hustle = normal(inherited_hustle, config.hustle_mutation_sd)\n self.hustle = Feature(value=mutated_hustle, inherited_from=takes_after)\n else:\n pass # TODO SET UP GENERATING FROM NOTHING","def _process_node(self, node):\n if node.type == \"program\":\n self._process_children(node)\n\n elif node.type == \"qreg\":\n self.qregs[node.name] = int(node.index)\n self.backend.new_qreg(node.name, int(node.index))\n\n elif node.type == \"creg\":\n self.cregs[node.name] = int(node.index)\n self.backend.new_creg(node.name, int(node.index))\n\n elif node.type == \"id\":\n raise UnrollerError(\"internal error: _process_node on id\")\n\n elif node.type == \"int\":\n raise UnrollerError(\"internal error: _process_node on int\")\n\n elif node.type == \"real\":\n raise UnrollerError(\"internal error: _process_node on real\")\n\n elif node.type == \"indexed_id\":\n raise UnrollerError(\"internal error: _process_node on indexed_id\")\n\n elif node.type == \"id_list\":\n # We process id_list nodes when they are leaves of barriers.\n return [self._process_bit_id(node_children)\n for node_children in node.children]\n\n elif node.type == \"primary_list\":\n # We should only be called for a barrier.\n return [self._process_bit_id(m) for m in node.children]\n\n elif node.type == \"gate\":\n self._process_gate(node)\n\n elif node.type == \"custom_unitary\":\n self._process_custom_unitary(node)\n\n elif node.type == \"universal_unitary\":\n args = self._process_node(node.children[0])\n qid = self._process_bit_id(node.children[1])\n for element in qid:\n self.backend.u(args, element, self.arg_stack)\n\n elif node.type == \"cnot\":\n self._process_cnot(node)\n\n elif node.type == \"expression_list\":\n return node.children\n\n elif node.type == \"binop\":\n raise UnrollerError(\"internal error: _process_node on binop\")\n\n elif node.type == \"prefix\":\n raise UnrollerError(\"internal error: _process_node on prefix\")\n\n elif node.type == \"measure\":\n self._process_measure(node)\n\n elif node.type == \"magic\":\n self.version = node.children[0].value\n self.backend.version(node.children[0])\n\n elif node.type == \"barrier\":\n ids = self._process_node(node.children[0])\n self.backend.barrier(ids)\n\n elif node.type == \"reset\":\n id0 = self._process_bit_id(node.children[0])\n for i, _ in enumerate(id0):\n self.backend.reset(id0[i])\n\n elif node.type == \"if\":\n self._process_if(node)\n\n elif node.type == \"opaque\":\n self._process_gate(node, opaque=True)\n\n elif node.type == \"external\":\n raise UnrollerError(\"internal error: _process_node on external\")\n\n else:\n raise UnrollerError(\"internal error: undefined node type\",\n node.type, \"line=%s\" % node.line,\n \"file=%s\" % node.file)\n return None","def _child_build_new_model(self):\n self._build_new_gp()","def __init__(self):\n self.drones = ZergUnit(UnitTypeId.DRONE, to_count=0)\n self.lings = ZergUnit(UnitTypeId.ZERGLING, to_count=999)\n self.queens = ZergUnit(UnitTypeId.QUEEN, to_count=3)\n self.roaches = ZergUnit(UnitTypeId.ROACH, to_count=100, priority=True)\n self.ravagers = ZergUnit(UnitTypeId.RAVAGER, to_count=0)\n self.defense_spines = DefensiveBuilding(\n unit_type=UnitTypeId.SPINECRAWLER, position_type=DefensePosition.Entrance, to_base_index=1, to_count=3\n )\n self.gas = StepBuildGas(to_count=3)\n\n unit_building = BuildOrder(\n [\n Step(None, self.drones, skip_until=self.should_build_drones),\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.defense_spines),\n Step(\n RequiredAll([UnitExists(UnitTypeId.ROACHWARREN), UnitExists(UnitTypeId.ROACH)]),\n self.ravagers,\n skip_until=self.should_build_ravagers,\n ),\n Step(UnitExists(UnitTypeId.ROACHWARREN), self.roaches),\n Step(\n RequiredAll(\n [\n UnitExists(UnitTypeId.SPAWNINGPOOL),\n UnitExists(\n UnitTypeId.ROACHWARREN,\n include_pending=True,\n include_not_ready=True,\n include_killed=True,\n ),\n ]\n ),\n self.lings,\n ),\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.queens),\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.lings),\n ]\n )\n\n buildings: BuildOrder = BuildOrder(\n [\n Step(None, ActBuilding(UnitTypeId.SPAWNINGPOOL, to_count=1)),\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), ActBuilding(UnitTypeId.ROACHWARREN, to_count=1)),\n Step(None, self.gas, skip_until=self.should_build_gas),\n ]\n )\n\n super().__init__(buildings, unit_building)","def childFactory(self, request, childName):\n return None","def _trackable_children(self, save_type=\"checkpoint\", **kwargs):\n dep = super()._trackable_children(save_type, **kwargs)\n dep.pop(_DUMMY_NAME, None)\n return dep","def _addEntity(self, pid, chunks):\n parent = chunks[pid]\n sub = None\n # Find subject\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n if child.func in SubDict:\n sub = child\n if child.func == \"では\":\n if child.negative != 0 or any([val.negative != 0 for key, val in self.G.successors(child.main)]):\n pass\n else:\n sub = None\n if sub:\n self._addNode(parent, sub=sub.main)\n self._addEdge(sub.main, parent.main, label=\"陳述\", etype=\"stat\")\n else:\n self._addNode(parent)\n \n # Lopp through all children\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n # If child is noun\n if child.func in SubDict:\n if child.func == \"では\":\n if child.negative != 0 or any([val.negative != 0 for key, val in self.G.successors(child.main)]):\n pass\n else:\n self._addNode(child)\n self._addEdge(child.main, parent.main, label=child.func, etype=\"attr\")\n elif child.type == 0 and child.func in [\"と\", \"などと\"] and child.id + 1 == parent.id and preprocessText(chunks[parent.parent].main) not in [\"交代\", \"交換\"]:\n self._addNode(child)\n self._addEdge(child.main, parent.main, label=\"並列\", etype=\"para\")\n self._addEdge(parent.main, child.main, label=\"並列\", etype=\"para\")\n self.para.append([child.main, parent.main])\n elif child.type == 0 and child.func in ParallelDict and child.id + 1 == parent.id:\n self._addNode(child)\n self._addEdge(child.main, parent.main, label=\"並列\", etype=\"para\")\n self._addEdge(parent.main, child.main, label=\"並列\", etype=\"para\")\n self.para.append([child.main, parent.main])\n else:\n self._addNode(child)\n self._addEdge(child.main, parent.main, label=child.func, etype=\"attr\")","def build_children(self, protein,amino_position):\n # Add a new state of the protein to the list of proteins.\n for direction in self.direction_options:\n new_protein = copy.deepcopy(protein)\n if new_protein.fold_next_amino(amino_position,direction) == False:\n self.proteins.append(new_protein)","def build(self,\n mode: tf.estimator.ModeKeys,\n outputs: mt.BuildMap):\n with tf.variable_scope(self.name.replace(' ', '_')):\n # Build child block sets\n for blockset in self.children:\n blockset.build(mode, outputs)\n\n outputs[self] = self.children[-1]\n\n pass","def _init_child(self,child,path):\n pass","def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\r\n # pylint: disable=no-member\r\n if depth == 0:\r\n self.get_module.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\r\n else:\r\n self.get_module.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)","def process_deferreds(self):\n if self.deferred_properties.keys():\n if b'interrupt-parent' in self.deferred_properties:\n phandle = struct.unpack('!I', self.deferred_properties[b'interrupt-parent'])[0]\n self.properties['interrupt-parent'] = self.get_phandle(phandle)\n if b'interrupts' in self.deferred_properties:\n interrupt_parent = self.get_inherited('interrupt-parent')\n cell_size = interrupt_parent['#interrupt-cells']\n self.properties['interrupts'] = self.process_interrupts(self.properties['interrupts'], cell_size)\n # Process children vertices in Depth First traversal.\n for child in self.children:\n child.process_deferreds()","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 _prepare(self):\n\n # table of containing directories (to add implicit dependencies to image builds)\n directories: dict[PurePosixPath, set[FileValue]] = dict()\n\n # map plan elements to values\n v: dict[Any, ValueBase] = dict()\n # map plan elements to actions\n a: dict[Any, Action] = dict()\n\n # Create FileValues for WorkFiles found in plan\n for workfile in self.plan.files():\n value = FileValue(workfile)\n v[workfile] = value\n directory = workfile.posix_path.parent\n if directory not in directories:\n directories[directory] = set()\n directories[directory].add(value)\n\n for image in self.plan.images():\n if image.pull_from_registry:\n image_value = RegistryImageValue(image)\n pull_image_action = PullImageAction(image)\n pull_image_action.set_output_image(image_value)\n v[image] = image_value\n a[image] = pull_image_action\n else:\n image_value = ImageToBuildValue(image)\n build_image_action = BuildImageAction(image)\n build_image_action.set_output_image(image_value)\n v[image] = image_value\n a[image] = build_image_action\n # if context dir contains any WorkFiles, add corresponding FileValues as dependencies\n for directory in directories.keys():\n if directory.is_relative_to(image_value._plan_element.build_from_context):\n for file_value in directories[directory]:\n logging.info(\"Implied dependency %s->%s\", file_value, build_image_action)\n build_image_action.add_input(file_value)\n\n for e in self.plan.execs():\n image_value = v[e.image]\n if not isinstance(image_value, ImageValue):\n raise Exception(\"not an ImageValue %s\" % image_value)\n exec_action = ExecAction(e, image_value)\n a[e] = exec_action\n for inp in e.inputs:\n exec_action.add_input(v[inp.workfile])\n v[inp.workfile].add_consumer(exec_action)\n for output in e.outputs:\n exec_action.add_output(v[output.workfile])\n v[output.workfile].set_producer(exec_action)\n\n self.actions = set(a.values())\n self.values = set(v.values())","def __init__(self, isParent):\n UTIL.TASK.ProcessingTask.__init__(self, isParent=isParent)","def _process_children(self, node):\n for kid in node.children:\n self._process_node(kid)","def _create_child_dataset(self, name, shape=None, dtype=None, data=None, **kwds):\n pass","def populate_course(self):\r\n def descend(parent, stack):\r\n xblock_type = stack.pop(0)\r\n for _ in range(2):\r\n child = ItemFactory.create(category=xblock_type, parent_location=parent.location)\r\n if stack:\r\n descend(child, stack)\r\n\r\n descend(self.course, ['chapter', 'sequential', 'vertical', 'problem'])","def assemble_substructure(self):\n\n yield self.task(\"Substation Substructure Assembly\", self.takt_time)\n yield self.task(\"Attach Topside\", self.attach_time)\n substation = FloatingSubstation()\n\n start = self.env.now\n yield self.target.put(substation)\n delay = self.env.now - start\n\n if delay > 0:\n self.submit_action_log(\"Delay: No Wet Storage Available\", delay)","def prepare_content_tree(self):\n for node_id in self.child_nodes:\n node = in_scope(node_id)\n\n if isinstance(node, CaptionNode):\n self.caption = node.argument\n\n if isinstance(node, LabelNode):\n self.setup_label(node)\n\n # node.prepare_content_tree()\n\n out_scope(node)","def make_filiation(self):\n if self.cells is not None:\n filiate_from_bpointer(self.cells)\n# for cell in self.cells:\n# childs = []\n# for cc in self.cells:\n# if cc.bpointer == cell.identifier:\n# childs.append(cc)\n# cc.parent = cell\n# cc.set_division_event()\n# cell.childs = childs\n return","def build_basic_base(self, game_state):\n filter_locations_x = [27, 24, 21, 18, 15, 12]\n for x in filter_locations_x:\n location = [x, 13]\n if game_state.can_spawn(FILTER, location):\n self.spawn_wrapper(game_state, FILTER, location)\n\n\n \"\"\"\n We use Encryptors firewalls because they are cheap and give shields\n This will build the line that our EMPs will use to snipe.\n If they are destroyed we replace them with destructors.\n \"\"\"\n encryptor_locations = []\n for x in range(26, 12, -1):\n # Because of the way pathing works don't need to build behind our Filters saving cores\n if x not in filter_locations_x and x != self.hole_x_location:\n encryptor_locations.append([x, 12])\n \n for location in encryptor_locations:\n if game_state.can_spawn(ENCRYPTOR, location):\n if game_state.turn_number < 2:\n self.spawn_wrapper(game_state, ENCRYPTOR, location)\n else:\n self.spawn_wrapper(game_state, DESTRUCTOR, location)","def generate_children(self):\n # loop over the board in order to obtain all the possible options.\n for i in range(0, len(self.board)):\n for j in range(0, len(self.board[0])):\n if check_board_position(self, i, j):\n # it's possible to place a token, therefore the board must be copied.\n child = copy.deepcopy(self)\n if self.machine_turn:\n # the machine is playing, therefore the token used is the machine one.\n child.board[i][j] = self.__machine\n # change the turn\n child.machine_turn = False\n else:\n # otherwise the human is playing\n child.board[i][j] = self.__human\n # change the turn\n child.machine_turn = True\n # yield the child on demand\n yield child","def create_offspring(environment, parent_1, parent_2, adaptive_mutation, num_offspring):\n\t# create num_offspring children from the parent pair\n\tchildren = []\n\tfor i in range(num_offspring):\n\t\t# apply whole arithmetic recombination to create children\n\t\tchild = recombine(parent_1, parent_2, adaptive_mutation)\n\n\t\t# apply mutation and add child to children list\t\t\n\t\tif adaptive_mutation:\n\t\t\tchild.mutate_self_adaptive()\n\t\telse:\n\t\t\tchild.mutate()\n\t\n\t\t# compute child's fitness after mutation\n\t\tchild.fitness = child.compute_fitness(environment)\n\t\tchildren.append(child)\n\n\treturn children","def init_children(self):\n children = []\n legal_moves = list(chess.Board(self.state).legal_moves)\n for move in legal_moves:\n temp_board = chess.Board(self.state)\n temp_board.push_san(str(move))\n children.append(Node(temp_board.fen(), self))\n self.children = children","def process_tree(tree):\n c = circuit()\n l = line()\n names = {}\n procedures = []\n for lst in tree.children:\n print(lst)\n if type(lst[0]) is str:\n names[lst[0]] = lst[1]\n else:\n procedures.append(lst)\n print(names)\n #print(procedures)\n\n for proc in procedures:\n\n proc_elements_names = proc[0]\n proc_name = proc[1]\n\n #print(proc_elements_names)\n #print(proc_name)\n\n if proc_name == \"set_mode\":\n mode_name = proc_elements_names[0]\n if mode_name != \"draw-mode\": \n c.set_mode(mode_name)\n elif mode_name == \"draw-mode\":\n l1 = line()\n # draw mode is different from other modes\n for element in names:\n e = CompleteElement(element)\n e.set_other_attrs(names[element])\n e.process_other_attrs()\n l1.addElement(e)\n c.connectInSeries(l1)\n c.set_mode(\"draw-mode\")\n \n \n if proc_name == \"series\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n l = l1\n c.connectInSeries(l)\n #raise SyntaxError(\"Alias {0} referrenced before assignment\".format(item[0]))\n\n elif proc_name == \"parallel\":\n l1 = line()\n for element in proc_elements_names:\n l1.addElement(names[element])\n c.connectInParallel(l1)\n l1 = line()\n\n\n elif proc_name == \"add_parallel\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n l1 = line()\n l1.addElement(names[new_element])\n c.connection.append(l1)\n\n\n elif proc_name == \"add_series\":\n new_element = proc_elements_names[1]\n old_element = proc_elements_names[0]\n for ln in c.connection:\n for e in ln.elements:\n if names[old_element] == e:\n ln.addElement(names[new_element])\n\n\n c.evaluate(\"output.png\")\n #print(c)","def _addPredicate(self, pid, chunks):\n parent = chunks[pid]\n sub = None\n obj = None\n aux = list()\n auxlabel = \"\"\n # 1st round find absolute subject & object\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n # Process by categories.\n if child.func in SubDict:\n sub = child\n elif child.func in ObjDict:\n obj = child\n\n # 2nd round find potential subject & object with aux.\n for i in range(len(parent.children)):\n child = chunks[parent.children[i]]\n # Process by categories.\n if child.func in SubDict or child.func in ObjDict:\n continue\n elif child.func in ObjPostDict:\n if not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n elif child.func in SubPassiveObjDict:\n if parent.passive == 1:\n if not obj and child.type in EntityTypeDict:\n obj = child\n elif not sub and child.type in EntityTypeDict:\n sub = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n if not sub and child.type in EntityTypeDict:\n sub = child\n elif not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n elif child.func in ObjPassiveSubDict:\n if parent.passive == 1:\n if not sub and child.type in EntityTypeDict:\n sub = child\n elif not obj and child.type in EntityTypeDict:\n obj = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n if not obj and child.type in EntityTypeDict:\n obj = child\n elif not sub and child.type in EntityTypeDict:\n sub = child\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n else:\n aux.append(child.id)\n auxlabel += \"[{0}]\\n\".format(child.surface)\n\n if parent.passive == 0:\n # Add parent and subject.\n # if sub and obj:\n # parent.main = \"<{0}>[{2}]{1}\".format(sub.main, parent.main, obj.main)\n # elif sub:\n # parent.main = \"<{0}>[NONE]{1}\".format(sub.main, parent.main)\n # elif obj:\n # parent.main = \"<NONE>[{1}]{0}\".format(parent.main, obj.main)\n if sub:\n parent.main = \"<{0}>{1}\".format(sub.main, parent.main)\n self._addNode(parent, sub=sub.main)\n if not self.G.has_node(sub.main):\n self._addNode(sub)\n self._addEdge(sub.main, parent.main, label=\"主体\\n\", etype=\"sub\")\n else:\n self._addNode(parent)\n # Add object.\n if obj:\n if not self.G.has_node(obj.main):\n self._addNode(obj)\n self._addEdge(parent.main, obj.main, label=\"客体\\n\" + auxlabel, etype=\"obj\")\n else:\n # Add obj as sub\n # if sub and obj:\n # parent.main = \"<{0}>[{2}]{1}\".format(sub.main, parent.main, obj.main)\n # elif obj:\n # parent.main = \"<{0}>[NONE]{1}\".format(obj.main, parent.main)\n # elif sub:\n # parent.main = \"<NONE>[{1}]{0}\".format(parent.main, sub.main)\n if obj:\n parent.main = \"<{0}>{1}\".format(obj.main, parent.main)\n self._addNode(parent, sub=obj.main)\n if not self.G.has_node(obj.main):\n self._addNode(obj)\n self._addEdge(obj.main, parent.main, label=\"主体\\n\", etype=\"sub\")\n else:\n self._addNode(parent)\n # Add sub as obj\n if sub:\n if not self.G.has_node(sub.main):\n self._addNode(sub)\n self._addEdge(parent.main, sub.main, label=\"客体\\n\", etype=\"obj\")\n # # Add obj as aux.\n # if obj:\n # aux.append(obj.id)\n # auxlabel += \"[{0}]\\n\".format(obj.surface)\n self._processAux(aux, parent.main, chunks)","def process_children(cls, operation):\n db = cls._core.get_db()\n\n stmnt = \"SELECT OPE_ID, OPE_TYPE FROM OPERATIONS WHERE OPE_OPE_PARENT = ? ORDER BY OPE_INVOKED ;\"\n stmnt_lock = \"UPDATE OPERATIONS SET OPE_STATUS = 1 WHERE OPE_ID = ? ;\"\n cur = db.query(cls._core,stmnt,(operation.get_id(),))\n for row in cur.fetchallmap():\n child_operation = cls.restore_operation(row)\n db.query(cls._core,stmnt_lock,(child_operation.get_id(),),commit=True)\n try:\n cls.process_children(child_operation)\n child_operation.do_workload()\n except Exception,e:\n stmnt_err = \"UPDATE OPERATIONS SET OPE_STATUS = 2 WHERE OPE_ID = ? ;\"\n db.query(cls._core,stmnt_err,(int(row[\"OPE_ID\"]),),commit=True)\n #TODO GENERATE ERROR IN LOG\n raise e\n stmnt_delete = \"DELETE FROM OPERATIONS WHERE OPE_ID = ?;\"\n db.query(cls._core,stmnt_delete,(child_operation.get_id(),),commit=True)","def run(self, parent, blocks):\r\n pass","def _build(self, prefilt=None):\n self.make_filiation()\n if prefilt is not None:\n self.prefilter(filt=prefilt)\n self.make_trees()\n return","def _dfs_assign(self, filetree):\n stack = [filetree]\n while stack:\n node = stack.pop()\n if isinstance(node, tuple) and node[0][\"packmode\"] is None:\n # all children have been seen already, assing packmode\n node = node[0] # unpack the actual node\n weights = defaultdict(int)\n for child in node[\"children\"].values():\n weights[child[\"packmode\"]] += child[\"weight\"]\n packmode, weight = max(weights.items(), key=lambda x: x[1])\n node[\"weight\"] = weight\n node[\"packmode\"] = packmode\n elif node[\"children\"]:\n # schedule that node for computation\n stack.append((node,))\n # visit all children first\n for child in node[\"children\"].values():\n stack.append(child)","def _internal_build(self):\n self.nodes = self.__tree.Nodes()\n self.edges = self.__tree.Edges()\n self.augmentedEdges = {}\n for key, val in self.__tree.AugmentedEdges().items():\n self.augmentedEdges[key] = list(val)\n self.root = self.__tree.Root()\n\n seen = set()\n self.branches = set()\n\n # Find all of the branching nodes in the tree, degree > 1\n # That is, they appear in more than one edge\n for e1, e2 in self.edges:\n if e1 not in seen:\n seen.add(e1)\n else:\n self.branches.add(e1)\n\n if e2 not in seen:\n seen.add(e2)\n else:\n self.branches.add(e2)\n\n # The nodes that are not branches are leaves\n self.leaves = set(self.nodes.keys()) - self.branches\n self.leaves.remove(self.root)","def create_nodes(self):","def _add_children(self, parent, parent_iter):\n parent_gadget = Gadget.from_widget(parent)\n if parent_gadget:\n children = parent_gadget.get_children()\n else:\n children = get_all_children(parent)\n\n for child in children:\n gadget = Gadget.from_widget(child)\n if not gadget:\n if isinstance(child, gtk.Container):\n self._add_children(child, parent_iter)\n else:\n continue\n\n elif not self._find_iter(parent_iter, gadget):\n child_iter = self._model.append(parent_iter, (gadget,))\n self._add_children(child, child_iter)","def __build_test_model_children_tree_1(self) -> Model:\n self.model_builder.clear()\n\n r_a = SystemFile(\"a\", 1024, True)\n r_aa = SystemFile(\"aa\", 512, False)\n r_a.add_child(r_aa)\n r_ab = SystemFile(\"ab\", 512, False)\n r_a.add_child(r_ab)\n r_b = SystemFile(\"b\", 3090, True)\n r_ba = SystemFile(\"ba\", 2048, True)\n r_b.add_child(r_ba)\n r_baa = SystemFile(\"baa\", 2048, False)\n r_ba.add_child(r_baa)\n r_bb = SystemFile(\"bb\", 42, True) # only in remote\n r_b.add_child(r_bb)\n r_bba = SystemFile(\"bba\", 42, False) # only in remote\n r_bb.add_child(r_bba)\n r_bd = SystemFile(\"bd\", 1000, False)\n r_b.add_child(r_bd)\n r_c = SystemFile(\"c\", 1234, False) # only in remote\n r_d = SystemFile(\"d\", 5678, True) # only in remote\n r_da = SystemFile(\"da\", 5678, False) # only in remote\n r_d.add_child(r_da)\n\n l_a = SystemFile(\"a\", 1024, True)\n l_aa = SystemFile(\"aa\", 512, False)\n l_a.add_child(l_aa)\n l_ab = SystemFile(\"ab\", 512, False)\n l_a.add_child(l_ab)\n l_b = SystemFile(\"b\", 1611, True)\n l_ba = SystemFile(\"ba\", 512, True)\n l_b.add_child(l_ba)\n l_baa = SystemFile(\"baa\", 512, False)\n l_ba.add_child(l_baa)\n l_bc = SystemFile(\"bc\", 99, True) # only in local\n l_b.add_child(l_bc)\n l_bca = SystemFile(\"bca\", 99, False) # only in local\n l_bc.add_child(l_bca)\n l_bd = SystemFile(\"bd\", 1000, False)\n l_b.add_child(l_bd)\n\n s_b = LftpJobStatus(0, LftpJobStatus.Type.MIRROR, LftpJobStatus.State.RUNNING, \"b\", \"\")\n s_b.total_transfer_state = LftpJobStatus.TransferState(1611, 3090, 52, 10, 1000)\n s_b.add_active_file_transfer_state(\"ba/baa\", LftpJobStatus.TransferState(512, 2048, 25, 5, 500))\n s_c = LftpJobStatus(0, LftpJobStatus.Type.PGET, LftpJobStatus.State.QUEUED, \"c\", \"\")\n s_d = LftpJobStatus(0, LftpJobStatus.Type.MIRROR, LftpJobStatus.State.QUEUED, \"d\", \"\")\n\n self.model_builder.set_remote_files([r_a, r_b, r_c, r_d])\n self.model_builder.set_local_files([l_a, l_b])\n self.model_builder.set_lftp_statuses([s_b, s_c, s_d])\n return self.model_builder.build_model()","def generate_children(count, parent, life_min, life_max):\n\n types = parent.__subclasses__()\n for i in range(count):\n yield { \n \"class_name\": random.choice(types).__name__, \n \"lifespan\": random.randint(life_min, life_max)\n }","def init_db(self, parent_type, child_type):\n self.parent = Node(self.handler, parent_type)\n self.children = [ Node(self.handler, child_type) for x in range(0, self.SIZE) ]\n for node in self.children:\n Link(self.handler, self.parent.node, node.node, child_type.upper())","def create(self):\n\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"] or sample_info[\"sample_category\"] in [ \"additional_signal_overlap\", \"background_data_estimate\" ]:\n continue\n process_name = sample_info[\"process_name_specific\"]\n for charge_selection in self.charge_selections:\n key_dir = getKey(process_name, charge_selection)\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_RLES ]:\n initDict(self.dirs, [ key_dir, dir_type ])\n if dir_type in [ DKEY_CFGS, DKEY_LOGS ]:\n self.dirs[key_dir][dir_type] = os.path.join(self.configDir, dir_type, self.channel,\n \"_\".join([ charge_selection ]), process_name)\n else:\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel,\n \"_\".join([ charge_selection ]), process_name)\n for dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\n initDict(self.dirs, [ dir_type ])\n if dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\n self.dirs[dir_type] = os.path.join(self.configDir, dir_type, self.channel)\n else:\n self.dirs[dir_type] = os.path.join(self.outputDir, dir_type, self.channel)\n ##print \"self.dirs = \", self.dirs\n\n for key in self.dirs.keys():\n if type(self.dirs[key]) == dict:\n for dir_type in self.dirs[key].keys():\n create_if_not_exists(self.dirs[key][dir_type])\n else:\n create_if_not_exists(self.dirs[key])\n\n inputFileLists = {}\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"] or sample_info[\"sample_category\"] in [ \"additional_signal_overlap\", \"background_data_estimate\" ]:\n continue\n logging.info(\"Checking input files for sample %s\" % sample_info[\"process_name_specific\"])\n inputFileLists[sample_name] = generateInputFileList(sample_name, sample_info, self.max_files_per_job, self.debug)\n \n self.inputFileIds = {}\n for sample_name, sample_info in self.samples.items():\n if not sample_info[\"use_it\"] or sample_info[\"sample_category\"] in [ \"additional_signal_overlap\", \"background_data_estimate\" ]:\n continue\n\n process_name = sample_info[\"process_name_specific\"]\n\n logging.info(\"Creating configuration files to run '%s' for sample %s\" % (self.executable_analyze, process_name)) \n\n is_mc = (sample_info[\"type\"] == \"mc\")\n lumi_scale = 1. if not (self.use_lumi and is_mc) else sample_info[\"xsection\"] * self.lumi / sample_info[\"nof_events\"]\n apply_genWeight = sample_info[\"apply_genWeight\"] if (is_mc and \"apply_genWeight\" in sample_info.keys()) else False\n sample_category = sample_info[\"sample_category\"]\n triggers = sample_info[\"triggers\"]\n apply_trigger_bits = (is_mc and (self.era == \"2015\" or (self.era == \"2016\" and sample_info[\"reHLT\"]))) or not is_mc\n\n for charge_selection in self.charge_selections:\n for central_or_shift in self.central_or_shifts:\n\n inputFileList = inputFileLists[sample_name]\n for jobId in inputFileList.keys():\n if central_or_shift != \"central\" and not is_mc:\n continue\n if central_or_shift.startswith(\"CMS_ttHl_thu_shape_ttH\") and sample_category != \"signal\":\n continue\n if central_or_shift.startswith(\"CMS_ttHl_thu_shape_ttW\") and sample_category != \"TTW\":\n continue\n if central_or_shift.startswith(\"CMS_ttHl_thu_shape_ttZ\") and sample_category != \"TTZ\":\n continue\n\n # build config files for executing analysis code\n key_dir = getKey(process_name, charge_selection)\n key_analyze_job = getKey(process_name, charge_selection, central_or_shift, jobId)\n\n ntupleFiles = inputFileList[jobId]\n if len(ntupleFiles) == 0:\n print \"Warning: ntupleFiles['%s'] = %s --> skipping job !!\" % (key_job, ntupleFiles)\n continue\n self.jobOptions_analyze[key_analyze_job] = {\n 'ntupleFiles' : ntupleFiles,\n 'cfgFile_modified' : os.path.join(self.dirs[key_dir][DKEY_CFGS], \"analyze_%s_%s_%s_%s_%i_cfg.py\" % \\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\n 'histogramFile' : os.path.join(self.dirs[key_dir][DKEY_HIST], \"%s_%s_%s_%i.root\" % \\\n (process_name, charge_selection, central_or_shift, jobId)),\n 'logFile' : os.path.join(self.dirs[key_dir][DKEY_LOGS], \"analyze_%s_%s_%s_%s_%i.log\" % \\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\n 'sample_category' : sample_category,\n 'triggers' : sample_info[\"triggers\"],\n 'charge_selection' : charge_selection,\n 'jet_minPt' : self.jet_minPt,\n 'jet_maxPt' : self.jet_maxPt,\n 'jet_minAbsEta' : self.jet_minAbsEta,\n 'jet_maxAbsEta' : self.jet_maxAbsEta,\n 'hadTau_selection_denominator' : self.hadTau_selection_denominator,\n 'hadTau_selections_numerator' : self.hadTau_selections_numerator,\n 'absEtaBins' : self.absEtaBins,\n ##'use_HIP_mitigation_mediumMuonId' : sample_info[\"use_HIP_mitigation_mediumMuonId\"],\n 'use_HIP_mitigation_mediumMuonId' : True,\n 'is_mc' : is_mc,\n 'central_or_shift' : central_or_shift,\n 'lumi_scale' : 1. if not (self.use_lumi and is_mc) else sample_info[\"xsection\"] * self.lumi / sample_info[\"nof_events\"],\n 'apply_genWeight' : sample_info[\"genWeight\"] if (is_mc and \"genWeight\" in sample_info.keys()) else False,\n 'apply_trigger_bits' : (is_mc and (self.era == \"2015\" or (self.era == \"2016\" and sample_info[\"reHLT\"]))) or not is_mc,\n }\n self.createCfg_analyze(self.jobOptions_analyze[key_analyze_job])\n\n # initialize input and output file names for hadd_stage1\n key_hadd_stage1 = getKey(process_name, charge_selection)\n if not key_hadd_stage1 in self.inputFiles_hadd_stage1:\n self.inputFiles_hadd_stage1[key_hadd_stage1] = []\n self.inputFiles_hadd_stage1[key_hadd_stage1].append(self.jobOptions_analyze[key_analyze_job]['histogramFile'])\n self.outputFile_hadd_stage1[key_hadd_stage1] = os.path.join(self.dirs[DKEY_HIST], \"histograms_harvested_stage1_%s_%s_%s.root\" % \\\n (self.channel, process_name, charge_selection))\n\n # initialize input and output file names for hadd_stage2\n key_hadd_stage1 = getKey(process_name, charge_selection)\n key_hadd_stage2 = getKey(charge_selection)\n if not key_hadd_stage2 in self.inputFiles_hadd_stage2:\n self.inputFiles_hadd_stage2[key_hadd_stage2] = []\n self.inputFiles_hadd_stage2[key_hadd_stage2].append(self.outputFile_hadd_stage1[key_hadd_stage1])\n self.outputFile_hadd_stage2[key_hadd_stage2] = os.path.join(self.dirs[DKEY_HIST], \"histograms_harvested_stage2_%s_%s.root\" % \\\n (self.channel, charge_selection))\n\n logging.info(\"Creating configuration files for executing 'comp_jetToTauFakeRate'\")\n for charge_selection in self.charge_selections:\n key_comp_jetToTauFakeRate_job = getKey(charge_selection)\n key_hadd_stage2 = getKey(charge_selection)\n self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job] = {\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\n 'cfgFile_modified' : os.path.join(\n self.dirs[DKEY_CFGS], \"comp_jetToTauFakeRate_%s_cfg.py\" % charge_selection),\n 'outputFile' : os.path.join(\n self.dirs[DKEY_HIST], \"comp_jetToTauFakeRate_%s.root\" % charge_selection),\n 'logFile' : os.path.join(\n self.dirs[DKEY_LOGS], \"comp_jetToTauFakeRate_%s.log\" % charge_selection),\n 'looseRegion' : \"jetToTauFakeRate_%s/denominator/\" % charge_selection,\n 'tightRegion' : \"jetToTauFakeRate_%s/numerator/\" % charge_selection,\n 'absEtaBins' : self.absEtaBins,\n 'ptBins' : self.ptBins\n }\n self.createCfg_comp_jetToTauFakeRate(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job])\n self.targets.append(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job]['outputFile'])\n\n logging.info(\"Creating configuration files to run 'makePlots'\")\n for charge_selection in self.charge_selections:\n key_makePlots_job = getKey(charge_selection)\n key_hadd_stage2 = getKey(charge_selection)\n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\n 'cfgFile_modified' : os.path.join(\n self.dirs[DKEY_CFGS], \"makePlots_%s_cfg.py\" % self.channel),\n 'outputFile' : os.path.join(\n self.dirs[DKEY_PLOT], \"makePlots_%s.png\" % self.channel),\n 'histogramDir' : \"jetToTauFakeRate_%s\" % charge_selection,\n 'label' : None,\n 'make_plots_backgrounds' : [ \"TT\", \"TTW\", \"TTZ\", \"EWK\", \"Rares\" ],\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n self.cfgFile_make_plots = self.cfgFile_make_plots_denominator\n for absEtaBin in [ \"absEtaLt1_5\", \"absEta1_5to9_9\" ]:\n key_makePlots_job = getKey(charge_selection, absEtaBin, \"denominator\")\n key_hadd_stage2 = getKey(charge_selection)\n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\n 'cfgFile_modified' : os.path.join(\n self.dirs[DKEY_CFGS], \"makePlots_%s_%s_denominator_%s_cfg.py\" % (self.channel, charge_selection, absEtaBin)),\n 'outputFile' : os.path.join(\n self.dirs[DKEY_PLOT], \"makePlots_%s_%s_denominator_%s.png\" % (self.channel, charge_selection, absEtaBin)),\n 'histogramDir' : \"jetToTauFakeRate_%s/denominator/%s\" % (charge_selection, absEtaBin),\n 'label' : None,\n 'make_plots_backgrounds' : [ \"TT\", \"TTW\", \"TTZ\", \"EWK\", \"Rares\" ],\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n for hadTau_selection_numerator in self.hadTau_selections_numerator:\n key_makePlots_job = getKey(charge_selection, absEtaBin, \"numerator\", hadTau_selection_numerator)\n key_hadd_stage2 = getKey(charge_selection)\n self.jobOptions_make_plots[key_makePlots_job] = {\n 'executable' : self.executable_make_plots,\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\n 'cfgFile_modified' : os.path.join(\n self.dirs[DKEY_CFGS], \"makePlots_%s_%s_numerator_%s_%s_cfg.py\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\n 'outputFile' : os.path.join(\n self.dirs[DKEY_PLOT], \"makePlots_%s_%s_numerator_%s_%s.png\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\n 'histogramDir' : \"jetToTauFakeRate_%s/numerator/%s/%s\" % (charge_selection, hadTau_selection_numerator, absEtaBin),\n 'label' : None,\n 'make_plots_backgrounds' : [ \"TT\", \"TTW\", \"TTZ\", \"EWK\", \"Rares\" ],\n }\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\n\n if self.is_sbatch:\n logging.info(\"Creating script for submitting '%s' jobs to batch system\" % self.executable_analyze)\n self.sbatchFile_analyze = os.path.join(self.dirs[DKEY_SCRIPTS], \"sbatch_analyze_%s.py\" % self.channel)\n self.createScript_sbatch_analyze(self.executable_analyze, self.sbatchFile_analyze, self.jobOptions_analyze)\n logging.info(\"Creating script for submitting '%s' jobs to batch system\" % self.executable_comp_jetToTauFakeRate)\n self.sbatchFile_comp_jetToTauFakeRate = os.path.join(self.dirs[DKEY_SCRIPTS], \"sbatch_comp_jetToTauFakeRate.py\")\n self.createScript_sbatch(self.executable_comp_jetToTauFakeRate, self.sbatchFile_comp_jetToTauFakeRate, self.jobOptions_comp_jetToTauFakeRate)\n\n lines_makefile = []\n self.addToMakefile_analyze(lines_makefile)\n self.addToMakefile_hadd_stage1(lines_makefile)\n self.addToMakefile_hadd_stage2(lines_makefile)\n self.addToMakefile_comp_jetToTauFakeRate(lines_makefile)\n self.addToMakefile_make_plots(lines_makefile)\n self.createMakefile(lines_makefile)\n \n logging.info(\"Done\")","def _generate_children(self) -> list:\n if self.debug: print(f\"StateNode._generate_children()\")\n return [self.transition(x) for x in self.actions()]","def __init__(self, message_log_file, stepSize, TER1, TER2, RSC, sizingMethod, iApartments, sqm, specDemandTh, ID, solutionPoolIntensity, absGap, envirmt=None):\n super(TreeAgent, self).__init__(message_log_file, stepSize, TER1, TER2, RSC, sizingMethod, iApartments, sqm, specDemandTh, ID, solutionPoolIntensity, absGap, envirmt=envirmt)\n\n #Variables for pseudo tree network structure\n # Pseudo tree is generated according to algorithm presented in\n # Thomas Leaute, Boi Faltings:\n # \"Protecting Privacy through Distributed Computation in Multi-agent Decision Making\"\n # Online Appendix 2: DFS Tree Generation Algorithm\n # Journal of Artificial Intelligence Research 47 (2013) pp. 649-695\n #\n # with slight modifications by Sonja Kolen\n self.Children = [] # in pseudo tree: list of IDs of known children\n self.Parent = [] # in pseudo tree: ID of parent (root has no parent)\n self.PseudoChildren = [] # in pseudo tree: list of IDs of known pseudo children (if any)\n self.PseudoParents = [] # in pseudo tree: list of IDs of known pseudo parents (if any)\n self.OpenNeighbors = [] # during pseudo tree generation: saves a list of neighbors that still need to be processed\n self.Visited = 0 # if all open neighbors are processed this flag is set to 1\n self.statusTree = 0 # saves the current status of the pseudo tree at the current node\n self.noOfChildReplies = 0 # saves the number of child replies\n\n # Variables used for tree-based coordination algorithm\n self.EConsumptionChildCurves = [] # Energy consumption curves of all children\n self.EConsumptionChildCurvesRec = [] # Received energy consumption curves of all children\n self.noOfConsumptionCurvesReceived = 0 # How many energy consumption curves were received?\n self.state_coordination = 0 # current state of coordination alg\n self.ERemainderLocal = [] # local view on energy remainder\n self.noNewRounds = 0 # saves the number of new coordination rounds started\n self.scheduleIdxOfPreviousRound = -1 # save schedule of previous round","def _validateChildren(self) -> None:\n\t\t# Check whether we already are in validation the children (ie prevent unfortunate recursion by the Dispatcher)\n\t\tif self.__validating:\n\t\t\treturn\n\t\tself.__validating = True\n\n\t\t# Only get the CINs in raw format. Instantiate them as resources if needed\n\t\tcinsRaw = cast(List[JSON], sorted(CSE.storage.directChildResources(self.ri, T.CIN, raw = True), key = lambda x: x['ct']))\n\t\tcni = len(cinsRaw)\t\t\t\n\t\t\t\n\t\t# Check number of instances\n\t\tif (mni := self.mni) is not None:\n\t\t\twhile cni > mni and cni > 0:\n\t\t\t\t# Only instantiate the <cin> when needed here for deletion\n\t\t\t\tcin = Factory.resourceFromDict(cinsRaw[0]).resource\n\t\t\t\tL.isDebug and L.logDebug(f'cni > mni: Removing <cin>: {cin.ri}')\n\t\t\t\t# remove oldest\n\t\t\t\t# Deleting a child must not cause a notification for 'deleteDirectChild'.\n\t\t\t\t# Don't do a delete check means that CNT.childRemoved() is not called, where subscriptions for 'deleteDirectChild' is tested.\n\t\t\t\tCSE.dispatcher.deleteResource(cin, parentResource = self, doDeleteCheck = False)\n\t\t\t\tdel cinsRaw[0]\t# Remove from list\n\t\t\t\tcni -= 1\t# decrement cni when deleting a <cin>\n\n\t\t# Calculate cbs of remaining cins\n\t\tcbs = sum([ each['cs'] for each in cinsRaw])\n\n\t\t# check size\n\t\tif (mbs := self.mbs) is not None:\n\t\t\twhile cbs > mbs and cbs > 0:\n\t\t\t\t# Only instantiate the <cin> when needed here for deletion\n\t\t\t\tcin = Factory.resourceFromDict(cinsRaw[0]).resource\n\t\t\t\tL.isDebug and L.logDebug(f'cbs > mbs: Removing <cin>: {cin.ri}')\n\t\t\t\t# remove oldest\n\t\t\t\tcbs -= cin.cs\n\t\t\t\t# Deleting a child must not cause a notification for 'deleteDirectChild'.\n\t\t\t\t# Don't do a delete check means that CNT.childRemoved() is not called, where subscriptions for 'deleteDirectChild' is tested.\n\t\t\t\tCSE.dispatcher.deleteResource(cin, parentResource = self, doDeleteCheck = False)\n\t\t\t\tdel cinsRaw[0]\t# Remove from list\n\t\t\t\tcni -= 1\t# decrement cni when deleting a <cin>\n\n\t\t# Some attributes may have been updated, so store the resource \n\t\tself['cni'] = cni\n\t\tself['cbs'] = cbs\n\t\tself.dbUpdate()\n\t\n\t\t# End validating\n\t\tself.__validating = False","def createChildren(self):\n children = []\n posMoves = self.checkPossibleMoves()\n\n for i in range(self.nrOfCars):\n if len(posMoves[i]) > 0:\n for j in range(len(posMoves[i])):\n child = copy(self.changeable)\n child[i] = child[i] + posMoves[i][j]\n children.append(child)\n\n return children","def _build_components(self):\n\n # Build dataframes.\n dfs = {}\n for df_name, df_repr in self._repr.dataframes.items():\n cols = {}\n for i in range(len(df_repr.columns)):\n col = df_repr.columns[i]\n cols[col.name] = {}\n cols[col.name]['index'] = i\n cols[col.name]['type'] = col.vtype\n dfs[df_name] = DataFrame(df_name, cols)\n self._dataframes = dfs\n\n # Build operator contexts.\n self._op_ctxs = {}\n for _, op_repr in self._repr.operators.items():\n op_ctx = OperatorContext(op_repr, self.dataframes)\n\n if op_ctx.name == '_start_op':\n op_ctx.add_task_start_handler(self.graph_start_handlers)\n elif op_ctx.name == '_end_op':\n op_ctx.add_task_finish_handler(self.graph_finish_handlers)\n else:\n op_ctx.add_task_start_handler(self.task_start_handlers)\n op_ctx.add_task_ready_handler(self.task_ready_handlers)\n op_ctx.add_task_finish_handler(self.task_finish_handlers)\n\n self._op_ctxs[op_ctx.name] = op_ctx","def create_child_nodes(current_node: Node, goal: list, generated: set) -> list:\n\n children = []\n locations = state_to_locations(current_node.state)\n blank = locations[0]\n\n # Moving blank to the left\n if blank[1] != 0:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0], new_locations[0][1] - 1)\n # Modifies the location of the blank in the new list\n \"\"\" Note that the index 0 represents the first column. So long as \n the blank is not in the first column, it can be moved to the left.\"\"\"\n neighbor = current_node.state[blank[0]][blank[1] - 1]\n # Finds the number on the tile to the left of the blank\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] + 1)\n # Modifies the location of the neighbor in the new list\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('L')\n new_state = locations_to_state(new_locations)\n # Constructs the new state by calling locations_to_state\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n \"\"\" Append the child node to the list only if it's not a \n repeated state.\"\"\"\n\n # Moving blank to the right\n if blank[1] != 3:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0], new_locations[0][1] + 1)\n \"\"\" Similar to the case above: so long as the blank is not in the fourth \n column, it can be moved to the right.\"\"\"\n neighbor = current_node.state[blank[0]][blank[1] + 1]\n # Finds the number on the tile to the right of the blank\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] - 1)\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('R')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n # Moving blank up\n if blank[0] != 0:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0] - 1, new_locations[0][1])\n \"\"\" So long as the blank is not in the first row, it can be moved up.\"\"\"\n neighbor = current_node.state[blank[0] - 1][blank[1]]\n # Finds the number on the tile above the blank\n new_locations[neighbor] = (new_locations[neighbor][0] + 1, new_locations[neighbor][1])\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('U')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n # Moving the blank down\n if blank[0] != 3:\n new_locations = copy.deepcopy(locations)\n new_locations[0] = (new_locations[0][0] + 1, new_locations[0][1])\n \"\"\" So long as the blank is not in the fourth row, it can be moved down.\"\"\"\n neighbor = current_node.state[blank[0] + 1][blank[1]]\n # Finds the number on the tile below the blank\n new_locations[neighbor] = (new_locations[neighbor][0] - 1, new_locations[neighbor][1])\n new_path_history = copy.deepcopy(current_node.path_history)\n new_path_history.append('D')\n new_state = locations_to_state(new_locations)\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\n heuristic_cal(new_state, goal), new_path_history)\n if new_node not in generated:\n children.append(new_node)\n\n return children","def _populateChild(self, populateAll=False):\n pass","def gen_model(children, tree_structure):\n referenced = False\n extended = False\n for child in children:\n #print child.arg\n node = dict()\n extended = False\n if hasattr(child, 'substmts'):\n for attribute in child.substmts:\n # process the 'type' attribute:\n # Currently integer, enumeration and string are supported.\n if attribute.keyword == 'type':\n if len(attribute.arg.split(':'))>1:\n attribute.arg = attribute.arg.split(':')[-1]\n # Firstly, it is checked if the attribute type has been previously define in typedefs.\n if attribute.arg in TYPEDEFS:\n if TYPEDEFS[attribute.arg]['type'][:3] == 'int':\n node['type'] = 'integer'\n node['format'] = TYPEDEFS[attribute.arg]['format']\n elif TYPEDEFS[attribute.arg]['type'] == 'enumeration':\n node['type'] = 'string'\n node['enum'] = [e\n for e in TYPEDEFS[attribute.arg]['enum']]\n # map all other types to string\n else:\n node['type'] = 'string'\n elif attribute.arg[:3] == 'int':\n node['type'] = 'integer'\n node['format'] = attribute.arg\n elif attribute.arg == 'decimal64':\n node['type'] = 'number'\n node['format'] = 'double'\n elif attribute.arg == 'boolean':\n node['type'] = attribute.arg\n elif attribute.arg == 'enumeration':\n node['type'] = 'string'\n node['enum'] = [e[0]\n for e in attribute.i_type_spec.enums]\n # map all other types to string\n else:\n node['type'] = 'string'\n elif attribute.keyword == 'mandatory':\n parent_model = to_upper_camelcase(child.parent.arg)\n if parent_model not in PARENT_MODELS.keys():\n PARENT_MODELS[parent_model] = {'models':[],'discriminator':to_lower_camelcase(child.arg)}\n # Process the reference to another model.\n # We differentiate between single and array references.\n elif attribute.keyword == 'uses':\n if len(attribute.arg.split(':'))>1:\n attribute.arg = attribute.arg.split(':')[-1]\n\n ref = to_upper_camelcase(attribute.arg)\n ref = '#/definitions/' + ref\n if str(child.keyword) == 'list':\n node['items'] = {'$ref': ref}\n node['type'] = 'array'\n for attribute in child.substmts:\n if attribute.keyword == 'key':\n listkey = to_lower_camelcase(attribute.arg)\n if listkey:\n node['x-key'] = listkey\n referenced = True\n elif str(child.keyword) == 'grouping':\n ref = to_upper_camelcase(attribute.arg)\n if ref in tree_structure:\n PARENT_MODELS[ref]['models'].append(child.arg)\n list_properties = [item for item in tree_structure[ref]['properties']]\n ref = '#/definitions/' + ref\n node['allOf'] = []\n node['allOf'].append({'$ref': ref})\n index = 0\n for i in range(0, len(child.i_children)):\n #print len(child.i_children)\n if to_lower_camelcase(child.i_children[index].arg) in list_properties:\n del child.i_children[index]\n else:\n index+=1\n extended = True\n else:\n pending_models.append(child)\n else:\n node['$ref'] = ref\n referenced = True\n\n # When a node contains a referenced model as an attribute the algorithm\n # does not go deeper into the sub-tree of the referenced model.\n if not referenced :\n if not extended:\n node = gen_model_node(child, node)\n else:\n node_ext = dict()\n node_ext = gen_model_node(child, node_ext)\n node['allOf'].append( node_ext)\n extended = False\n\n # Leaf-lists need to create arrays.\n # Copy the 'node' content to 'items' and change the reference\n if child.keyword == 'leaf-list':\n ll_node = {'type': 'array', 'items': node}\n node = ll_node\n # Groupings are class names and upper camelcase.\n # All the others are variables and lower camelcase.\n if child.keyword == 'grouping':\n tree_structure[to_upper_camelcase(child.arg)] = node\n else:\n tree_structure[to_lower_camelcase(child.arg)] = node\n # TODO: do we really need this return value? We are working on the\n # reference anyhow.\n return tree_structure","def _create_channels(self):\n for name, creator in CommonBase.get_channels(self.__class__):\n for cls, id in creator.pairs:\n # If channel pair was created with MultiChannelCreator\n # add channel interface to collection with passed attribute name\n if isinstance(creator, CommonBase.MultiChannelCreator):\n child = self.add_child(cls, id, collection=name, **creator.kwargs)\n # If channel pair was created with ChannelCreator\n # name channel interface with passed attribute name\n elif isinstance(creator, CommonBase.ChannelCreator):\n child = self.add_child(cls, id, attr_name=name, **creator.kwargs)\n else:\n raise ValueError(\"Invalid class '{creator}' for channel creation.\")\n child._protected = True","def _create_xblock_children(self, parent_loc, xblock_descriptions):\r\n for desc in xblock_descriptions:\r\n loc = self._create_xblock(parent_loc, desc)\r\n self._create_xblock_children(loc, desc.children)\r\n\r\n self._publish_xblock(parent_loc)","def __init__(self, **kwargs):\n FeatureDefinition.__init__(self)\n\n nbTypes = self._getTypeNumber(kwargs)\n \n print(\"BETTER FEATURES\")\n \n \n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"xywh\", Pipeline([\n ('selector', NodeTransformerXYWH_v2()),\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"neighbors\", Pipeline([\n ('selector', NodeTransformerNeighbors()),\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n , (\"1hot\", Pipeline([\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\n ])\n )\n ])\n grid_line_transformer = GridLine_NodeTransformer_v2()\n \n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \n \n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\n (\"1hot\", Pipeline([\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\n ])\n )\n , (\"boolean\", Pipeline([\n ('boolean', EdgeBooleanFeatures_v2())\n ])\n )\n , (\"numerical\", Pipeline([\n ('selector', EdgeNumericalSelector()),\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\n ])\n )\n ] )\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\n edge_BL_transformer,\n edge_BL_transformer, # useless but required\n edge_LL_transformer \n ])\n \n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer","def __init__(self):\n self.child = {}\n self.isend = False","def makeTree(node,baseName,baseAddress,nodes,parentNode,vars,isGenerated):\n \n if (isGenerated == None or isGenerated == False) and node.get('generate') is not None and node.get('generate') == 'true':\n generateSize = parseInt(node.get('generate_size'))\n generateAddressStep = parseInt(node.get('generate_address_step'))\n generateIdxVar = node.get('generate_idx_var')\n for i in range(0, generateSize):\n vars[generateIdxVar] = i\n makeTree(node, baseName, baseAddress + generateAddressStep * i, nodes, parentNode, vars, True)\n return\n newNode = Node()\n name = baseName\n if baseName != '': name += '.'\n if node.get('id') is not None:\n name += node.get('id')\n name = substituteVars(name, vars)\n newNode.name = name\n if node.get('description') is not None:\n newNode.description = node.get('description')\n address = baseAddress\n if node.get('address') is not None:\n address = baseAddress + parseInt(node.get('address'))\n newNode.address = address\n newNode.real_address = (address<<2)+0x64000000\n newNode.permission = node.get('permission')\n newNode.mask = parseInt(node.get('mask'))\n newNode.isModule = node.get('fw_is_module') is not None and node.get('fw_is_module') == 'true'\n if node.get('sw_monitor_warn_min_threshold') is not None:\n newNode.warn_min_value = node.get('sw_monitor_warn_min_threshold') \n if node.get('sw_monitor_error_min_threshold') is not None:\n newNode.error_min_value = node.get('sw_monitor_error_min_threshold') \n nodes[name] = newNode\n if parentNode is not None:\n parentNode.addChild(newNode)\n newNode.parent = parentNode\n newNode.level = parentNode.level+1\n for child in node:\n makeTree(child,name,address,nodes,newNode,vars,False)","def initialize_context(self):\n # a task's workdir == context.flow_workdir / context.flow_config.workdir / context.task_config.workdir\n # If any of the above dirs is absolute dir, then use it instead\n super().initialize_context()\n # only inject the up-most flow's info\n if not flowsaber.context.up_flow:\n flow_workdir = self.config_dict['workdir']\n if not Path(flow_workdir).is_absolute():\n flow_workdir = str(Path().resolve().absolute())\n self.context.update({\n 'flow_id': self.config_dict['id'],\n 'flow_name': self.config_dict['name'],\n 'flow_full_name': self.config_dict['full_name'],\n 'flow_labels': self.config_dict['labels'],\n 'flow_workdir': flow_workdir,\n 'top_flow_config': self.config_dict\n })","def build(self, *args, **kwargs):\n raise NotImplemented(\"Implement me in children!\")","def __init__(self, system, location, definition, descriptor,\r\n instance_state=None, shared_state=None, metadata=None, static_data=None, **kwargs):\r\n self.instance_state = instance_state\r\n self.display_name = instance_state.get('display_name', \"Open Ended\")\r\n\r\n # We need to set the location here so the child modules can use it\r\n system.set('location', location)\r\n self.system = system\r\n\r\n # Tells the system which xml definition to load\r\n self.current_task_number = instance_state.get('current_task_number', 0)\r\n # This loads the states of the individual children\r\n self.task_states = instance_state.get('task_states', [])\r\n #This gets any old task states that have been persisted after the instructor changed the tasks.\r\n self.old_task_states = instance_state.get('old_task_states', [])\r\n # Overall state of the combined open ended module\r\n self.state = instance_state.get('state', self.INITIAL)\r\n\r\n self.student_attempts = instance_state.get('student_attempts', 0)\r\n self.weight = instance_state.get('weight', 1)\r\n\r\n # Allow reset is true if student has failed the criteria to move to the next child task\r\n self.ready_to_reset = instance_state.get('ready_to_reset', False)\r\n self.max_attempts = instance_state.get('max_attempts', MAX_ATTEMPTS)\r\n self.is_scored = instance_state.get('graded', IS_SCORED) in TRUE_DICT\r\n self.accept_file_upload = instance_state.get('accept_file_upload', ACCEPT_FILE_UPLOAD) in TRUE_DICT\r\n self.skip_basic_checks = instance_state.get('skip_spelling_checks', SKIP_BASIC_CHECKS) in TRUE_DICT\r\n\r\n if system.open_ended_grading_interface:\r\n self.peer_gs = PeerGradingService(system.open_ended_grading_interface, system)\r\n else:\r\n self.peer_gs = MockPeerGradingService()\r\n\r\n self.required_peer_grading = instance_state.get('required_peer_grading', 3)\r\n self.peer_grader_count = instance_state.get('peer_grader_count', 3)\r\n self.min_to_calibrate = instance_state.get('min_to_calibrate', 3)\r\n self.max_to_calibrate = instance_state.get('max_to_calibrate', 6)\r\n self.peer_grade_finished_submissions_when_none_pending = instance_state.get(\r\n 'peer_grade_finished_submissions_when_none_pending', False\r\n )\r\n\r\n due_date = get_extended_due_date(instance_state)\r\n grace_period_string = instance_state.get('graceperiod', None)\r\n try:\r\n self.timeinfo = TimeInfo(due_date, grace_period_string)\r\n except Exception:\r\n log.error(\"Error parsing due date information in location {0}\".format(location))\r\n raise\r\n self.display_due_date = self.timeinfo.display_due_date\r\n\r\n self.rubric_renderer = CombinedOpenEndedRubric(system, True)\r\n rubric_string = stringify_children(definition['rubric'])\r\n self._max_score = self.rubric_renderer.check_if_rubric_is_parseable(rubric_string, location, MAX_SCORE_ALLOWED)\r\n\r\n # Static data is passed to the child modules to render\r\n self.static_data = {\r\n 'max_score': self._max_score,\r\n 'max_attempts': self.max_attempts,\r\n 'prompt': definition['prompt'],\r\n 'rubric': definition['rubric'],\r\n 'display_name': self.display_name,\r\n 'accept_file_upload': self.accept_file_upload,\r\n 'close_date': self.timeinfo.close_date,\r\n 's3_interface': self.system.s3_interface,\r\n 'skip_basic_checks': self.skip_basic_checks,\r\n 'control': {\r\n 'required_peer_grading': self.required_peer_grading,\r\n 'peer_grader_count': self.peer_grader_count,\r\n 'min_to_calibrate': self.min_to_calibrate,\r\n 'max_to_calibrate': self.max_to_calibrate,\r\n 'peer_grade_finished_submissions_when_none_pending': (\r\n self.peer_grade_finished_submissions_when_none_pending\r\n ),\r\n }\r\n }\r\n\r\n self.task_xml = definition['task_xml']\r\n self.location = location\r\n self.fix_invalid_state()\r\n self.setup_next_task()","def _create_child_group(self, name) -> \"GroupBase\":\n pass","def __initChild(self):\n if self.__child is None:\n self.__child = []\n self._populateChild()","def create_child_with_current_counts(self):\n\t\tself.tree.children.append(self.tree.makeTree(self.tree.root, self.tree, self.tree))","def startTreeBasedCoord(self):\n self.log_message('ID {0} starts Load Propagation Optimization'.format(self.CommID))\n #self.MsgReceiveCount_interval = 0\n #self.MsgSendCount_interval = 0\n\n self.noOfTimesteps = (self.toTime - self.fromTime) / self.stepSize + 1\n\n # calculate pool of schedules (also saved in self.schedules) and schedule load curves\n if self.getTER1() != 0: # if not a gas boiler\n self.calcSchedulePool(self.fromTime, self.toTime)\n self.calcScheduleConsumptionCurves()\n\n if not self.Parent: #root node\n random.seed() # initialize pseudo random number generator\n\n\n\n # leave nodes select initial best schedule from schedule pool based on fluctuations curve and propagate their load to parent\n if not self.Children:\n #self.ChildrenProcessed = [0 for x in range(len(self.Children))]\n if self.getTER1() != 0: # not a gas boiler\n self.selectBestSchedule(copy.deepcopy(self.ERemainderLocal))\n self.setSOC(self.SOCEnd[self.chosenScheduleIndex])\n self.setStateModlvl(self.chosenSchedule[-1])\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(self.EConsumptionChosenSchedule)])\n else:\n zeros = [0 for x in range(len(self.ERemainderLocal))]\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(zeros)])\n\n else: # if not a leave node\n self.EConsumptionChildCurves = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\n self.EConsumptionChildCurvesRec = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\n self.noOfConsumptionCurvesReceived = 0\n #self.ChildLoadCurvesChosen = [0 for x in range(len(self.Children))]\n return","def visit_children(self, func):\n for child in self._children:\n func(child)","def make_objects(self):\n pass","def build(self, parent):\n raise NotImplementedError","def generate_children(self, current_state):\n # Define a list of the possible moves that this current state can make\n list_of_possible_moves = []\n\n # Find the index of the '0' tile\n index = current_state.index('0')\n\n # Check all the possible moves and see which are possible for this current state\n move_up_copy = current_state.copy()\n result = self.move_up(move_up_copy)\n if result[0] > 0:\n list_of_possible_moves.append((move_up_copy, self.cost_of_move_up, 'move_up', result[1]))\n\n move_down_copy = current_state.copy()\n result = self.move_down(move_down_copy)\n if result[0] > 0:\n list_of_possible_moves.append((move_down_copy, self.cost_of_move_down, 'move_down', result[1]))\n\n move_left_copy = current_state.copy()\n result = self.move_left(move_left_copy)\n if result[0] > 0:\n list_of_possible_moves.append((move_left_copy, self.cost_of_move_left, 'move_left', result[1]))\n\n move_right_copy = current_state.copy()\n result = self.move_right(move_right_copy)\n if result[0] > 0:\n list_of_possible_moves.append((move_right_copy, self.cost_of_move_right, 'move_right', result[1]))\n\n # Two possible moves can be done if the wrap is allowed\n if self.can_move_wrap(index):\n # The regular (horizontal) wrap\n regular_wrap_copy = current_state.copy()\n result = self.wrap(regular_wrap_copy)\n if result[0] > 0:\n list_of_possible_moves.append((regular_wrap_copy, self.cost_of_wrap_move, 'wrap', result[1]))\n\n # The scaled-up (vertical) wrap\n scaled_wrap_copy = current_state.copy()\n result = self.wrap_scale(scaled_wrap_copy)\n if result[0] > 0:\n list_of_possible_moves.append((scaled_wrap_copy, self.cost_of_wrap_move, 'wrap_scale', result[1]))\n # end: if\n\n # Two possible moves can be done if the diagonal action is allowed\n if self.can_move_diagonally(index):\n # The diagonal adjacent:\n diagonal_adjacent_copy = current_state.copy()\n result = self.diagonal_adjacent(diagonal_adjacent_copy)\n list_of_possible_moves.append(\n (diagonal_adjacent_copy, self.cost_of_diagonal_adjacent, 'diagonal_adjacent', result[1]))\n\n # The diagonal across:\n diagonal_across_copy = current_state.copy()\n result = self.diagonal_across(diagonal_across_copy)\n list_of_possible_moves.append(\n (diagonal_across_copy, self.cost_of_diagonal_across, 'diagonal_across', result[1]))\n # end: if\n\n # Return the list of possible moves\n return list_of_possible_moves","def _monit(self):\n # For each children\n for index, (cls, kwargs, proc) in enumerate(self._children):\n\n # Spawn children if required\n if proc is None:\n\n try:\n self._children[index][2] = cls(**kwargs)\n self._children[index][2].start()\n except Exception as e:\n self._children.pop(index)\n logger.error(f'Could not instantiate/spawn child \\'{cls.__name__}\\' due to: {str(e)}')\n logger.info(f'Removed child \\'{cls.__name__}\\' from processes list.')\n\n elif not (proc.is_alive() or proc.exitcode is None):\n\n # Join process and delete instance\n proc.join(timeout=0.1)\n self._children[index][2] = None","def parents_loop(self):\r\n while len(self.parents) > 0:\r\n children = 0\r\n self.parent1 = random.choice(self.parents)\r\n index = self.parents.index(self.parent1)\r\n del self.parents[index]\r\n\r\n self.parent2 = random.choice(self.parents)\r\n index = self.parents.index(self.parent2)\r\n del self.parents[index]\r\n\r\n while children < 2:\r\n self.child = copy.deepcopy(self.parent1)\r\n \r\n self.battery_loop()\r\n\r\n childsolution = random_algo.Random(self.child, self.cable_cost, self.battery_cost)\r\n childsolution.change_battery_or_house('change_battery')\r\n childsolution.change_battery_or_house('change_house')\r\n\r\n if (self.child.valid_solution() and self.child not in self.district_population\r\n and self.child not in self.best_districts and self.child not in self.worst_districts):\r\n self.district_population.append(self.child)\r\n self.cost_populations.append(self.child.total_cost(self.battery_cost, self.cable_cost))\r\n children += 1","def initialize_children(self, bibs):\n\t\tpass","def emp_line_strategy(self, game_state):\n self.build_basic_base(game_state)\n\n \"\"\"\n Build corner defense.\n \"\"\"\n self.build_defences(game_state)\n\n \"\"\"\n Finally deploy our information units to attack.\n \"\"\"\n self.deploy_attackers(game_state)","def _makeAndAssignSpecialties(self):\n workflowTool = getToolByName(self.portal, 'portal_workflow')\n def makeSpecialties(node, container, explicitSpecialties):\n \"\"\"Make specialties inside `container` according to the tree-shaped dict `node`. Append the created specialties (unless marked as {'associated': False}) to the list `explicitSpecialties`.\"\"\"\n for child in node.get('children', []):\n id = child['id']\n container.invokeFactory(type_name='FSDSpecialty', id=id, title=child['title'])\n newSpecialty = container[id]\n workflowTool.doActionFor(newSpecialty, 'publish')\n if child.get('associated', True):\n explicitSpecialties.append(newSpecialty)\n makeSpecialties(child, newSpecialty, explicitSpecialties)\n \n # Create specialties:\n explicitSpecialties = []\n makeSpecialties({'children':\n [{'id': 'sanitation', 'title': 'Sanitation', 'children':\n [{'id': 'picking-stuff-up', 'title': 'Picking stuff up'},\n {'id': 'hosing-stuff-down', 'title': 'Hosing stuff off'},\n {'id': 'keeping-stuff-from-getting-so-messed-up-to-begin-with', 'title': 'Keeping stuff from getting so dirty in the first place'}]},\n {'id': 'mastication', 'title': 'Mastication', 'associated': False, 'children':\n [{'id': 'chomping', 'title': 'Chomping'}]}]}, self.directory.getSpecialtiesFolder(), explicitSpecialties)\n \n # Assign them to the person:\n rulesetId = getToolByName(self.portal, 'relations_library').getRuleset('people_specialties').getId()\n personUid = self.person.UID()\n explicitSpecialties.reverse() # Otherwise, testSpecialtiesAreOrdered never fails, because specialties tend to get returned by getSpecialties() in the order they were assigned.\n for s in explicitSpecialties:\n process(self.portal, connect=((personUid, s.UID(), rulesetId),)) # You mustmustmust use the Relations API to add references, sayeth Relations/doc/Overview.txt.\n \n # Add a research topic for Sanitation:\n refCatalog = getToolByName(self.portal, 'reference_catalog')\n sanitationRef = refCatalog.getReferences(self.person, relationship='people_specialties', targetObject=self.directory.getSpecialtiesFolder()['sanitation'])[0]\n sanitationRef.getContentObject().setResearchTopic('Picking up sprockets from bowls of soup')","def build_context(component, weight_variables,\n input_filename=\"[Unknown-Filename]\", hierarchical_mode=False):\n for i, regime in enumerate(component.regimes):\n regime.flag = FIRST_REGIME_FLAG + i\n regime.label = regime.name.replace(' ', '').replace('-', '_').upper()\n if not weight_variables:\n weight_variables = {'': guess_weight_variable(component)}\n\n # THIS IS JUST NASTY.\n # TODO - PROPERLY WITH A DICTIONARY.\n FIRST_TRANSITION_FLAG = 5000\n for i, transition in enumerate(component.transitions):\n n = FIRST_TRANSITION_FLAG + i\n transition.label = 'TRANSITION%d'%n\n transition.flag = n\n\n assert component.is_flat()\n weights_as_states = False\n if hierarchical_mode:\n weights_as_states = True\n\n # Close\n component.backsub_all()\n\n # Resolve Randomness:\n rand = NeuronExprRandomBuilder()\n rand.visit(component)\n\n #if rand.has_random_functions():\n # libfilefull = get_ninemlnrnlibfile()\n # libdir = get_ninemlnrnlibdir()\n # print 'LibFileFull', libfilefull\n # if not os.path.exists( libfilefull ):\n # err = 'Random Library Proxy not built: %s.\\nRun make in %s'%(libfilefull, libdir)\n # raise NineMLRuntimeError(err)\n #\n # LD_LIB_PATH = 'LD_LIBRARY_PATH'\n # err = \" *** WARNING CAN'T FIND %s in LD_LIBRARY_PATH\\nTHERE MAY BE A PROBLEM USING RANDOM FUNCTIONS\"%libdir\n # if not LD_LIB_PATH in os.environ:\n # raise NineMLRuntimeError(err)\n # else:\n # if not libdir in os.environ[LD_LIB_PATH]:\n # raise NineMLRuntimeError(err)\n\n event_based = sum(len(list(r.time_derivatives)) for r in component.regimes) == 0\n\n context = {\n \"input_filename\": input_filename,\n \"version\": nineml.__version__,\n \"component\": component,\n \"channels\": build_channels(component),\n \"weight_variables\": weight_variables,\n \"get_weight_variable\": get_weight_variable,\n \"initial_regime\": list(component.regimes)[0].label,\n \"as_expr\": as_expr,\n \"deriv_func_args\": deriv_func_args,\n \"ode_for\": ode_for,\n\n # Added by Mike:\n \"weights_as_states\": weights_as_states,\n 'get_on_event_channel': get_on_event_channel,\n 'random_functions': rand.get_modl_function_defs(),\n\n 'event_based': event_based\n }\n return context","def create_child(parent, idx):\n boardCopy = deepcopy(parent.currentBoardState)\n action = boardCopy.get_available_actions()[idx]\n parent.children[idx] = DecisionTree(boardCopy, action, parent.level+1, parent, strategy=parent.strategy)","def copy_children(self):\n\n # Create a group\n self.fileh.create_group('/', 'agroup')\n # Create several objects there\n for i in range(10):\n # Create a new array\n self.fileh.create_array('/agroup', 'array' + str(i), self.a1)\n # Excercise copy_children\n for i in range(self.nobjects):\n # Create another group for destination\n self.fileh.create_group('/', 'anothergroup' + str(i))\n # Copy children from /agroup to /anothergroup+i\n self.fileh.copy_children('/agroup', '/anothergroup' + str(i))\n # Put a mark\n self.fileh.mark()\n # Unwind all marks sequentially\n for i in range(self.niter):\n t1 = clock()\n for i in range(self.nobjects):\n self.fileh.undo()\n if verbose:\n print(\"u\", end=' ')\n if verbose:\n print()\n undo = clock() - t1\n # Rewind all marks sequentially\n t1 = clock()\n for i in range(self.nobjects):\n self.fileh.redo()\n if verbose:\n print(\"r\", end=' ')\n if verbose:\n print()\n redo = clock() - t1\n\n print((\"Time for Undo, Redo (copy_children):\", undo, \"s, \",\n redo, \"s\"))","def populate_tools_and_factors(self):\n for tool_channel in self.channel_manager.tool_channels:\n if tool_channel.channel_id == \"tools\":\n # These are the core tools\n setattr(self, \"tools\", ToolContainer())\n setattr(self, \"factors\", FactorContainer())\n tool_container = getattr(self, \"tools\")\n factor_container = getattr(self, \"factors\")\n else:\n # This is a plugin, so ends in \"_tools\"\n plugin_name = \"_\".join(tool_channel.channel_id.split(\"_\")[:-1])\n setattr(self.plugins, plugin_name, PluginWrapper())\n plugin = getattr(self.plugins, plugin_name)\n tool_container = plugin.tools\n factor_container = plugin.factors\n\n for tool_stream in tool_channel.streams:\n try:\n # This is the tool initializer\n tool_function = self.channel_manager.get_tool_class(tool_stream.name)\n setattr(tool_container, tool_stream.name, tool_function)\n\n def create_factory_function(tool_func):\n \"\"\"\n This wrapper is needed to capture the tool_function closure\n\n :param tool_func: The tool function\n :return: The factory function\n\n \"\"\"\n base = tool_function.__bases__[0]\n if base == Tool:\n def tool_factory_function(sources, alignment_node=None, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param sources: source nodes\n :param alignment_node: alignment node\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.alignment_node == alignment_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(**parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources,\n alignment_node=alignment_node)\n\n return tool_factory_function\n elif base == MultiOutputTool:\n def tool_factory_function(source, splitting_node=None, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param source: source node\n :param splitting_node: splitting node\n :return: the created factor\n :type source: Node\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.source == source\n and m.splitting_node == splitting_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(**parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n source=source,\n splitting_node=splitting_node)\n\n return tool_factory_function\n\n elif base == AggregateTool:\n def tool_factory_function(sources, alignment_node, aggregation_meta_data, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param aggregation_meta_data: the meta data to aggregate over\n :param sources: source nodes\n :param alignment_node: alignment node\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.alignment_node == alignment_node\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(aggregation_meta_data=aggregation_meta_data, **parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources,\n alignment_node=alignment_node)\n\n return tool_factory_function\n elif base == SelectorTool:\n def tool_factory_function(sources, selector_meta_data, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param selector_meta_data: the meta data to select over\n :param sources: source nodes\n :return: the created factor\n :type sources: list[Node] | tuple[Node] | None\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n # find matching tools (possibly different parameters)\n matches = [f for f in self.current_workflow.factors if\n f.tool.__class__ == tool_func]\n # make sure parameters are all the same\n full_matches = [m for m in matches if m.sources == sources\n and m.selector_meta_data == selector_meta_data\n and dict(m.tool.parameters_dict) == parameters]\n\n if len(full_matches) == 1:\n tool = full_matches[0].tool\n else:\n tool = tool_func(selector_meta_data=selector_meta_data, **parameters)\n\n return dict(\n workflow=self.current_workflow,\n tool=tool,\n sources=sources)\n\n return tool_factory_function\n elif base == PlateCreationTool:\n def tool_factory_function(source, **parameters):\n \"\"\"\n Factory function for creating factors inside a workflow\n\n :param source: source node\n :return: the created factor\n :type source: Node\n\n \"\"\"\n if not self.current_workflow:\n raise ValueError(\"No workflow context - use create_workflow first\")\n\n return dict(\n workflow=self.current_workflow,\n tool=tool_func(**parameters),\n source=source)\n\n return tool_factory_function\n else:\n raise NotImplementedError\n\n setattr(factor_container, tool_stream.name, create_factory_function(tool_function))\n\n except (NameError, AttributeError, ImportError) as e:\n logging.warn('Unable to load tool {}: {}'.format(tool_stream.name, e))","def generate_hierarchy(self,descr):\n # assert the existence of all the keys we need to set up at least on level\n assert 'problem_class' in descr\n assert 'problem_params' in descr\n assert 'dtype_u' in descr\n assert 'dtype_f' in descr\n assert 'sweeper_class' in descr\n assert 'level_params' in descr\n\n # convert problem-dependent parameters consisting of dictionary of lists to a list of dictionaries with only a\n # single entry per key, one dict per level\n pparams_list = self.__dict_to_list(descr['problem_params'])\n # put this newly generated list into the description dictionary (copy to avoid changing the original one)\n descr_new = cp.deepcopy(descr)\n descr_new['problem_params'] = pparams_list\n # generate list of dictionaries out of the description\n descr_list = self.__dict_to_list(descr_new)\n\n # sanity check: is there a transfer class? is there one even if only a single level is specified?\n if len(descr_list) > 1:\n assert 'transfer_class' in descr_new\n assert 'transfer_params' in descr_new\n elif 'transfer_class' in descr_new:\n print('WARNING: you have specified transfer classes, but only a single level...')\n\n # generate levels, register and connect if needed\n for l in range(len(descr_list)):\n\n # check if we have a hook on this list. if not, use default class.\n if 'hook_class' in descr_list[l]:\n hook = descr_list[l]['hook_class']\n else:\n hook = hookclass.hooks\n\n if 'sweeper_params' in descr_list[l]:\n swparams = descr_list[l]['sweeper_params']\n else:\n swparams = {}\n\n if not 'collocation_class' in swparams:\n assert 'collocation_class' in descr_list[l]\n swparams['collocation_class'] = descr_list[l]['collocation_class']\n\n if not 'num_nodes' in swparams:\n assert 'num_nodes' in descr_list[l]\n swparams['num_nodes'] = descr_list[l]['num_nodes']\n\n L = levclass.level(problem_class = descr_list[l]['problem_class'],\n problem_params = descr_list[l]['problem_params'],\n dtype_u = descr_list[l]['dtype_u'],\n dtype_f = descr_list[l]['dtype_f'],\n sweeper_class = descr_list[l]['sweeper_class'],\n sweeper_params = swparams,\n level_params = descr_list[l]['level_params'],\n hook_class = hook,\n id = 'L'+str(l))\n\n self.register_level(L)\n\n if l > 0:\n self.connect_levels(transfer_class = descr_list[l]['transfer_class'],\n transfer_params = descr_list[l]['transfer_params'],\n fine_level = self.levels[l-1],\n coarse_level = self.levels[l])","def __init__(self, mech, nodes, traceable, intermediates, bottomup = True):\n # Internalize arguments for later use\n self.__mech = mech\n self.__traceable = set(traceable)\n self.__intermediates = set(intermediates)\n self.__bottomup = bottomup\n \n # make sure that nodes is a list of nodes\n if isinstance(nodes, Species):\n nodes = [nodes]\n\n # Initialize dictionaries for storing\n # source data\n self.origins = {}\n self.origin_loss = {}\n\n # Producers is a dictionary (keys = species; values = dictionaries of producers) \n # that contains integrated production arrays\n #\n # Example: {'CO': {'Transport': array([8,5,6,...]), ...}}\n self.producers = {}\n \n # Concentrations is a dictionary (keys = species; values dictionary \n # initial, average, and final concentration arrays. Similar to producers\n self.concentrations = {}\n \n # Production is a dictionary of gross production each species\n self.production = {}\n \n # Losses is a dictionary of gross consumption of each species\n self.losses = {}\n\n # Preset traced nodes as those provided by the user\n self.traced = set(nodes)\n \n \n # Storing data about input shapes\n tmp_init = mech('INIT')\n self.__old_shape = tmp_init[list(tmp_init.keys())[0]].shape\n self.__shape = [i for i in self.__old_shape]\n self.__ntimes = mech.mrg.variables['TFLAG'].shape[-3]\n for i, s in enumerate(self.__shape):\n if s == self.__ntimes:\n self.__shape[i] = self.__ntimes + 1\n self.__time_dim = i\n self.__shape = tuple(self.__shape)\n \n self.run()","def check_objects_have_parents_and_are_not_referenced_twice(self):\n # logger.debug(\"ports:\")\n all_objs = crest.get_all_ports(self.model)\n # for o in all_objs:\n # print(o._name, o._parent)\n for obj in all_objs:\n assert all_objs.count(obj) == 1, f\"Port {obj._name} has been used multiple times\"\n assert obj._parent is not None, f\"Port {obj._name} has no parent definition\"\n\n # logger.debug(\"states:\")\n all_objs = crest.get_all_states(self.model)\n # for o in all_objs:\n # print(o._name, o._parent)\n for obj in all_objs:\n assert all_objs.count(obj) == 1, f\"State {obj._name} has been used multiple times\"\n assert obj._parent is not None, f\"State {obj._name} has no parent definition\"\n\n # logger.debug(\"updates:\")\n all_objs = crest.get_all_updates(self.model)\n # for o in all_objs:\n # print(o._name, o._parent)\n for obj in all_objs:\n assert all_objs.count(obj) == 1, f\"Update {obj._name} has been used multiple times\"\n assert obj._parent is not None, f\"Update {obj._name} has no parent definition\"\n\n # logger.debug(\"influences\")\n all_objs = crest.get_all_influences(self.model)\n # for o in all_objs:\n # print(o._name, o._parent)\n for obj in all_objs:\n assert all_objs.count(obj) == 1, f\"Influence {obj._name} has been used multiple times\"\n assert obj._parent is not None, f\"Influence {obj._name} has no parent definition\"\n\n # logger.debug(\"transitions:\")\n all_objs = crest.get_all_transitions(self.model)\n # for o in all_objs:\n # print(o._name, o._parent)\n for obj in all_objs:\n assert all_objs.count(obj) == 1, f\"Transition '{obj._name}' has been used multiple times\"\n assert obj._parent is not None, f\"Transition '{obj._name}' has no parent definition\"","def __init__(self, state, parent, action, path_cost):\n self.state = state\n self.parent = parent\n self.action = action\n self.path_cost = path_cost\n self.depth = 0\n if parent:\n self.depth = parent.depth + 1","def _derived_features(self):\n for created_feature, creator in self.feature_creators.items():\n self.parameters[created_feature] = creator(self.parameters)","def make(config):\n # Create child folders\n for func in (create_basic_structure,\n copy_resources,\n copy_databases,\n copy_libraries,\n copy_security,\n copy_app_actions,\n copy_pages,\n create_application_info_file,\n replace_all_guids):\n\n INFO(\"\")\n INFO(\"+\"*70)\n INFO(\"\")\n func(config)","def _prepareNewChild(self):\n\n # Register exit listener. We cannot immediately spawn new child when we\n # get a modified event. Must wait that child has closed database etc.\n atexit.register(self._childExitHandler)\n\n # Make sure that PID files and locks stay here, because dying child\n # will clear them.\n self.makeLockFile()\n self.makePidFile()\n\n self.storage_index.restore()\n\n notify(NewChildForked(self))\n\n autoinclude.include_deferred()\n fiveconfigure.install_deferred()","def getChildren():","def update_childs(self, _tasks):\n tasks = copy.deepcopy(_tasks)\n for child in tasks.keys():\n\n # only process init state tasks\n if tasks[child].state != self.STATE_INIT:\n continue\n\n # if erased and none\n if not tasks[child].require:\n continue\n\n # process all childs\n for r_tid in tasks[child].require:\n\n # if child id is not me, ignore\n if r_tid != self.tid:\n continue\n\n # success\n elif self.state == self.STATE_SUCCESS:\n tasks[child].del_require(r_tid)\n yield {tasks[child].tid: tasks[child]}\n\n # task running\n elif self.state == self.STATE_RUNNING:\n continue\n\n # task error\n elif self.state < self.STATE_INIT:\n tasks[child].state = self.STATE_DEPENDENCY\n tasks[child].del_require(r_tid)\n\n yield {tasks[child].tid: tasks[child]}\n\n # recurse and mark child of child as dependency error\n for item in tasks[child].update_childs(tasks):\n yield item","def gen_child(self, g, ng, child):\n with About(child.debug, self.relation):\n self.remap_node((g, child), g, child, ng, ng.apply())","def __init__(self, obj, datamodel=None):\n with RecursiveConverter.in_progress:\n self.obj = obj\n self.class_name = obj.__class__.__name__\n self.datamodel = datamodel\n self.is_root = datamodel is None\n if self.is_root:\n RecursiveConverter.converted_modules = {}\n RecursiveConverter.typedefs = []\n self.datamodel = VHDLModule('-', obj)\n\n # recursively convert all child modules\n self.childs = []\n\n def conv(self, node):\n if isinstance(node, VHDLList):\n if node.elements_compatible_typed:\n if isinstance(node.elems[0], VHDLModule):\n if self.is_compatible_with_converted_module(node.elems[0]):\n return\n self.childs.append(RecursiveConverter(node.elems[0].current, node.elems[0]))\n\n else:\n # dynamic list..need to convert all modules\n for x in node.elems:\n if isinstance(x, VHDLModule):\n if self.is_compatible_with_converted_module(x):\n return\n self.childs.append(RecursiveConverter(x.current, x))\n elif isinstance(node, VHDLModule):\n if self.is_compatible_with_converted_module(node):\n return\n self.childs.append(RecursiveConverter(node.current, node))\n\n if self.is_root:\n logger.info(f'Creating top.vhd ...')\n self.top_vhdl = TopGenerator(obj)\n\n # maybe some input/output is a convertible module?\n for node in self.inputs:\n conv(self, node)\n\n for node in self.outputs:\n conv(self, node)\n\n # iterate all functions and discover local variables that may need to be converted\n for x in self.obj.__dict__.values():\n if isinstance(x, PyhaFunc):\n for key, val in x.get_local_types().items():\n if isinstance(val, Hardware):\n node = init_vhdl_type(key, val)\n conv(self, node)\n\n # convert instance elements before the instance itself, recursive\n for node in self.datamodel.elems:\n conv(self, node)\n\n self.red_node = get_objects_rednode(obj)\n convert_name = self.get_module_converted_name(self.datamodel)\n logger.info(f'{convert_name} to VHDL ...')\n\n self.conv = convert(self.red_node, obj) # actual conversion happens here\n\n self.vhdl_conversion = str(self.conv)\n RecursiveConverter.converted_modules[convert_name] = (self.datamodel, self.vhdl_conversion)\n RecursiveConverter.typedefs.extend(self.conv.build_typedefs())","def get_child_resource_nodes(self):\n raise errors.Unimplemented()","def _create_pipeline(self):\n # Add boxes to the pipeline\n if self.box_tag not in self.proto:\n raise Exception(\n \"Box defined in '{0}' has no '<{1}>' declared.\".format(\n self._xmlfile, self.box_tag))\n switch_descs = []\n for box_item in self.proto[self.box_tag]:\n for box_type in box_item.keys():\n\n # Create processing boxes (can be iterative)\n if box_type == self.box_names[0]:\n for boxdesc in box_item[box_type]:\n self._add_box(boxdesc)\n # Create switch boxes\n elif box_type == self.box_names[1]:\n for switchdesc in box_item[box_type]:\n switch_descs.append(switchdesc)\n # Unrecognize box type\n else:\n raise ValueError(\n \"Box structure: '{0}' defined in '{1}' is not \"\n \"supported. Supported boxes are '{2}'.\".format(\n json.dumps(box_item, indent=2), self._xmlfile,\n self.box_names))\n\n # Add switch to the pipeline\n for switchdesc in switch_descs:\n self._add_switch(switchdesc)\n\n # Add links between boxes\n if self.link_tag not in self.proto:\n raise Exception(\n \"Box defined in '{0}' has no '<{1}>' declared.\".format(\n self._xmlfile, self.link_tag))\n for link_item in self.proto[self.link_tag]:\n inner_tag = self.link_tag[:-1]\n for linkdesc in link_item[inner_tag]:\n if is_io_control(linkdesc[self.link_attributes[0]]):\n linktype = \"input\"\n elif is_io_control(linkdesc[self.link_attributes[1]]):\n linktype = \"output\"\n else:\n linktype = \"link\"\n self._add_link(linkdesc, linktype)","def _initialize_trees(self):"],"string":"[\n \"def child_case():\\n result = ObjectContainer()\\n\\n flow1 = Flow(\\\"flow1\\\")\\n result.flow1 = flow1\\n\\n with flow1.add_container(\\\"container1\\\") as container1:\\n result.container1 = container1\\n with container1.add_task(\\\"task1\\\") as task1:\\n result.task1 = task1\\n with container1.add_task(\\\"task2\\\") as task2:\\n result.task2 = task2\\n\\n flow1.requeue()\\n\\n return result\",\n \"def create_child(self):\\n raise NotImplementedError\",\n \"def children(self): # noqa: ANN201\",\n \"def _addChildren(self, pid, chunks):\\n if chunks[pid].type in [0, -1]:\\n self._addEntity(pid, chunks)\\n else:\\n self._addPredicate(pid, chunks)\",\n \"def setup_children(self):\\n # Only generate new children if there are none\\n if len(self.children) == 0:\\n # Create the encoder and decoder genes\\n encoder = EncoderGene(name='encoder',\\n parent=self,\\n spatial_scale=self.hyperparam(\\n 'spatial_scale'))\\n self.children = [encoder]\\n\\n decoder = DecoderGene(name='decoder',\\n parent=self,\\n spatial_scale=self.hyperparam(\\n 'spatial_scale'))\\n\\n self.children.append(decoder)\\n\\n pass\",\n \"def create_children(self):\\n actionCount = len(self.availableActions)\\n self.children = [None] * actionCount\\n\\n # Split creation into multiple threads if this is the master node.\\n if self.level == 0 and USE_THREADS:\\n threads = [None] * actionCount\\n for idx in range(actionCount):\\n threads[idx] = threading.Thread(target=create_child, args=(self, idx))\\n threads[idx].start()\\n for t in threads:\\n t.join()\\n else:\\n for idx in range(actionCount):\\n create_child(self, idx)\\n # Stop making child branches if the most recent child branch already found lethal.\\n if self.children[idx].get_max_win_strength() == WIN_VALUE:\\n self.children = self.children[:idx+1]\\n break\",\n \"def _instantiate__deferred_inits(self, context=None):\\n\\n # For each mechanism in the Process, in backwards order through its _mech_tuples\\n for item in reversed(self._mech_tuples):\\n mech = item[OBJECT_ITEM]\\n mech._deferred_init()\\n\\n # For each inputState of the mechanism\\n for input_state in mech.inputStates.values():\\n input_state._deferred_init()\\n # Restrict projections to those from mechanisms in the current process\\n projections = []\\n for projection in input_state.receivesFromProjections:\\n try:\\n if self in projection.sender.owner.processes:\\n projections.append(projection)\\n except AttributeError:\\n pass\\n self._instantiate__deferred_init_projections(projections, context=context)\\n\\n # For each parameterState of the mechanism\\n for parameter_state in mech.parameterStates.values():\\n parameter_state._deferred_init()\\n self._instantiate__deferred_init_projections(parameter_state.receivesFromProjections)\\n\\n # Label monitoring mechanisms and add _monitoring_mech_tuples to _mech_tuples for execution\\n if self._monitoring_mech_tuples:\\n\\n # Add designations to newly created MonitoringMechanisms:\\n for mech_tuple in self._monitoring_mech_tuples:\\n mech = mech_tuple[OBJECT_ITEM]\\n # If\\n # - mech is a TARGET ObjectiveMechanism, and\\n # - the mech that projects to mech is a TERMINAL for the current process, and\\n # - current process has learning specified\\n # then designate mech as a TARGET\\n if (isinstance(mech, ObjectiveMechanism) and\\n # any(projection.sender.owner.processes[self] == TERMINAL\\n # for projection in mech.inputStates[SAMPLE].receivesFromProjections) and\\n mech.learning_role is TARGET and\\n self.learning\\n ):\\n mech_tuple[0].processes[self] = TARGET\\n else:\\n # mech must be a LearningMechanism;\\n # If a learning_rate has been specified for the process, assign that to all LearningMechanisms\\n # for which a mechanism-specific learning_rate has NOT been assigned\\n if (self.learning_rate is not None and\\n mech.function_object.learning_rate is None):\\n mech.function_object.learning_rate = self.learning_rate\\n\\n # Assign its label\\n mech_tuple[0].processes[self] = MONITORING\\n\\n # Add _monitoring_mech_tuples to _mech_tuples\\n self._mech_tuples.extend(self._monitoring_mech_tuples)\\n\\n # IMPLEMENTATION NOTE:\\n # MonitoringMechanisms for learning are assigned _phaseSpecMax;\\n # this is so that they will run after the last ProcessingMechansisms have run\",\n \"def Children(self) -> _n_1_t_2:\",\n \"def _setup_children(self):\\n\\n for i in xrange(self._nhalos):\\n self._halos[i+1].properties['children'] = []\\n\\n for i in xrange(self._nhalos):\\n host = self._halos[i+1].properties.get('hostHalo', -2)\\n if host > -1:\\n try:\\n self._halos[host+1].properties['children'].append(i+1)\\n except KeyError:\\n pass\",\n \"def _setup_children(self):\\n\\n for i in xrange(self._nhalos):\\n self._halos[i + 1].properties['children'] = []\\n\\n for i in xrange(self._nhalos):\\n host = self._halos[i + 1].properties.get('hostHalo', -2)\\n if host > -1:\\n try:\\n self._halos[host + 1].properties['children'].append(i + 1)\\n except KeyError:\\n pass\",\n \"def create_hierarchy(self):\\n\\t\\tpass\",\n \"def _configure_flowables(self, flowables):\\n if flowables is None:\\n flowables = DEFAULT_FLOWABLES\\n\\n # FlowablesDict-- mainly to upsample CAS numbers for matching\\n self._fm = FlowablesDict()\\n\\n self._fm.new_entry('carbon dioxide', '124-38-9')\\n self._fm.new_entry('Water', '7732-18-5')\\n # we store the child object and use it to signify biogenic CO2 to optionally quell\\n # this strategy depends on the ability to set a query flow's name-- i.e. FlowInterface\\n self._bio_co2 = self._fm.new_entry('carbon dioxide (biotic)', '124-38-9', create_child=True)\\n\\n # now load + merge from file\\n self._fm.load(flowables)\\n\\n # now add all known \\\"biotic\\\" synonyms for CO2 to the biotic child\\n for k in self._fm.synonyms('124-38-9'):\\n if bool(biogenic.search(k)):\\n self._bio_co2.add_term(k)\\n self._fq_map = {fb: set() for fb in self._fm.objects}\",\n \"def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\\r\\n # pylint: disable=no-member\\r\\n if depth == 0:\\r\\n self.load_item.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\\r\\n else:\\r\\n self.load_item.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)\",\n \"def consolidate(self, final_context='adapter'):\\n\\n for context in ORDERED_CONTEXTS:\\n block = getattr(self, context)\\n parent_context = CONTEXTS[context]['parent']\\n\\n # End of parents chain reached\\n if parent_context is None:\\n if block is not None and context == 'adapter':\\n self.adapters.append(block)\\n break\\n\\n parent = getattr(self, parent_context)\\n if block is not None:\\n parent['childs'].append(block)\\n setattr(self, context, None)\\n\\n if context == final_context:\\n break\",\n \"def _child_init(self):\\n self._create_init_gp()\",\n \"def _init_inherit_physical_attributes(self):\\n config = self.person.cosmos.config\\n mother, father = self.person.biological_mother, self.person.biological_father\\n parents = (mother.body, father.body)\\n # Handedness\\n if random.random() < config.heritability_of_handedness:\\n takes_after = random.choice(parents)\\n self.left_handed = Feature(value=takes_after.left_handed, inherited_from=takes_after)\\n self.right_handed = Feature(value=takes_after.right_handed, inherited_from=takes_after)\\n # Hustle\\n if random.random() < config.heritability_of_hustle:\\n takes_after = random.choice(parents)\\n inherited_hustle = takes_after.hustle\\n mutated_hustle = normal(inherited_hustle, config.hustle_mutation_sd)\\n self.hustle = Feature(value=mutated_hustle, inherited_from=takes_after)\\n else:\\n pass # TODO SET UP GENERATING FROM NOTHING\",\n \"def _process_node(self, node):\\n if node.type == \\\"program\\\":\\n self._process_children(node)\\n\\n elif node.type == \\\"qreg\\\":\\n self.qregs[node.name] = int(node.index)\\n self.backend.new_qreg(node.name, int(node.index))\\n\\n elif node.type == \\\"creg\\\":\\n self.cregs[node.name] = int(node.index)\\n self.backend.new_creg(node.name, int(node.index))\\n\\n elif node.type == \\\"id\\\":\\n raise UnrollerError(\\\"internal error: _process_node on id\\\")\\n\\n elif node.type == \\\"int\\\":\\n raise UnrollerError(\\\"internal error: _process_node on int\\\")\\n\\n elif node.type == \\\"real\\\":\\n raise UnrollerError(\\\"internal error: _process_node on real\\\")\\n\\n elif node.type == \\\"indexed_id\\\":\\n raise UnrollerError(\\\"internal error: _process_node on indexed_id\\\")\\n\\n elif node.type == \\\"id_list\\\":\\n # We process id_list nodes when they are leaves of barriers.\\n return [self._process_bit_id(node_children)\\n for node_children in node.children]\\n\\n elif node.type == \\\"primary_list\\\":\\n # We should only be called for a barrier.\\n return [self._process_bit_id(m) for m in node.children]\\n\\n elif node.type == \\\"gate\\\":\\n self._process_gate(node)\\n\\n elif node.type == \\\"custom_unitary\\\":\\n self._process_custom_unitary(node)\\n\\n elif node.type == \\\"universal_unitary\\\":\\n args = self._process_node(node.children[0])\\n qid = self._process_bit_id(node.children[1])\\n for element in qid:\\n self.backend.u(args, element, self.arg_stack)\\n\\n elif node.type == \\\"cnot\\\":\\n self._process_cnot(node)\\n\\n elif node.type == \\\"expression_list\\\":\\n return node.children\\n\\n elif node.type == \\\"binop\\\":\\n raise UnrollerError(\\\"internal error: _process_node on binop\\\")\\n\\n elif node.type == \\\"prefix\\\":\\n raise UnrollerError(\\\"internal error: _process_node on prefix\\\")\\n\\n elif node.type == \\\"measure\\\":\\n self._process_measure(node)\\n\\n elif node.type == \\\"magic\\\":\\n self.version = node.children[0].value\\n self.backend.version(node.children[0])\\n\\n elif node.type == \\\"barrier\\\":\\n ids = self._process_node(node.children[0])\\n self.backend.barrier(ids)\\n\\n elif node.type == \\\"reset\\\":\\n id0 = self._process_bit_id(node.children[0])\\n for i, _ in enumerate(id0):\\n self.backend.reset(id0[i])\\n\\n elif node.type == \\\"if\\\":\\n self._process_if(node)\\n\\n elif node.type == \\\"opaque\\\":\\n self._process_gate(node, opaque=True)\\n\\n elif node.type == \\\"external\\\":\\n raise UnrollerError(\\\"internal error: _process_node on external\\\")\\n\\n else:\\n raise UnrollerError(\\\"internal error: undefined node type\\\",\\n node.type, \\\"line=%s\\\" % node.line,\\n \\\"file=%s\\\" % node.file)\\n return None\",\n \"def _child_build_new_model(self):\\n self._build_new_gp()\",\n \"def __init__(self):\\n self.drones = ZergUnit(UnitTypeId.DRONE, to_count=0)\\n self.lings = ZergUnit(UnitTypeId.ZERGLING, to_count=999)\\n self.queens = ZergUnit(UnitTypeId.QUEEN, to_count=3)\\n self.roaches = ZergUnit(UnitTypeId.ROACH, to_count=100, priority=True)\\n self.ravagers = ZergUnit(UnitTypeId.RAVAGER, to_count=0)\\n self.defense_spines = DefensiveBuilding(\\n unit_type=UnitTypeId.SPINECRAWLER, position_type=DefensePosition.Entrance, to_base_index=1, to_count=3\\n )\\n self.gas = StepBuildGas(to_count=3)\\n\\n unit_building = BuildOrder(\\n [\\n Step(None, self.drones, skip_until=self.should_build_drones),\\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.defense_spines),\\n Step(\\n RequiredAll([UnitExists(UnitTypeId.ROACHWARREN), UnitExists(UnitTypeId.ROACH)]),\\n self.ravagers,\\n skip_until=self.should_build_ravagers,\\n ),\\n Step(UnitExists(UnitTypeId.ROACHWARREN), self.roaches),\\n Step(\\n RequiredAll(\\n [\\n UnitExists(UnitTypeId.SPAWNINGPOOL),\\n UnitExists(\\n UnitTypeId.ROACHWARREN,\\n include_pending=True,\\n include_not_ready=True,\\n include_killed=True,\\n ),\\n ]\\n ),\\n self.lings,\\n ),\\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.queens),\\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), self.lings),\\n ]\\n )\\n\\n buildings: BuildOrder = BuildOrder(\\n [\\n Step(None, ActBuilding(UnitTypeId.SPAWNINGPOOL, to_count=1)),\\n Step(UnitExists(UnitTypeId.SPAWNINGPOOL), ActBuilding(UnitTypeId.ROACHWARREN, to_count=1)),\\n Step(None, self.gas, skip_until=self.should_build_gas),\\n ]\\n )\\n\\n super().__init__(buildings, unit_building)\",\n \"def childFactory(self, request, childName):\\n return None\",\n \"def _trackable_children(self, save_type=\\\"checkpoint\\\", **kwargs):\\n dep = super()._trackable_children(save_type, **kwargs)\\n dep.pop(_DUMMY_NAME, None)\\n return dep\",\n \"def _addEntity(self, pid, chunks):\\n parent = chunks[pid]\\n sub = None\\n # Find subject\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n if child.func in SubDict:\\n sub = child\\n if child.func == \\\"では\\\":\\n if child.negative != 0 or any([val.negative != 0 for key, val in self.G.successors(child.main)]):\\n pass\\n else:\\n sub = None\\n if sub:\\n self._addNode(parent, sub=sub.main)\\n self._addEdge(sub.main, parent.main, label=\\\"陳述\\\", etype=\\\"stat\\\")\\n else:\\n self._addNode(parent)\\n \\n # Lopp through all children\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n # If child is noun\\n if child.func in SubDict:\\n if child.func == \\\"では\\\":\\n if child.negative != 0 or any([val.negative != 0 for key, val in self.G.successors(child.main)]):\\n pass\\n else:\\n self._addNode(child)\\n self._addEdge(child.main, parent.main, label=child.func, etype=\\\"attr\\\")\\n elif child.type == 0 and child.func in [\\\"と\\\", \\\"などと\\\"] and child.id + 1 == parent.id and preprocessText(chunks[parent.parent].main) not in [\\\"交代\\\", \\\"交換\\\"]:\\n self._addNode(child)\\n self._addEdge(child.main, parent.main, label=\\\"並列\\\", etype=\\\"para\\\")\\n self._addEdge(parent.main, child.main, label=\\\"並列\\\", etype=\\\"para\\\")\\n self.para.append([child.main, parent.main])\\n elif child.type == 0 and child.func in ParallelDict and child.id + 1 == parent.id:\\n self._addNode(child)\\n self._addEdge(child.main, parent.main, label=\\\"並列\\\", etype=\\\"para\\\")\\n self._addEdge(parent.main, child.main, label=\\\"並列\\\", etype=\\\"para\\\")\\n self.para.append([child.main, parent.main])\\n else:\\n self._addNode(child)\\n self._addEdge(child.main, parent.main, label=child.func, etype=\\\"attr\\\")\",\n \"def build_children(self, protein,amino_position):\\n # Add a new state of the protein to the list of proteins.\\n for direction in self.direction_options:\\n new_protein = copy.deepcopy(protein)\\n if new_protein.fold_next_amino(amino_position,direction) == False:\\n self.proteins.append(new_protein)\",\n \"def build(self,\\n mode: tf.estimator.ModeKeys,\\n outputs: mt.BuildMap):\\n with tf.variable_scope(self.name.replace(' ', '_')):\\n # Build child block sets\\n for blockset in self.children:\\n blockset.build(mode, outputs)\\n\\n outputs[self] = self.children[-1]\\n\\n pass\",\n \"def _init_child(self,child,path):\\n pass\",\n \"def depth(self, create, depth, **kwargs): # pylint: disable=unused-argument\\r\\n # pylint: disable=no-member\\r\\n if depth == 0:\\r\\n self.get_module.side_effect = lambda x: LeafModuleFactory(descriptor_cls=HtmlDescriptor)\\r\\n else:\\r\\n self.get_module.side_effect = lambda x: ContainerModuleFactory(descriptor_cls=VerticalDescriptor, depth=depth - 1)\",\n \"def process_deferreds(self):\\n if self.deferred_properties.keys():\\n if b'interrupt-parent' in self.deferred_properties:\\n phandle = struct.unpack('!I', self.deferred_properties[b'interrupt-parent'])[0]\\n self.properties['interrupt-parent'] = self.get_phandle(phandle)\\n if b'interrupts' in self.deferred_properties:\\n interrupt_parent = self.get_inherited('interrupt-parent')\\n cell_size = interrupt_parent['#interrupt-cells']\\n self.properties['interrupts'] = self.process_interrupts(self.properties['interrupts'], cell_size)\\n # Process children vertices in Depth First traversal.\\n for child in self.children:\\n child.process_deferreds()\",\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 _prepare(self):\\n\\n # table of containing directories (to add implicit dependencies to image builds)\\n directories: dict[PurePosixPath, set[FileValue]] = dict()\\n\\n # map plan elements to values\\n v: dict[Any, ValueBase] = dict()\\n # map plan elements to actions\\n a: dict[Any, Action] = dict()\\n\\n # Create FileValues for WorkFiles found in plan\\n for workfile in self.plan.files():\\n value = FileValue(workfile)\\n v[workfile] = value\\n directory = workfile.posix_path.parent\\n if directory not in directories:\\n directories[directory] = set()\\n directories[directory].add(value)\\n\\n for image in self.plan.images():\\n if image.pull_from_registry:\\n image_value = RegistryImageValue(image)\\n pull_image_action = PullImageAction(image)\\n pull_image_action.set_output_image(image_value)\\n v[image] = image_value\\n a[image] = pull_image_action\\n else:\\n image_value = ImageToBuildValue(image)\\n build_image_action = BuildImageAction(image)\\n build_image_action.set_output_image(image_value)\\n v[image] = image_value\\n a[image] = build_image_action\\n # if context dir contains any WorkFiles, add corresponding FileValues as dependencies\\n for directory in directories.keys():\\n if directory.is_relative_to(image_value._plan_element.build_from_context):\\n for file_value in directories[directory]:\\n logging.info(\\\"Implied dependency %s->%s\\\", file_value, build_image_action)\\n build_image_action.add_input(file_value)\\n\\n for e in self.plan.execs():\\n image_value = v[e.image]\\n if not isinstance(image_value, ImageValue):\\n raise Exception(\\\"not an ImageValue %s\\\" % image_value)\\n exec_action = ExecAction(e, image_value)\\n a[e] = exec_action\\n for inp in e.inputs:\\n exec_action.add_input(v[inp.workfile])\\n v[inp.workfile].add_consumer(exec_action)\\n for output in e.outputs:\\n exec_action.add_output(v[output.workfile])\\n v[output.workfile].set_producer(exec_action)\\n\\n self.actions = set(a.values())\\n self.values = set(v.values())\",\n \"def __init__(self, isParent):\\n UTIL.TASK.ProcessingTask.__init__(self, isParent=isParent)\",\n \"def _process_children(self, node):\\n for kid in node.children:\\n self._process_node(kid)\",\n \"def _create_child_dataset(self, name, shape=None, dtype=None, data=None, **kwds):\\n pass\",\n \"def populate_course(self):\\r\\n def descend(parent, stack):\\r\\n xblock_type = stack.pop(0)\\r\\n for _ in range(2):\\r\\n child = ItemFactory.create(category=xblock_type, parent_location=parent.location)\\r\\n if stack:\\r\\n descend(child, stack)\\r\\n\\r\\n descend(self.course, ['chapter', 'sequential', 'vertical', 'problem'])\",\n \"def assemble_substructure(self):\\n\\n yield self.task(\\\"Substation Substructure Assembly\\\", self.takt_time)\\n yield self.task(\\\"Attach Topside\\\", self.attach_time)\\n substation = FloatingSubstation()\\n\\n start = self.env.now\\n yield self.target.put(substation)\\n delay = self.env.now - start\\n\\n if delay > 0:\\n self.submit_action_log(\\\"Delay: No Wet Storage Available\\\", delay)\",\n \"def prepare_content_tree(self):\\n for node_id in self.child_nodes:\\n node = in_scope(node_id)\\n\\n if isinstance(node, CaptionNode):\\n self.caption = node.argument\\n\\n if isinstance(node, LabelNode):\\n self.setup_label(node)\\n\\n # node.prepare_content_tree()\\n\\n out_scope(node)\",\n \"def make_filiation(self):\\n if self.cells is not None:\\n filiate_from_bpointer(self.cells)\\n# for cell in self.cells:\\n# childs = []\\n# for cc in self.cells:\\n# if cc.bpointer == cell.identifier:\\n# childs.append(cc)\\n# cc.parent = cell\\n# cc.set_division_event()\\n# cell.childs = childs\\n return\",\n \"def build_basic_base(self, game_state):\\n filter_locations_x = [27, 24, 21, 18, 15, 12]\\n for x in filter_locations_x:\\n location = [x, 13]\\n if game_state.can_spawn(FILTER, location):\\n self.spawn_wrapper(game_state, FILTER, location)\\n\\n\\n \\\"\\\"\\\"\\n We use Encryptors firewalls because they are cheap and give shields\\n This will build the line that our EMPs will use to snipe.\\n If they are destroyed we replace them with destructors.\\n \\\"\\\"\\\"\\n encryptor_locations = []\\n for x in range(26, 12, -1):\\n # Because of the way pathing works don't need to build behind our Filters saving cores\\n if x not in filter_locations_x and x != self.hole_x_location:\\n encryptor_locations.append([x, 12])\\n \\n for location in encryptor_locations:\\n if game_state.can_spawn(ENCRYPTOR, location):\\n if game_state.turn_number < 2:\\n self.spawn_wrapper(game_state, ENCRYPTOR, location)\\n else:\\n self.spawn_wrapper(game_state, DESTRUCTOR, location)\",\n \"def generate_children(self):\\n # loop over the board in order to obtain all the possible options.\\n for i in range(0, len(self.board)):\\n for j in range(0, len(self.board[0])):\\n if check_board_position(self, i, j):\\n # it's possible to place a token, therefore the board must be copied.\\n child = copy.deepcopy(self)\\n if self.machine_turn:\\n # the machine is playing, therefore the token used is the machine one.\\n child.board[i][j] = self.__machine\\n # change the turn\\n child.machine_turn = False\\n else:\\n # otherwise the human is playing\\n child.board[i][j] = self.__human\\n # change the turn\\n child.machine_turn = True\\n # yield the child on demand\\n yield child\",\n \"def create_offspring(environment, parent_1, parent_2, adaptive_mutation, num_offspring):\\n\\t# create num_offspring children from the parent pair\\n\\tchildren = []\\n\\tfor i in range(num_offspring):\\n\\t\\t# apply whole arithmetic recombination to create children\\n\\t\\tchild = recombine(parent_1, parent_2, adaptive_mutation)\\n\\n\\t\\t# apply mutation and add child to children list\\t\\t\\n\\t\\tif adaptive_mutation:\\n\\t\\t\\tchild.mutate_self_adaptive()\\n\\t\\telse:\\n\\t\\t\\tchild.mutate()\\n\\t\\n\\t\\t# compute child's fitness after mutation\\n\\t\\tchild.fitness = child.compute_fitness(environment)\\n\\t\\tchildren.append(child)\\n\\n\\treturn children\",\n \"def init_children(self):\\n children = []\\n legal_moves = list(chess.Board(self.state).legal_moves)\\n for move in legal_moves:\\n temp_board = chess.Board(self.state)\\n temp_board.push_san(str(move))\\n children.append(Node(temp_board.fen(), self))\\n self.children = children\",\n \"def process_tree(tree):\\n c = circuit()\\n l = line()\\n names = {}\\n procedures = []\\n for lst in tree.children:\\n print(lst)\\n if type(lst[0]) is str:\\n names[lst[0]] = lst[1]\\n else:\\n procedures.append(lst)\\n print(names)\\n #print(procedures)\\n\\n for proc in procedures:\\n\\n proc_elements_names = proc[0]\\n proc_name = proc[1]\\n\\n #print(proc_elements_names)\\n #print(proc_name)\\n\\n if proc_name == \\\"set_mode\\\":\\n mode_name = proc_elements_names[0]\\n if mode_name != \\\"draw-mode\\\": \\n c.set_mode(mode_name)\\n elif mode_name == \\\"draw-mode\\\":\\n l1 = line()\\n # draw mode is different from other modes\\n for element in names:\\n e = CompleteElement(element)\\n e.set_other_attrs(names[element])\\n e.process_other_attrs()\\n l1.addElement(e)\\n c.connectInSeries(l1)\\n c.set_mode(\\\"draw-mode\\\")\\n \\n \\n if proc_name == \\\"series\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n l = l1\\n c.connectInSeries(l)\\n #raise SyntaxError(\\\"Alias {0} referrenced before assignment\\\".format(item[0]))\\n\\n elif proc_name == \\\"parallel\\\":\\n l1 = line()\\n for element in proc_elements_names:\\n l1.addElement(names[element])\\n c.connectInParallel(l1)\\n l1 = line()\\n\\n\\n elif proc_name == \\\"add_parallel\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n l1 = line()\\n l1.addElement(names[new_element])\\n c.connection.append(l1)\\n\\n\\n elif proc_name == \\\"add_series\\\":\\n new_element = proc_elements_names[1]\\n old_element = proc_elements_names[0]\\n for ln in c.connection:\\n for e in ln.elements:\\n if names[old_element] == e:\\n ln.addElement(names[new_element])\\n\\n\\n c.evaluate(\\\"output.png\\\")\\n #print(c)\",\n \"def _addPredicate(self, pid, chunks):\\n parent = chunks[pid]\\n sub = None\\n obj = None\\n aux = list()\\n auxlabel = \\\"\\\"\\n # 1st round find absolute subject & object\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n # Process by categories.\\n if child.func in SubDict:\\n sub = child\\n elif child.func in ObjDict:\\n obj = child\\n\\n # 2nd round find potential subject & object with aux.\\n for i in range(len(parent.children)):\\n child = chunks[parent.children[i]]\\n # Process by categories.\\n if child.func in SubDict or child.func in ObjDict:\\n continue\\n elif child.func in ObjPostDict:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n elif child.func in SubPassiveObjDict:\\n if parent.passive == 1:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n elif not sub and child.type in EntityTypeDict:\\n sub = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n if not sub and child.type in EntityTypeDict:\\n sub = child\\n elif not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n elif child.func in ObjPassiveSubDict:\\n if parent.passive == 1:\\n if not sub and child.type in EntityTypeDict:\\n sub = child\\n elif not obj and child.type in EntityTypeDict:\\n obj = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n if not obj and child.type in EntityTypeDict:\\n obj = child\\n elif not sub and child.type in EntityTypeDict:\\n sub = child\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n else:\\n aux.append(child.id)\\n auxlabel += \\\"[{0}]\\\\n\\\".format(child.surface)\\n\\n if parent.passive == 0:\\n # Add parent and subject.\\n # if sub and obj:\\n # parent.main = \\\"<{0}>[{2}]{1}\\\".format(sub.main, parent.main, obj.main)\\n # elif sub:\\n # parent.main = \\\"<{0}>[NONE]{1}\\\".format(sub.main, parent.main)\\n # elif obj:\\n # parent.main = \\\"<NONE>[{1}]{0}\\\".format(parent.main, obj.main)\\n if sub:\\n parent.main = \\\"<{0}>{1}\\\".format(sub.main, parent.main)\\n self._addNode(parent, sub=sub.main)\\n if not self.G.has_node(sub.main):\\n self._addNode(sub)\\n self._addEdge(sub.main, parent.main, label=\\\"主体\\\\n\\\", etype=\\\"sub\\\")\\n else:\\n self._addNode(parent)\\n # Add object.\\n if obj:\\n if not self.G.has_node(obj.main):\\n self._addNode(obj)\\n self._addEdge(parent.main, obj.main, label=\\\"客体\\\\n\\\" + auxlabel, etype=\\\"obj\\\")\\n else:\\n # Add obj as sub\\n # if sub and obj:\\n # parent.main = \\\"<{0}>[{2}]{1}\\\".format(sub.main, parent.main, obj.main)\\n # elif obj:\\n # parent.main = \\\"<{0}>[NONE]{1}\\\".format(obj.main, parent.main)\\n # elif sub:\\n # parent.main = \\\"<NONE>[{1}]{0}\\\".format(parent.main, sub.main)\\n if obj:\\n parent.main = \\\"<{0}>{1}\\\".format(obj.main, parent.main)\\n self._addNode(parent, sub=obj.main)\\n if not self.G.has_node(obj.main):\\n self._addNode(obj)\\n self._addEdge(obj.main, parent.main, label=\\\"主体\\\\n\\\", etype=\\\"sub\\\")\\n else:\\n self._addNode(parent)\\n # Add sub as obj\\n if sub:\\n if not self.G.has_node(sub.main):\\n self._addNode(sub)\\n self._addEdge(parent.main, sub.main, label=\\\"客体\\\\n\\\", etype=\\\"obj\\\")\\n # # Add obj as aux.\\n # if obj:\\n # aux.append(obj.id)\\n # auxlabel += \\\"[{0}]\\\\n\\\".format(obj.surface)\\n self._processAux(aux, parent.main, chunks)\",\n \"def process_children(cls, operation):\\n db = cls._core.get_db()\\n\\n stmnt = \\\"SELECT OPE_ID, OPE_TYPE FROM OPERATIONS WHERE OPE_OPE_PARENT = ? ORDER BY OPE_INVOKED ;\\\"\\n stmnt_lock = \\\"UPDATE OPERATIONS SET OPE_STATUS = 1 WHERE OPE_ID = ? ;\\\"\\n cur = db.query(cls._core,stmnt,(operation.get_id(),))\\n for row in cur.fetchallmap():\\n child_operation = cls.restore_operation(row)\\n db.query(cls._core,stmnt_lock,(child_operation.get_id(),),commit=True)\\n try:\\n cls.process_children(child_operation)\\n child_operation.do_workload()\\n except Exception,e:\\n stmnt_err = \\\"UPDATE OPERATIONS SET OPE_STATUS = 2 WHERE OPE_ID = ? ;\\\"\\n db.query(cls._core,stmnt_err,(int(row[\\\"OPE_ID\\\"]),),commit=True)\\n #TODO GENERATE ERROR IN LOG\\n raise e\\n stmnt_delete = \\\"DELETE FROM OPERATIONS WHERE OPE_ID = ?;\\\"\\n db.query(cls._core,stmnt_delete,(child_operation.get_id(),),commit=True)\",\n \"def run(self, parent, blocks):\\r\\n pass\",\n \"def _build(self, prefilt=None):\\n self.make_filiation()\\n if prefilt is not None:\\n self.prefilter(filt=prefilt)\\n self.make_trees()\\n return\",\n \"def _dfs_assign(self, filetree):\\n stack = [filetree]\\n while stack:\\n node = stack.pop()\\n if isinstance(node, tuple) and node[0][\\\"packmode\\\"] is None:\\n # all children have been seen already, assing packmode\\n node = node[0] # unpack the actual node\\n weights = defaultdict(int)\\n for child in node[\\\"children\\\"].values():\\n weights[child[\\\"packmode\\\"]] += child[\\\"weight\\\"]\\n packmode, weight = max(weights.items(), key=lambda x: x[1])\\n node[\\\"weight\\\"] = weight\\n node[\\\"packmode\\\"] = packmode\\n elif node[\\\"children\\\"]:\\n # schedule that node for computation\\n stack.append((node,))\\n # visit all children first\\n for child in node[\\\"children\\\"].values():\\n stack.append(child)\",\n \"def _internal_build(self):\\n self.nodes = self.__tree.Nodes()\\n self.edges = self.__tree.Edges()\\n self.augmentedEdges = {}\\n for key, val in self.__tree.AugmentedEdges().items():\\n self.augmentedEdges[key] = list(val)\\n self.root = self.__tree.Root()\\n\\n seen = set()\\n self.branches = set()\\n\\n # Find all of the branching nodes in the tree, degree > 1\\n # That is, they appear in more than one edge\\n for e1, e2 in self.edges:\\n if e1 not in seen:\\n seen.add(e1)\\n else:\\n self.branches.add(e1)\\n\\n if e2 not in seen:\\n seen.add(e2)\\n else:\\n self.branches.add(e2)\\n\\n # The nodes that are not branches are leaves\\n self.leaves = set(self.nodes.keys()) - self.branches\\n self.leaves.remove(self.root)\",\n \"def create_nodes(self):\",\n \"def _add_children(self, parent, parent_iter):\\n parent_gadget = Gadget.from_widget(parent)\\n if parent_gadget:\\n children = parent_gadget.get_children()\\n else:\\n children = get_all_children(parent)\\n\\n for child in children:\\n gadget = Gadget.from_widget(child)\\n if not gadget:\\n if isinstance(child, gtk.Container):\\n self._add_children(child, parent_iter)\\n else:\\n continue\\n\\n elif not self._find_iter(parent_iter, gadget):\\n child_iter = self._model.append(parent_iter, (gadget,))\\n self._add_children(child, child_iter)\",\n \"def __build_test_model_children_tree_1(self) -> Model:\\n self.model_builder.clear()\\n\\n r_a = SystemFile(\\\"a\\\", 1024, True)\\n r_aa = SystemFile(\\\"aa\\\", 512, False)\\n r_a.add_child(r_aa)\\n r_ab = SystemFile(\\\"ab\\\", 512, False)\\n r_a.add_child(r_ab)\\n r_b = SystemFile(\\\"b\\\", 3090, True)\\n r_ba = SystemFile(\\\"ba\\\", 2048, True)\\n r_b.add_child(r_ba)\\n r_baa = SystemFile(\\\"baa\\\", 2048, False)\\n r_ba.add_child(r_baa)\\n r_bb = SystemFile(\\\"bb\\\", 42, True) # only in remote\\n r_b.add_child(r_bb)\\n r_bba = SystemFile(\\\"bba\\\", 42, False) # only in remote\\n r_bb.add_child(r_bba)\\n r_bd = SystemFile(\\\"bd\\\", 1000, False)\\n r_b.add_child(r_bd)\\n r_c = SystemFile(\\\"c\\\", 1234, False) # only in remote\\n r_d = SystemFile(\\\"d\\\", 5678, True) # only in remote\\n r_da = SystemFile(\\\"da\\\", 5678, False) # only in remote\\n r_d.add_child(r_da)\\n\\n l_a = SystemFile(\\\"a\\\", 1024, True)\\n l_aa = SystemFile(\\\"aa\\\", 512, False)\\n l_a.add_child(l_aa)\\n l_ab = SystemFile(\\\"ab\\\", 512, False)\\n l_a.add_child(l_ab)\\n l_b = SystemFile(\\\"b\\\", 1611, True)\\n l_ba = SystemFile(\\\"ba\\\", 512, True)\\n l_b.add_child(l_ba)\\n l_baa = SystemFile(\\\"baa\\\", 512, False)\\n l_ba.add_child(l_baa)\\n l_bc = SystemFile(\\\"bc\\\", 99, True) # only in local\\n l_b.add_child(l_bc)\\n l_bca = SystemFile(\\\"bca\\\", 99, False) # only in local\\n l_bc.add_child(l_bca)\\n l_bd = SystemFile(\\\"bd\\\", 1000, False)\\n l_b.add_child(l_bd)\\n\\n s_b = LftpJobStatus(0, LftpJobStatus.Type.MIRROR, LftpJobStatus.State.RUNNING, \\\"b\\\", \\\"\\\")\\n s_b.total_transfer_state = LftpJobStatus.TransferState(1611, 3090, 52, 10, 1000)\\n s_b.add_active_file_transfer_state(\\\"ba/baa\\\", LftpJobStatus.TransferState(512, 2048, 25, 5, 500))\\n s_c = LftpJobStatus(0, LftpJobStatus.Type.PGET, LftpJobStatus.State.QUEUED, \\\"c\\\", \\\"\\\")\\n s_d = LftpJobStatus(0, LftpJobStatus.Type.MIRROR, LftpJobStatus.State.QUEUED, \\\"d\\\", \\\"\\\")\\n\\n self.model_builder.set_remote_files([r_a, r_b, r_c, r_d])\\n self.model_builder.set_local_files([l_a, l_b])\\n self.model_builder.set_lftp_statuses([s_b, s_c, s_d])\\n return self.model_builder.build_model()\",\n \"def generate_children(count, parent, life_min, life_max):\\n\\n types = parent.__subclasses__()\\n for i in range(count):\\n yield { \\n \\\"class_name\\\": random.choice(types).__name__, \\n \\\"lifespan\\\": random.randint(life_min, life_max)\\n }\",\n \"def init_db(self, parent_type, child_type):\\n self.parent = Node(self.handler, parent_type)\\n self.children = [ Node(self.handler, child_type) for x in range(0, self.SIZE) ]\\n for node in self.children:\\n Link(self.handler, self.parent.node, node.node, child_type.upper())\",\n \"def create(self):\\n\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n for charge_selection in self.charge_selections:\\n key_dir = getKey(process_name, charge_selection)\\n for dir_type in [ DKEY_CFGS, DKEY_HIST, DKEY_LOGS, DKEY_RLES ]:\\n initDict(self.dirs, [ key_dir, dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_LOGS ]:\\n self.dirs[key_dir][dir_type] = os.path.join(self.configDir, dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name)\\n else:\\n self.dirs[key_dir][dir_type] = os.path.join(self.outputDir, dir_type, self.channel,\\n \\\"_\\\".join([ charge_selection ]), process_name)\\n for dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_HIST, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n initDict(self.dirs, [ dir_type ])\\n if dir_type in [ DKEY_CFGS, DKEY_SCRIPTS, DKEY_LOGS, DKEY_DCRD, DKEY_PLOT, DKEY_HADD_RT ]:\\n self.dirs[dir_type] = os.path.join(self.configDir, dir_type, self.channel)\\n else:\\n self.dirs[dir_type] = os.path.join(self.outputDir, dir_type, self.channel)\\n ##print \\\"self.dirs = \\\", self.dirs\\n\\n for key in self.dirs.keys():\\n if type(self.dirs[key]) == dict:\\n for dir_type in self.dirs[key].keys():\\n create_if_not_exists(self.dirs[key][dir_type])\\n else:\\n create_if_not_exists(self.dirs[key])\\n\\n inputFileLists = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n logging.info(\\\"Checking input files for sample %s\\\" % sample_info[\\\"process_name_specific\\\"])\\n inputFileLists[sample_name] = generateInputFileList(sample_name, sample_info, self.max_files_per_job, self.debug)\\n \\n self.inputFileIds = {}\\n for sample_name, sample_info in self.samples.items():\\n if not sample_info[\\\"use_it\\\"] or sample_info[\\\"sample_category\\\"] in [ \\\"additional_signal_overlap\\\", \\\"background_data_estimate\\\" ]:\\n continue\\n\\n process_name = sample_info[\\\"process_name_specific\\\"]\\n\\n logging.info(\\\"Creating configuration files to run '%s' for sample %s\\\" % (self.executable_analyze, process_name)) \\n\\n is_mc = (sample_info[\\\"type\\\"] == \\\"mc\\\")\\n lumi_scale = 1. if not (self.use_lumi and is_mc) else sample_info[\\\"xsection\\\"] * self.lumi / sample_info[\\\"nof_events\\\"]\\n apply_genWeight = sample_info[\\\"apply_genWeight\\\"] if (is_mc and \\\"apply_genWeight\\\" in sample_info.keys()) else False\\n sample_category = sample_info[\\\"sample_category\\\"]\\n triggers = sample_info[\\\"triggers\\\"]\\n apply_trigger_bits = (is_mc and (self.era == \\\"2015\\\" or (self.era == \\\"2016\\\" and sample_info[\\\"reHLT\\\"]))) or not is_mc\\n\\n for charge_selection in self.charge_selections:\\n for central_or_shift in self.central_or_shifts:\\n\\n inputFileList = inputFileLists[sample_name]\\n for jobId in inputFileList.keys():\\n if central_or_shift != \\\"central\\\" and not is_mc:\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttH\\\") and sample_category != \\\"signal\\\":\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttW\\\") and sample_category != \\\"TTW\\\":\\n continue\\n if central_or_shift.startswith(\\\"CMS_ttHl_thu_shape_ttZ\\\") and sample_category != \\\"TTZ\\\":\\n continue\\n\\n # build config files for executing analysis code\\n key_dir = getKey(process_name, charge_selection)\\n key_analyze_job = getKey(process_name, charge_selection, central_or_shift, jobId)\\n\\n ntupleFiles = inputFileList[jobId]\\n if len(ntupleFiles) == 0:\\n print \\\"Warning: ntupleFiles['%s'] = %s --> skipping job !!\\\" % (key_job, ntupleFiles)\\n continue\\n self.jobOptions_analyze[key_analyze_job] = {\\n 'ntupleFiles' : ntupleFiles,\\n 'cfgFile_modified' : os.path.join(self.dirs[key_dir][DKEY_CFGS], \\\"analyze_%s_%s_%s_%s_%i_cfg.py\\\" % \\\\\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\\n 'histogramFile' : os.path.join(self.dirs[key_dir][DKEY_HIST], \\\"%s_%s_%s_%i.root\\\" % \\\\\\n (process_name, charge_selection, central_or_shift, jobId)),\\n 'logFile' : os.path.join(self.dirs[key_dir][DKEY_LOGS], \\\"analyze_%s_%s_%s_%s_%i.log\\\" % \\\\\\n (self.channel, process_name, charge_selection, central_or_shift, jobId)),\\n 'sample_category' : sample_category,\\n 'triggers' : sample_info[\\\"triggers\\\"],\\n 'charge_selection' : charge_selection,\\n 'jet_minPt' : self.jet_minPt,\\n 'jet_maxPt' : self.jet_maxPt,\\n 'jet_minAbsEta' : self.jet_minAbsEta,\\n 'jet_maxAbsEta' : self.jet_maxAbsEta,\\n 'hadTau_selection_denominator' : self.hadTau_selection_denominator,\\n 'hadTau_selections_numerator' : self.hadTau_selections_numerator,\\n 'absEtaBins' : self.absEtaBins,\\n ##'use_HIP_mitigation_mediumMuonId' : sample_info[\\\"use_HIP_mitigation_mediumMuonId\\\"],\\n 'use_HIP_mitigation_mediumMuonId' : True,\\n 'is_mc' : is_mc,\\n 'central_or_shift' : central_or_shift,\\n 'lumi_scale' : 1. if not (self.use_lumi and is_mc) else sample_info[\\\"xsection\\\"] * self.lumi / sample_info[\\\"nof_events\\\"],\\n 'apply_genWeight' : sample_info[\\\"genWeight\\\"] if (is_mc and \\\"genWeight\\\" in sample_info.keys()) else False,\\n 'apply_trigger_bits' : (is_mc and (self.era == \\\"2015\\\" or (self.era == \\\"2016\\\" and sample_info[\\\"reHLT\\\"]))) or not is_mc,\\n }\\n self.createCfg_analyze(self.jobOptions_analyze[key_analyze_job])\\n\\n # initialize input and output file names for hadd_stage1\\n key_hadd_stage1 = getKey(process_name, charge_selection)\\n if not key_hadd_stage1 in self.inputFiles_hadd_stage1:\\n self.inputFiles_hadd_stage1[key_hadd_stage1] = []\\n self.inputFiles_hadd_stage1[key_hadd_stage1].append(self.jobOptions_analyze[key_analyze_job]['histogramFile'])\\n self.outputFile_hadd_stage1[key_hadd_stage1] = os.path.join(self.dirs[DKEY_HIST], \\\"histograms_harvested_stage1_%s_%s_%s.root\\\" % \\\\\\n (self.channel, process_name, charge_selection))\\n\\n # initialize input and output file names for hadd_stage2\\n key_hadd_stage1 = getKey(process_name, charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n if not key_hadd_stage2 in self.inputFiles_hadd_stage2:\\n self.inputFiles_hadd_stage2[key_hadd_stage2] = []\\n self.inputFiles_hadd_stage2[key_hadd_stage2].append(self.outputFile_hadd_stage1[key_hadd_stage1])\\n self.outputFile_hadd_stage2[key_hadd_stage2] = os.path.join(self.dirs[DKEY_HIST], \\\"histograms_harvested_stage2_%s_%s.root\\\" % \\\\\\n (self.channel, charge_selection))\\n\\n logging.info(\\\"Creating configuration files for executing 'comp_jetToTauFakeRate'\\\")\\n for charge_selection in self.charge_selections:\\n key_comp_jetToTauFakeRate_job = getKey(charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job] = {\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"comp_jetToTauFakeRate_%s_cfg.py\\\" % charge_selection),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_HIST], \\\"comp_jetToTauFakeRate_%s.root\\\" % charge_selection),\\n 'logFile' : os.path.join(\\n self.dirs[DKEY_LOGS], \\\"comp_jetToTauFakeRate_%s.log\\\" % charge_selection),\\n 'looseRegion' : \\\"jetToTauFakeRate_%s/denominator/\\\" % charge_selection,\\n 'tightRegion' : \\\"jetToTauFakeRate_%s/numerator/\\\" % charge_selection,\\n 'absEtaBins' : self.absEtaBins,\\n 'ptBins' : self.ptBins\\n }\\n self.createCfg_comp_jetToTauFakeRate(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job])\\n self.targets.append(self.jobOptions_comp_jetToTauFakeRate[key_comp_jetToTauFakeRate_job]['outputFile'])\\n\\n logging.info(\\\"Creating configuration files to run 'makePlots'\\\")\\n for charge_selection in self.charge_selections:\\n key_makePlots_job = getKey(charge_selection)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_cfg.py\\\" % self.channel),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s.png\\\" % self.channel),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s\\\" % charge_selection,\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n self.cfgFile_make_plots = self.cfgFile_make_plots_denominator\\n for absEtaBin in [ \\\"absEtaLt1_5\\\", \\\"absEta1_5to9_9\\\" ]:\\n key_makePlots_job = getKey(charge_selection, absEtaBin, \\\"denominator\\\")\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_%s_denominator_%s_cfg.py\\\" % (self.channel, charge_selection, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s_%s_denominator_%s.png\\\" % (self.channel, charge_selection, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s/denominator/%s\\\" % (charge_selection, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n for hadTau_selection_numerator in self.hadTau_selections_numerator:\\n key_makePlots_job = getKey(charge_selection, absEtaBin, \\\"numerator\\\", hadTau_selection_numerator)\\n key_hadd_stage2 = getKey(charge_selection)\\n self.jobOptions_make_plots[key_makePlots_job] = {\\n 'executable' : self.executable_make_plots,\\n 'inputFile' : self.outputFile_hadd_stage2[key_hadd_stage2],\\n 'cfgFile_modified' : os.path.join(\\n self.dirs[DKEY_CFGS], \\\"makePlots_%s_%s_numerator_%s_%s_cfg.py\\\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\\n 'outputFile' : os.path.join(\\n self.dirs[DKEY_PLOT], \\\"makePlots_%s_%s_numerator_%s_%s.png\\\" % (self.channel, charge_selection, hadTau_selection_numerator, absEtaBin)),\\n 'histogramDir' : \\\"jetToTauFakeRate_%s/numerator/%s/%s\\\" % (charge_selection, hadTau_selection_numerator, absEtaBin),\\n 'label' : None,\\n 'make_plots_backgrounds' : [ \\\"TT\\\", \\\"TTW\\\", \\\"TTZ\\\", \\\"EWK\\\", \\\"Rares\\\" ],\\n }\\n self.createCfg_makePlots(self.jobOptions_make_plots[key_makePlots_job])\\n\\n if self.is_sbatch:\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_analyze)\\n self.sbatchFile_analyze = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_analyze_%s.py\\\" % self.channel)\\n self.createScript_sbatch_analyze(self.executable_analyze, self.sbatchFile_analyze, self.jobOptions_analyze)\\n logging.info(\\\"Creating script for submitting '%s' jobs to batch system\\\" % self.executable_comp_jetToTauFakeRate)\\n self.sbatchFile_comp_jetToTauFakeRate = os.path.join(self.dirs[DKEY_SCRIPTS], \\\"sbatch_comp_jetToTauFakeRate.py\\\")\\n self.createScript_sbatch(self.executable_comp_jetToTauFakeRate, self.sbatchFile_comp_jetToTauFakeRate, self.jobOptions_comp_jetToTauFakeRate)\\n\\n lines_makefile = []\\n self.addToMakefile_analyze(lines_makefile)\\n self.addToMakefile_hadd_stage1(lines_makefile)\\n self.addToMakefile_hadd_stage2(lines_makefile)\\n self.addToMakefile_comp_jetToTauFakeRate(lines_makefile)\\n self.addToMakefile_make_plots(lines_makefile)\\n self.createMakefile(lines_makefile)\\n \\n logging.info(\\\"Done\\\")\",\n \"def _generate_children(self) -> list:\\n if self.debug: print(f\\\"StateNode._generate_children()\\\")\\n return [self.transition(x) for x in self.actions()]\",\n \"def __init__(self, message_log_file, stepSize, TER1, TER2, RSC, sizingMethod, iApartments, sqm, specDemandTh, ID, solutionPoolIntensity, absGap, envirmt=None):\\n super(TreeAgent, self).__init__(message_log_file, stepSize, TER1, TER2, RSC, sizingMethod, iApartments, sqm, specDemandTh, ID, solutionPoolIntensity, absGap, envirmt=envirmt)\\n\\n #Variables for pseudo tree network structure\\n # Pseudo tree is generated according to algorithm presented in\\n # Thomas Leaute, Boi Faltings:\\n # \\\"Protecting Privacy through Distributed Computation in Multi-agent Decision Making\\\"\\n # Online Appendix 2: DFS Tree Generation Algorithm\\n # Journal of Artificial Intelligence Research 47 (2013) pp. 649-695\\n #\\n # with slight modifications by Sonja Kolen\\n self.Children = [] # in pseudo tree: list of IDs of known children\\n self.Parent = [] # in pseudo tree: ID of parent (root has no parent)\\n self.PseudoChildren = [] # in pseudo tree: list of IDs of known pseudo children (if any)\\n self.PseudoParents = [] # in pseudo tree: list of IDs of known pseudo parents (if any)\\n self.OpenNeighbors = [] # during pseudo tree generation: saves a list of neighbors that still need to be processed\\n self.Visited = 0 # if all open neighbors are processed this flag is set to 1\\n self.statusTree = 0 # saves the current status of the pseudo tree at the current node\\n self.noOfChildReplies = 0 # saves the number of child replies\\n\\n # Variables used for tree-based coordination algorithm\\n self.EConsumptionChildCurves = [] # Energy consumption curves of all children\\n self.EConsumptionChildCurvesRec = [] # Received energy consumption curves of all children\\n self.noOfConsumptionCurvesReceived = 0 # How many energy consumption curves were received?\\n self.state_coordination = 0 # current state of coordination alg\\n self.ERemainderLocal = [] # local view on energy remainder\\n self.noNewRounds = 0 # saves the number of new coordination rounds started\\n self.scheduleIdxOfPreviousRound = -1 # save schedule of previous round\",\n \"def _validateChildren(self) -> None:\\n\\t\\t# Check whether we already are in validation the children (ie prevent unfortunate recursion by the Dispatcher)\\n\\t\\tif self.__validating:\\n\\t\\t\\treturn\\n\\t\\tself.__validating = True\\n\\n\\t\\t# Only get the CINs in raw format. Instantiate them as resources if needed\\n\\t\\tcinsRaw = cast(List[JSON], sorted(CSE.storage.directChildResources(self.ri, T.CIN, raw = True), key = lambda x: x['ct']))\\n\\t\\tcni = len(cinsRaw)\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t# Check number of instances\\n\\t\\tif (mni := self.mni) is not None:\\n\\t\\t\\twhile cni > mni and cni > 0:\\n\\t\\t\\t\\t# Only instantiate the <cin> when needed here for deletion\\n\\t\\t\\t\\tcin = Factory.resourceFromDict(cinsRaw[0]).resource\\n\\t\\t\\t\\tL.isDebug and L.logDebug(f'cni > mni: Removing <cin>: {cin.ri}')\\n\\t\\t\\t\\t# remove oldest\\n\\t\\t\\t\\t# Deleting a child must not cause a notification for 'deleteDirectChild'.\\n\\t\\t\\t\\t# Don't do a delete check means that CNT.childRemoved() is not called, where subscriptions for 'deleteDirectChild' is tested.\\n\\t\\t\\t\\tCSE.dispatcher.deleteResource(cin, parentResource = self, doDeleteCheck = False)\\n\\t\\t\\t\\tdel cinsRaw[0]\\t# Remove from list\\n\\t\\t\\t\\tcni -= 1\\t# decrement cni when deleting a <cin>\\n\\n\\t\\t# Calculate cbs of remaining cins\\n\\t\\tcbs = sum([ each['cs'] for each in cinsRaw])\\n\\n\\t\\t# check size\\n\\t\\tif (mbs := self.mbs) is not None:\\n\\t\\t\\twhile cbs > mbs and cbs > 0:\\n\\t\\t\\t\\t# Only instantiate the <cin> when needed here for deletion\\n\\t\\t\\t\\tcin = Factory.resourceFromDict(cinsRaw[0]).resource\\n\\t\\t\\t\\tL.isDebug and L.logDebug(f'cbs > mbs: Removing <cin>: {cin.ri}')\\n\\t\\t\\t\\t# remove oldest\\n\\t\\t\\t\\tcbs -= cin.cs\\n\\t\\t\\t\\t# Deleting a child must not cause a notification for 'deleteDirectChild'.\\n\\t\\t\\t\\t# Don't do a delete check means that CNT.childRemoved() is not called, where subscriptions for 'deleteDirectChild' is tested.\\n\\t\\t\\t\\tCSE.dispatcher.deleteResource(cin, parentResource = self, doDeleteCheck = False)\\n\\t\\t\\t\\tdel cinsRaw[0]\\t# Remove from list\\n\\t\\t\\t\\tcni -= 1\\t# decrement cni when deleting a <cin>\\n\\n\\t\\t# Some attributes may have been updated, so store the resource \\n\\t\\tself['cni'] = cni\\n\\t\\tself['cbs'] = cbs\\n\\t\\tself.dbUpdate()\\n\\t\\n\\t\\t# End validating\\n\\t\\tself.__validating = False\",\n \"def createChildren(self):\\n children = []\\n posMoves = self.checkPossibleMoves()\\n\\n for i in range(self.nrOfCars):\\n if len(posMoves[i]) > 0:\\n for j in range(len(posMoves[i])):\\n child = copy(self.changeable)\\n child[i] = child[i] + posMoves[i][j]\\n children.append(child)\\n\\n return children\",\n \"def _build_components(self):\\n\\n # Build dataframes.\\n dfs = {}\\n for df_name, df_repr in self._repr.dataframes.items():\\n cols = {}\\n for i in range(len(df_repr.columns)):\\n col = df_repr.columns[i]\\n cols[col.name] = {}\\n cols[col.name]['index'] = i\\n cols[col.name]['type'] = col.vtype\\n dfs[df_name] = DataFrame(df_name, cols)\\n self._dataframes = dfs\\n\\n # Build operator contexts.\\n self._op_ctxs = {}\\n for _, op_repr in self._repr.operators.items():\\n op_ctx = OperatorContext(op_repr, self.dataframes)\\n\\n if op_ctx.name == '_start_op':\\n op_ctx.add_task_start_handler(self.graph_start_handlers)\\n elif op_ctx.name == '_end_op':\\n op_ctx.add_task_finish_handler(self.graph_finish_handlers)\\n else:\\n op_ctx.add_task_start_handler(self.task_start_handlers)\\n op_ctx.add_task_ready_handler(self.task_ready_handlers)\\n op_ctx.add_task_finish_handler(self.task_finish_handlers)\\n\\n self._op_ctxs[op_ctx.name] = op_ctx\",\n \"def create_child_nodes(current_node: Node, goal: list, generated: set) -> list:\\n\\n children = []\\n locations = state_to_locations(current_node.state)\\n blank = locations[0]\\n\\n # Moving blank to the left\\n if blank[1] != 0:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0], new_locations[0][1] - 1)\\n # Modifies the location of the blank in the new list\\n \\\"\\\"\\\" Note that the index 0 represents the first column. So long as \\n the blank is not in the first column, it can be moved to the left.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0]][blank[1] - 1]\\n # Finds the number on the tile to the left of the blank\\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] + 1)\\n # Modifies the location of the neighbor in the new list\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('L')\\n new_state = locations_to_state(new_locations)\\n # Constructs the new state by calling locations_to_state\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n \\\"\\\"\\\" Append the child node to the list only if it's not a \\n repeated state.\\\"\\\"\\\"\\n\\n # Moving blank to the right\\n if blank[1] != 3:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0], new_locations[0][1] + 1)\\n \\\"\\\"\\\" Similar to the case above: so long as the blank is not in the fourth \\n column, it can be moved to the right.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0]][blank[1] + 1]\\n # Finds the number on the tile to the right of the blank\\n new_locations[neighbor] = (new_locations[neighbor][0], new_locations[neighbor][1] - 1)\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('R')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n # Moving blank up\\n if blank[0] != 0:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0] - 1, new_locations[0][1])\\n \\\"\\\"\\\" So long as the blank is not in the first row, it can be moved up.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0] - 1][blank[1]]\\n # Finds the number on the tile above the blank\\n new_locations[neighbor] = (new_locations[neighbor][0] + 1, new_locations[neighbor][1])\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('U')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n # Moving the blank down\\n if blank[0] != 3:\\n new_locations = copy.deepcopy(locations)\\n new_locations[0] = (new_locations[0][0] + 1, new_locations[0][1])\\n \\\"\\\"\\\" So long as the blank is not in the fourth row, it can be moved down.\\\"\\\"\\\"\\n neighbor = current_node.state[blank[0] + 1][blank[1]]\\n # Finds the number on the tile below the blank\\n new_locations[neighbor] = (new_locations[neighbor][0] - 1, new_locations[neighbor][1])\\n new_path_history = copy.deepcopy(current_node.path_history)\\n new_path_history.append('D')\\n new_state = locations_to_state(new_locations)\\n new_node = Node(new_state, current_node, current_node.path_cost + 1,\\n heuristic_cal(new_state, goal), new_path_history)\\n if new_node not in generated:\\n children.append(new_node)\\n\\n return children\",\n \"def _populateChild(self, populateAll=False):\\n pass\",\n \"def gen_model(children, tree_structure):\\n referenced = False\\n extended = False\\n for child in children:\\n #print child.arg\\n node = dict()\\n extended = False\\n if hasattr(child, 'substmts'):\\n for attribute in child.substmts:\\n # process the 'type' attribute:\\n # Currently integer, enumeration and string are supported.\\n if attribute.keyword == 'type':\\n if len(attribute.arg.split(':'))>1:\\n attribute.arg = attribute.arg.split(':')[-1]\\n # Firstly, it is checked if the attribute type has been previously define in typedefs.\\n if attribute.arg in TYPEDEFS:\\n if TYPEDEFS[attribute.arg]['type'][:3] == 'int':\\n node['type'] = 'integer'\\n node['format'] = TYPEDEFS[attribute.arg]['format']\\n elif TYPEDEFS[attribute.arg]['type'] == 'enumeration':\\n node['type'] = 'string'\\n node['enum'] = [e\\n for e in TYPEDEFS[attribute.arg]['enum']]\\n # map all other types to string\\n else:\\n node['type'] = 'string'\\n elif attribute.arg[:3] == 'int':\\n node['type'] = 'integer'\\n node['format'] = attribute.arg\\n elif attribute.arg == 'decimal64':\\n node['type'] = 'number'\\n node['format'] = 'double'\\n elif attribute.arg == 'boolean':\\n node['type'] = attribute.arg\\n elif attribute.arg == 'enumeration':\\n node['type'] = 'string'\\n node['enum'] = [e[0]\\n for e in attribute.i_type_spec.enums]\\n # map all other types to string\\n else:\\n node['type'] = 'string'\\n elif attribute.keyword == 'mandatory':\\n parent_model = to_upper_camelcase(child.parent.arg)\\n if parent_model not in PARENT_MODELS.keys():\\n PARENT_MODELS[parent_model] = {'models':[],'discriminator':to_lower_camelcase(child.arg)}\\n # Process the reference to another model.\\n # We differentiate between single and array references.\\n elif attribute.keyword == 'uses':\\n if len(attribute.arg.split(':'))>1:\\n attribute.arg = attribute.arg.split(':')[-1]\\n\\n ref = to_upper_camelcase(attribute.arg)\\n ref = '#/definitions/' + ref\\n if str(child.keyword) == 'list':\\n node['items'] = {'$ref': ref}\\n node['type'] = 'array'\\n for attribute in child.substmts:\\n if attribute.keyword == 'key':\\n listkey = to_lower_camelcase(attribute.arg)\\n if listkey:\\n node['x-key'] = listkey\\n referenced = True\\n elif str(child.keyword) == 'grouping':\\n ref = to_upper_camelcase(attribute.arg)\\n if ref in tree_structure:\\n PARENT_MODELS[ref]['models'].append(child.arg)\\n list_properties = [item for item in tree_structure[ref]['properties']]\\n ref = '#/definitions/' + ref\\n node['allOf'] = []\\n node['allOf'].append({'$ref': ref})\\n index = 0\\n for i in range(0, len(child.i_children)):\\n #print len(child.i_children)\\n if to_lower_camelcase(child.i_children[index].arg) in list_properties:\\n del child.i_children[index]\\n else:\\n index+=1\\n extended = True\\n else:\\n pending_models.append(child)\\n else:\\n node['$ref'] = ref\\n referenced = True\\n\\n # When a node contains a referenced model as an attribute the algorithm\\n # does not go deeper into the sub-tree of the referenced model.\\n if not referenced :\\n if not extended:\\n node = gen_model_node(child, node)\\n else:\\n node_ext = dict()\\n node_ext = gen_model_node(child, node_ext)\\n node['allOf'].append( node_ext)\\n extended = False\\n\\n # Leaf-lists need to create arrays.\\n # Copy the 'node' content to 'items' and change the reference\\n if child.keyword == 'leaf-list':\\n ll_node = {'type': 'array', 'items': node}\\n node = ll_node\\n # Groupings are class names and upper camelcase.\\n # All the others are variables and lower camelcase.\\n if child.keyword == 'grouping':\\n tree_structure[to_upper_camelcase(child.arg)] = node\\n else:\\n tree_structure[to_lower_camelcase(child.arg)] = node\\n # TODO: do we really need this return value? We are working on the\\n # reference anyhow.\\n return tree_structure\",\n \"def _create_channels(self):\\n for name, creator in CommonBase.get_channels(self.__class__):\\n for cls, id in creator.pairs:\\n # If channel pair was created with MultiChannelCreator\\n # add channel interface to collection with passed attribute name\\n if isinstance(creator, CommonBase.MultiChannelCreator):\\n child = self.add_child(cls, id, collection=name, **creator.kwargs)\\n # If channel pair was created with ChannelCreator\\n # name channel interface with passed attribute name\\n elif isinstance(creator, CommonBase.ChannelCreator):\\n child = self.add_child(cls, id, attr_name=name, **creator.kwargs)\\n else:\\n raise ValueError(\\\"Invalid class '{creator}' for channel creation.\\\")\\n child._protected = True\",\n \"def _create_xblock_children(self, parent_loc, xblock_descriptions):\\r\\n for desc in xblock_descriptions:\\r\\n loc = self._create_xblock(parent_loc, desc)\\r\\n self._create_xblock_children(loc, desc.children)\\r\\n\\r\\n self._publish_xblock(parent_loc)\",\n \"def __init__(self, **kwargs):\\n FeatureDefinition.__init__(self)\\n\\n nbTypes = self._getTypeNumber(kwargs)\\n \\n print(\\\"BETTER FEATURES\\\")\\n \\n \\n block_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"xywh\\\", Pipeline([\\n ('selector', NodeTransformerXYWH_v2()),\\n #v1 ('xywh', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('xywh', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"neighbors\\\", Pipeline([\\n ('selector', NodeTransformerNeighbors()),\\n #v1 ('neighbors', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('neighbors', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n , (\\\"1hot\\\", Pipeline([\\n ('1hot', Node1HotFeatures()) #does the 1-hot encoding directly\\n ])\\n )\\n ])\\n grid_line_transformer = GridLine_NodeTransformer_v2()\\n \\n self._node_transformer = TransformerListByType([block_transformer, grid_line_transformer]) \\n \\n edge_BB_transformer = FeatureUnion( [ #CAREFUL IF YOU CHANGE THIS - see cleanTransformers method!!!!\\n (\\\"1hot\\\", Pipeline([\\n ('1hot', Edge1HotFeatures(PageNumberSimpleSequenciality()))\\n ])\\n )\\n , (\\\"boolean\\\", Pipeline([\\n ('boolean', EdgeBooleanFeatures_v2())\\n ])\\n )\\n , (\\\"numerical\\\", Pipeline([\\n ('selector', EdgeNumericalSelector()),\\n #v1 ('numerical', StandardScaler(copy=False, with_mean=True, with_std=True)) #use in-place scaling\\n ('numerical', QuantileTransformer(n_quantiles=self.n_QUANTILES, copy=False)) #use in-place scaling\\n ])\\n )\\n ] )\\n edge_BL_transformer = DU_ABPTableRG.Block2GridLine_EdgeTransformer()\\n edge_LL_transformer = DU_ABPTableRG.GridLine2GridLine_EdgeTransformer()\\n self._edge_transformer = TransformerListByType([edge_BB_transformer,\\n edge_BL_transformer,\\n edge_BL_transformer, # useless but required\\n edge_LL_transformer \\n ])\\n \\n self.tfidfNodeTextVectorizer = None #tdifNodeTextVectorizer\",\n \"def __init__(self):\\n self.child = {}\\n self.isend = False\",\n \"def makeTree(node,baseName,baseAddress,nodes,parentNode,vars,isGenerated):\\n \\n if (isGenerated == None or isGenerated == False) and node.get('generate') is not None and node.get('generate') == 'true':\\n generateSize = parseInt(node.get('generate_size'))\\n generateAddressStep = parseInt(node.get('generate_address_step'))\\n generateIdxVar = node.get('generate_idx_var')\\n for i in range(0, generateSize):\\n vars[generateIdxVar] = i\\n makeTree(node, baseName, baseAddress + generateAddressStep * i, nodes, parentNode, vars, True)\\n return\\n newNode = Node()\\n name = baseName\\n if baseName != '': name += '.'\\n if node.get('id') is not None:\\n name += node.get('id')\\n name = substituteVars(name, vars)\\n newNode.name = name\\n if node.get('description') is not None:\\n newNode.description = node.get('description')\\n address = baseAddress\\n if node.get('address') is not None:\\n address = baseAddress + parseInt(node.get('address'))\\n newNode.address = address\\n newNode.real_address = (address<<2)+0x64000000\\n newNode.permission = node.get('permission')\\n newNode.mask = parseInt(node.get('mask'))\\n newNode.isModule = node.get('fw_is_module') is not None and node.get('fw_is_module') == 'true'\\n if node.get('sw_monitor_warn_min_threshold') is not None:\\n newNode.warn_min_value = node.get('sw_monitor_warn_min_threshold') \\n if node.get('sw_monitor_error_min_threshold') is not None:\\n newNode.error_min_value = node.get('sw_monitor_error_min_threshold') \\n nodes[name] = newNode\\n if parentNode is not None:\\n parentNode.addChild(newNode)\\n newNode.parent = parentNode\\n newNode.level = parentNode.level+1\\n for child in node:\\n makeTree(child,name,address,nodes,newNode,vars,False)\",\n \"def initialize_context(self):\\n # a task's workdir == context.flow_workdir / context.flow_config.workdir / context.task_config.workdir\\n # If any of the above dirs is absolute dir, then use it instead\\n super().initialize_context()\\n # only inject the up-most flow's info\\n if not flowsaber.context.up_flow:\\n flow_workdir = self.config_dict['workdir']\\n if not Path(flow_workdir).is_absolute():\\n flow_workdir = str(Path().resolve().absolute())\\n self.context.update({\\n 'flow_id': self.config_dict['id'],\\n 'flow_name': self.config_dict['name'],\\n 'flow_full_name': self.config_dict['full_name'],\\n 'flow_labels': self.config_dict['labels'],\\n 'flow_workdir': flow_workdir,\\n 'top_flow_config': self.config_dict\\n })\",\n \"def build(self, *args, **kwargs):\\n raise NotImplemented(\\\"Implement me in children!\\\")\",\n \"def __init__(self, system, location, definition, descriptor,\\r\\n instance_state=None, shared_state=None, metadata=None, static_data=None, **kwargs):\\r\\n self.instance_state = instance_state\\r\\n self.display_name = instance_state.get('display_name', \\\"Open Ended\\\")\\r\\n\\r\\n # We need to set the location here so the child modules can use it\\r\\n system.set('location', location)\\r\\n self.system = system\\r\\n\\r\\n # Tells the system which xml definition to load\\r\\n self.current_task_number = instance_state.get('current_task_number', 0)\\r\\n # This loads the states of the individual children\\r\\n self.task_states = instance_state.get('task_states', [])\\r\\n #This gets any old task states that have been persisted after the instructor changed the tasks.\\r\\n self.old_task_states = instance_state.get('old_task_states', [])\\r\\n # Overall state of the combined open ended module\\r\\n self.state = instance_state.get('state', self.INITIAL)\\r\\n\\r\\n self.student_attempts = instance_state.get('student_attempts', 0)\\r\\n self.weight = instance_state.get('weight', 1)\\r\\n\\r\\n # Allow reset is true if student has failed the criteria to move to the next child task\\r\\n self.ready_to_reset = instance_state.get('ready_to_reset', False)\\r\\n self.max_attempts = instance_state.get('max_attempts', MAX_ATTEMPTS)\\r\\n self.is_scored = instance_state.get('graded', IS_SCORED) in TRUE_DICT\\r\\n self.accept_file_upload = instance_state.get('accept_file_upload', ACCEPT_FILE_UPLOAD) in TRUE_DICT\\r\\n self.skip_basic_checks = instance_state.get('skip_spelling_checks', SKIP_BASIC_CHECKS) in TRUE_DICT\\r\\n\\r\\n if system.open_ended_grading_interface:\\r\\n self.peer_gs = PeerGradingService(system.open_ended_grading_interface, system)\\r\\n else:\\r\\n self.peer_gs = MockPeerGradingService()\\r\\n\\r\\n self.required_peer_grading = instance_state.get('required_peer_grading', 3)\\r\\n self.peer_grader_count = instance_state.get('peer_grader_count', 3)\\r\\n self.min_to_calibrate = instance_state.get('min_to_calibrate', 3)\\r\\n self.max_to_calibrate = instance_state.get('max_to_calibrate', 6)\\r\\n self.peer_grade_finished_submissions_when_none_pending = instance_state.get(\\r\\n 'peer_grade_finished_submissions_when_none_pending', False\\r\\n )\\r\\n\\r\\n due_date = get_extended_due_date(instance_state)\\r\\n grace_period_string = instance_state.get('graceperiod', None)\\r\\n try:\\r\\n self.timeinfo = TimeInfo(due_date, grace_period_string)\\r\\n except Exception:\\r\\n log.error(\\\"Error parsing due date information in location {0}\\\".format(location))\\r\\n raise\\r\\n self.display_due_date = self.timeinfo.display_due_date\\r\\n\\r\\n self.rubric_renderer = CombinedOpenEndedRubric(system, True)\\r\\n rubric_string = stringify_children(definition['rubric'])\\r\\n self._max_score = self.rubric_renderer.check_if_rubric_is_parseable(rubric_string, location, MAX_SCORE_ALLOWED)\\r\\n\\r\\n # Static data is passed to the child modules to render\\r\\n self.static_data = {\\r\\n 'max_score': self._max_score,\\r\\n 'max_attempts': self.max_attempts,\\r\\n 'prompt': definition['prompt'],\\r\\n 'rubric': definition['rubric'],\\r\\n 'display_name': self.display_name,\\r\\n 'accept_file_upload': self.accept_file_upload,\\r\\n 'close_date': self.timeinfo.close_date,\\r\\n 's3_interface': self.system.s3_interface,\\r\\n 'skip_basic_checks': self.skip_basic_checks,\\r\\n 'control': {\\r\\n 'required_peer_grading': self.required_peer_grading,\\r\\n 'peer_grader_count': self.peer_grader_count,\\r\\n 'min_to_calibrate': self.min_to_calibrate,\\r\\n 'max_to_calibrate': self.max_to_calibrate,\\r\\n 'peer_grade_finished_submissions_when_none_pending': (\\r\\n self.peer_grade_finished_submissions_when_none_pending\\r\\n ),\\r\\n }\\r\\n }\\r\\n\\r\\n self.task_xml = definition['task_xml']\\r\\n self.location = location\\r\\n self.fix_invalid_state()\\r\\n self.setup_next_task()\",\n \"def _create_child_group(self, name) -> \\\"GroupBase\\\":\\n pass\",\n \"def __initChild(self):\\n if self.__child is None:\\n self.__child = []\\n self._populateChild()\",\n \"def create_child_with_current_counts(self):\\n\\t\\tself.tree.children.append(self.tree.makeTree(self.tree.root, self.tree, self.tree))\",\n \"def startTreeBasedCoord(self):\\n self.log_message('ID {0} starts Load Propagation Optimization'.format(self.CommID))\\n #self.MsgReceiveCount_interval = 0\\n #self.MsgSendCount_interval = 0\\n\\n self.noOfTimesteps = (self.toTime - self.fromTime) / self.stepSize + 1\\n\\n # calculate pool of schedules (also saved in self.schedules) and schedule load curves\\n if self.getTER1() != 0: # if not a gas boiler\\n self.calcSchedulePool(self.fromTime, self.toTime)\\n self.calcScheduleConsumptionCurves()\\n\\n if not self.Parent: #root node\\n random.seed() # initialize pseudo random number generator\\n\\n\\n\\n # leave nodes select initial best schedule from schedule pool based on fluctuations curve and propagate their load to parent\\n if not self.Children:\\n #self.ChildrenProcessed = [0 for x in range(len(self.Children))]\\n if self.getTER1() != 0: # not a gas boiler\\n self.selectBestSchedule(copy.deepcopy(self.ERemainderLocal))\\n self.setSOC(self.SOCEnd[self.chosenScheduleIndex])\\n self.setStateModlvl(self.chosenSchedule[-1])\\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(self.EConsumptionChosenSchedule)])\\n else:\\n zeros = [0 for x in range(len(self.ERemainderLocal))]\\n self.sendMessage(self.Parent, 40, ['newload', copy.deepcopy(zeros)])\\n\\n else: # if not a leave node\\n self.EConsumptionChildCurves = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\\n self.EConsumptionChildCurvesRec = [ [0 for x in range(len(self.EFluctuationCurve))] for y in range(len(self.Children))] # initialize array for load curves of children\\n self.noOfConsumptionCurvesReceived = 0\\n #self.ChildLoadCurvesChosen = [0 for x in range(len(self.Children))]\\n return\",\n \"def visit_children(self, func):\\n for child in self._children:\\n func(child)\",\n \"def make_objects(self):\\n pass\",\n \"def build(self, parent):\\n raise NotImplementedError\",\n \"def generate_children(self, current_state):\\n # Define a list of the possible moves that this current state can make\\n list_of_possible_moves = []\\n\\n # Find the index of the '0' tile\\n index = current_state.index('0')\\n\\n # Check all the possible moves and see which are possible for this current state\\n move_up_copy = current_state.copy()\\n result = self.move_up(move_up_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((move_up_copy, self.cost_of_move_up, 'move_up', result[1]))\\n\\n move_down_copy = current_state.copy()\\n result = self.move_down(move_down_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((move_down_copy, self.cost_of_move_down, 'move_down', result[1]))\\n\\n move_left_copy = current_state.copy()\\n result = self.move_left(move_left_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((move_left_copy, self.cost_of_move_left, 'move_left', result[1]))\\n\\n move_right_copy = current_state.copy()\\n result = self.move_right(move_right_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((move_right_copy, self.cost_of_move_right, 'move_right', result[1]))\\n\\n # Two possible moves can be done if the wrap is allowed\\n if self.can_move_wrap(index):\\n # The regular (horizontal) wrap\\n regular_wrap_copy = current_state.copy()\\n result = self.wrap(regular_wrap_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((regular_wrap_copy, self.cost_of_wrap_move, 'wrap', result[1]))\\n\\n # The scaled-up (vertical) wrap\\n scaled_wrap_copy = current_state.copy()\\n result = self.wrap_scale(scaled_wrap_copy)\\n if result[0] > 0:\\n list_of_possible_moves.append((scaled_wrap_copy, self.cost_of_wrap_move, 'wrap_scale', result[1]))\\n # end: if\\n\\n # Two possible moves can be done if the diagonal action is allowed\\n if self.can_move_diagonally(index):\\n # The diagonal adjacent:\\n diagonal_adjacent_copy = current_state.copy()\\n result = self.diagonal_adjacent(diagonal_adjacent_copy)\\n list_of_possible_moves.append(\\n (diagonal_adjacent_copy, self.cost_of_diagonal_adjacent, 'diagonal_adjacent', result[1]))\\n\\n # The diagonal across:\\n diagonal_across_copy = current_state.copy()\\n result = self.diagonal_across(diagonal_across_copy)\\n list_of_possible_moves.append(\\n (diagonal_across_copy, self.cost_of_diagonal_across, 'diagonal_across', result[1]))\\n # end: if\\n\\n # Return the list of possible moves\\n return list_of_possible_moves\",\n \"def _monit(self):\\n # For each children\\n for index, (cls, kwargs, proc) in enumerate(self._children):\\n\\n # Spawn children if required\\n if proc is None:\\n\\n try:\\n self._children[index][2] = cls(**kwargs)\\n self._children[index][2].start()\\n except Exception as e:\\n self._children.pop(index)\\n logger.error(f'Could not instantiate/spawn child \\\\'{cls.__name__}\\\\' due to: {str(e)}')\\n logger.info(f'Removed child \\\\'{cls.__name__}\\\\' from processes list.')\\n\\n elif not (proc.is_alive() or proc.exitcode is None):\\n\\n # Join process and delete instance\\n proc.join(timeout=0.1)\\n self._children[index][2] = None\",\n \"def parents_loop(self):\\r\\n while len(self.parents) > 0:\\r\\n children = 0\\r\\n self.parent1 = random.choice(self.parents)\\r\\n index = self.parents.index(self.parent1)\\r\\n del self.parents[index]\\r\\n\\r\\n self.parent2 = random.choice(self.parents)\\r\\n index = self.parents.index(self.parent2)\\r\\n del self.parents[index]\\r\\n\\r\\n while children < 2:\\r\\n self.child = copy.deepcopy(self.parent1)\\r\\n \\r\\n self.battery_loop()\\r\\n\\r\\n childsolution = random_algo.Random(self.child, self.cable_cost, self.battery_cost)\\r\\n childsolution.change_battery_or_house('change_battery')\\r\\n childsolution.change_battery_or_house('change_house')\\r\\n\\r\\n if (self.child.valid_solution() and self.child not in self.district_population\\r\\n and self.child not in self.best_districts and self.child not in self.worst_districts):\\r\\n self.district_population.append(self.child)\\r\\n self.cost_populations.append(self.child.total_cost(self.battery_cost, self.cable_cost))\\r\\n children += 1\",\n \"def initialize_children(self, bibs):\\n\\t\\tpass\",\n \"def emp_line_strategy(self, game_state):\\n self.build_basic_base(game_state)\\n\\n \\\"\\\"\\\"\\n Build corner defense.\\n \\\"\\\"\\\"\\n self.build_defences(game_state)\\n\\n \\\"\\\"\\\"\\n Finally deploy our information units to attack.\\n \\\"\\\"\\\"\\n self.deploy_attackers(game_state)\",\n \"def _makeAndAssignSpecialties(self):\\n workflowTool = getToolByName(self.portal, 'portal_workflow')\\n def makeSpecialties(node, container, explicitSpecialties):\\n \\\"\\\"\\\"Make specialties inside `container` according to the tree-shaped dict `node`. Append the created specialties (unless marked as {'associated': False}) to the list `explicitSpecialties`.\\\"\\\"\\\"\\n for child in node.get('children', []):\\n id = child['id']\\n container.invokeFactory(type_name='FSDSpecialty', id=id, title=child['title'])\\n newSpecialty = container[id]\\n workflowTool.doActionFor(newSpecialty, 'publish')\\n if child.get('associated', True):\\n explicitSpecialties.append(newSpecialty)\\n makeSpecialties(child, newSpecialty, explicitSpecialties)\\n \\n # Create specialties:\\n explicitSpecialties = []\\n makeSpecialties({'children':\\n [{'id': 'sanitation', 'title': 'Sanitation', 'children':\\n [{'id': 'picking-stuff-up', 'title': 'Picking stuff up'},\\n {'id': 'hosing-stuff-down', 'title': 'Hosing stuff off'},\\n {'id': 'keeping-stuff-from-getting-so-messed-up-to-begin-with', 'title': 'Keeping stuff from getting so dirty in the first place'}]},\\n {'id': 'mastication', 'title': 'Mastication', 'associated': False, 'children':\\n [{'id': 'chomping', 'title': 'Chomping'}]}]}, self.directory.getSpecialtiesFolder(), explicitSpecialties)\\n \\n # Assign them to the person:\\n rulesetId = getToolByName(self.portal, 'relations_library').getRuleset('people_specialties').getId()\\n personUid = self.person.UID()\\n explicitSpecialties.reverse() # Otherwise, testSpecialtiesAreOrdered never fails, because specialties tend to get returned by getSpecialties() in the order they were assigned.\\n for s in explicitSpecialties:\\n process(self.portal, connect=((personUid, s.UID(), rulesetId),)) # You mustmustmust use the Relations API to add references, sayeth Relations/doc/Overview.txt.\\n \\n # Add a research topic for Sanitation:\\n refCatalog = getToolByName(self.portal, 'reference_catalog')\\n sanitationRef = refCatalog.getReferences(self.person, relationship='people_specialties', targetObject=self.directory.getSpecialtiesFolder()['sanitation'])[0]\\n sanitationRef.getContentObject().setResearchTopic('Picking up sprockets from bowls of soup')\",\n \"def build_context(component, weight_variables,\\n input_filename=\\\"[Unknown-Filename]\\\", hierarchical_mode=False):\\n for i, regime in enumerate(component.regimes):\\n regime.flag = FIRST_REGIME_FLAG + i\\n regime.label = regime.name.replace(' ', '').replace('-', '_').upper()\\n if not weight_variables:\\n weight_variables = {'': guess_weight_variable(component)}\\n\\n # THIS IS JUST NASTY.\\n # TODO - PROPERLY WITH A DICTIONARY.\\n FIRST_TRANSITION_FLAG = 5000\\n for i, transition in enumerate(component.transitions):\\n n = FIRST_TRANSITION_FLAG + i\\n transition.label = 'TRANSITION%d'%n\\n transition.flag = n\\n\\n assert component.is_flat()\\n weights_as_states = False\\n if hierarchical_mode:\\n weights_as_states = True\\n\\n # Close\\n component.backsub_all()\\n\\n # Resolve Randomness:\\n rand = NeuronExprRandomBuilder()\\n rand.visit(component)\\n\\n #if rand.has_random_functions():\\n # libfilefull = get_ninemlnrnlibfile()\\n # libdir = get_ninemlnrnlibdir()\\n # print 'LibFileFull', libfilefull\\n # if not os.path.exists( libfilefull ):\\n # err = 'Random Library Proxy not built: %s.\\\\nRun make in %s'%(libfilefull, libdir)\\n # raise NineMLRuntimeError(err)\\n #\\n # LD_LIB_PATH = 'LD_LIBRARY_PATH'\\n # err = \\\" *** WARNING CAN'T FIND %s in LD_LIBRARY_PATH\\\\nTHERE MAY BE A PROBLEM USING RANDOM FUNCTIONS\\\"%libdir\\n # if not LD_LIB_PATH in os.environ:\\n # raise NineMLRuntimeError(err)\\n # else:\\n # if not libdir in os.environ[LD_LIB_PATH]:\\n # raise NineMLRuntimeError(err)\\n\\n event_based = sum(len(list(r.time_derivatives)) for r in component.regimes) == 0\\n\\n context = {\\n \\\"input_filename\\\": input_filename,\\n \\\"version\\\": nineml.__version__,\\n \\\"component\\\": component,\\n \\\"channels\\\": build_channels(component),\\n \\\"weight_variables\\\": weight_variables,\\n \\\"get_weight_variable\\\": get_weight_variable,\\n \\\"initial_regime\\\": list(component.regimes)[0].label,\\n \\\"as_expr\\\": as_expr,\\n \\\"deriv_func_args\\\": deriv_func_args,\\n \\\"ode_for\\\": ode_for,\\n\\n # Added by Mike:\\n \\\"weights_as_states\\\": weights_as_states,\\n 'get_on_event_channel': get_on_event_channel,\\n 'random_functions': rand.get_modl_function_defs(),\\n\\n 'event_based': event_based\\n }\\n return context\",\n \"def create_child(parent, idx):\\n boardCopy = deepcopy(parent.currentBoardState)\\n action = boardCopy.get_available_actions()[idx]\\n parent.children[idx] = DecisionTree(boardCopy, action, parent.level+1, parent, strategy=parent.strategy)\",\n \"def copy_children(self):\\n\\n # Create a group\\n self.fileh.create_group('/', 'agroup')\\n # Create several objects there\\n for i in range(10):\\n # Create a new array\\n self.fileh.create_array('/agroup', 'array' + str(i), self.a1)\\n # Excercise copy_children\\n for i in range(self.nobjects):\\n # Create another group for destination\\n self.fileh.create_group('/', 'anothergroup' + str(i))\\n # Copy children from /agroup to /anothergroup+i\\n self.fileh.copy_children('/agroup', '/anothergroup' + str(i))\\n # Put a mark\\n self.fileh.mark()\\n # Unwind all marks sequentially\\n for i in range(self.niter):\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.undo()\\n if verbose:\\n print(\\\"u\\\", end=' ')\\n if verbose:\\n print()\\n undo = clock() - t1\\n # Rewind all marks sequentially\\n t1 = clock()\\n for i in range(self.nobjects):\\n self.fileh.redo()\\n if verbose:\\n print(\\\"r\\\", end=' ')\\n if verbose:\\n print()\\n redo = clock() - t1\\n\\n print((\\\"Time for Undo, Redo (copy_children):\\\", undo, \\\"s, \\\",\\n redo, \\\"s\\\"))\",\n \"def populate_tools_and_factors(self):\\n for tool_channel in self.channel_manager.tool_channels:\\n if tool_channel.channel_id == \\\"tools\\\":\\n # These are the core tools\\n setattr(self, \\\"tools\\\", ToolContainer())\\n setattr(self, \\\"factors\\\", FactorContainer())\\n tool_container = getattr(self, \\\"tools\\\")\\n factor_container = getattr(self, \\\"factors\\\")\\n else:\\n # This is a plugin, so ends in \\\"_tools\\\"\\n plugin_name = \\\"_\\\".join(tool_channel.channel_id.split(\\\"_\\\")[:-1])\\n setattr(self.plugins, plugin_name, PluginWrapper())\\n plugin = getattr(self.plugins, plugin_name)\\n tool_container = plugin.tools\\n factor_container = plugin.factors\\n\\n for tool_stream in tool_channel.streams:\\n try:\\n # This is the tool initializer\\n tool_function = self.channel_manager.get_tool_class(tool_stream.name)\\n setattr(tool_container, tool_stream.name, tool_function)\\n\\n def create_factory_function(tool_func):\\n \\\"\\\"\\\"\\n This wrapper is needed to capture the tool_function closure\\n\\n :param tool_func: The tool function\\n :return: The factory function\\n\\n \\\"\\\"\\\"\\n base = tool_function.__bases__[0]\\n if base == Tool:\\n def tool_factory_function(sources, alignment_node=None, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param sources: source nodes\\n :param alignment_node: alignment node\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.alignment_node == alignment_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(**parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources,\\n alignment_node=alignment_node)\\n\\n return tool_factory_function\\n elif base == MultiOutputTool:\\n def tool_factory_function(source, splitting_node=None, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param source: source node\\n :param splitting_node: splitting node\\n :return: the created factor\\n :type source: Node\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.source == source\\n and m.splitting_node == splitting_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(**parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n source=source,\\n splitting_node=splitting_node)\\n\\n return tool_factory_function\\n\\n elif base == AggregateTool:\\n def tool_factory_function(sources, alignment_node, aggregation_meta_data, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param aggregation_meta_data: the meta data to aggregate over\\n :param sources: source nodes\\n :param alignment_node: alignment node\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.alignment_node == alignment_node\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(aggregation_meta_data=aggregation_meta_data, **parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources,\\n alignment_node=alignment_node)\\n\\n return tool_factory_function\\n elif base == SelectorTool:\\n def tool_factory_function(sources, selector_meta_data, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param selector_meta_data: the meta data to select over\\n :param sources: source nodes\\n :return: the created factor\\n :type sources: list[Node] | tuple[Node] | None\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n # find matching tools (possibly different parameters)\\n matches = [f for f in self.current_workflow.factors if\\n f.tool.__class__ == tool_func]\\n # make sure parameters are all the same\\n full_matches = [m for m in matches if m.sources == sources\\n and m.selector_meta_data == selector_meta_data\\n and dict(m.tool.parameters_dict) == parameters]\\n\\n if len(full_matches) == 1:\\n tool = full_matches[0].tool\\n else:\\n tool = tool_func(selector_meta_data=selector_meta_data, **parameters)\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool,\\n sources=sources)\\n\\n return tool_factory_function\\n elif base == PlateCreationTool:\\n def tool_factory_function(source, **parameters):\\n \\\"\\\"\\\"\\n Factory function for creating factors inside a workflow\\n\\n :param source: source node\\n :return: the created factor\\n :type source: Node\\n\\n \\\"\\\"\\\"\\n if not self.current_workflow:\\n raise ValueError(\\\"No workflow context - use create_workflow first\\\")\\n\\n return dict(\\n workflow=self.current_workflow,\\n tool=tool_func(**parameters),\\n source=source)\\n\\n return tool_factory_function\\n else:\\n raise NotImplementedError\\n\\n setattr(factor_container, tool_stream.name, create_factory_function(tool_function))\\n\\n except (NameError, AttributeError, ImportError) as e:\\n logging.warn('Unable to load tool {}: {}'.format(tool_stream.name, e))\",\n \"def generate_hierarchy(self,descr):\\n # assert the existence of all the keys we need to set up at least on level\\n assert 'problem_class' in descr\\n assert 'problem_params' in descr\\n assert 'dtype_u' in descr\\n assert 'dtype_f' in descr\\n assert 'sweeper_class' in descr\\n assert 'level_params' in descr\\n\\n # convert problem-dependent parameters consisting of dictionary of lists to a list of dictionaries with only a\\n # single entry per key, one dict per level\\n pparams_list = self.__dict_to_list(descr['problem_params'])\\n # put this newly generated list into the description dictionary (copy to avoid changing the original one)\\n descr_new = cp.deepcopy(descr)\\n descr_new['problem_params'] = pparams_list\\n # generate list of dictionaries out of the description\\n descr_list = self.__dict_to_list(descr_new)\\n\\n # sanity check: is there a transfer class? is there one even if only a single level is specified?\\n if len(descr_list) > 1:\\n assert 'transfer_class' in descr_new\\n assert 'transfer_params' in descr_new\\n elif 'transfer_class' in descr_new:\\n print('WARNING: you have specified transfer classes, but only a single level...')\\n\\n # generate levels, register and connect if needed\\n for l in range(len(descr_list)):\\n\\n # check if we have a hook on this list. if not, use default class.\\n if 'hook_class' in descr_list[l]:\\n hook = descr_list[l]['hook_class']\\n else:\\n hook = hookclass.hooks\\n\\n if 'sweeper_params' in descr_list[l]:\\n swparams = descr_list[l]['sweeper_params']\\n else:\\n swparams = {}\\n\\n if not 'collocation_class' in swparams:\\n assert 'collocation_class' in descr_list[l]\\n swparams['collocation_class'] = descr_list[l]['collocation_class']\\n\\n if not 'num_nodes' in swparams:\\n assert 'num_nodes' in descr_list[l]\\n swparams['num_nodes'] = descr_list[l]['num_nodes']\\n\\n L = levclass.level(problem_class = descr_list[l]['problem_class'],\\n problem_params = descr_list[l]['problem_params'],\\n dtype_u = descr_list[l]['dtype_u'],\\n dtype_f = descr_list[l]['dtype_f'],\\n sweeper_class = descr_list[l]['sweeper_class'],\\n sweeper_params = swparams,\\n level_params = descr_list[l]['level_params'],\\n hook_class = hook,\\n id = 'L'+str(l))\\n\\n self.register_level(L)\\n\\n if l > 0:\\n self.connect_levels(transfer_class = descr_list[l]['transfer_class'],\\n transfer_params = descr_list[l]['transfer_params'],\\n fine_level = self.levels[l-1],\\n coarse_level = self.levels[l])\",\n \"def __init__(self, mech, nodes, traceable, intermediates, bottomup = True):\\n # Internalize arguments for later use\\n self.__mech = mech\\n self.__traceable = set(traceable)\\n self.__intermediates = set(intermediates)\\n self.__bottomup = bottomup\\n \\n # make sure that nodes is a list of nodes\\n if isinstance(nodes, Species):\\n nodes = [nodes]\\n\\n # Initialize dictionaries for storing\\n # source data\\n self.origins = {}\\n self.origin_loss = {}\\n\\n # Producers is a dictionary (keys = species; values = dictionaries of producers) \\n # that contains integrated production arrays\\n #\\n # Example: {'CO': {'Transport': array([8,5,6,...]), ...}}\\n self.producers = {}\\n \\n # Concentrations is a dictionary (keys = species; values dictionary \\n # initial, average, and final concentration arrays. Similar to producers\\n self.concentrations = {}\\n \\n # Production is a dictionary of gross production each species\\n self.production = {}\\n \\n # Losses is a dictionary of gross consumption of each species\\n self.losses = {}\\n\\n # Preset traced nodes as those provided by the user\\n self.traced = set(nodes)\\n \\n \\n # Storing data about input shapes\\n tmp_init = mech('INIT')\\n self.__old_shape = tmp_init[list(tmp_init.keys())[0]].shape\\n self.__shape = [i for i in self.__old_shape]\\n self.__ntimes = mech.mrg.variables['TFLAG'].shape[-3]\\n for i, s in enumerate(self.__shape):\\n if s == self.__ntimes:\\n self.__shape[i] = self.__ntimes + 1\\n self.__time_dim = i\\n self.__shape = tuple(self.__shape)\\n \\n self.run()\",\n \"def check_objects_have_parents_and_are_not_referenced_twice(self):\\n # logger.debug(\\\"ports:\\\")\\n all_objs = crest.get_all_ports(self.model)\\n # for o in all_objs:\\n # print(o._name, o._parent)\\n for obj in all_objs:\\n assert all_objs.count(obj) == 1, f\\\"Port {obj._name} has been used multiple times\\\"\\n assert obj._parent is not None, f\\\"Port {obj._name} has no parent definition\\\"\\n\\n # logger.debug(\\\"states:\\\")\\n all_objs = crest.get_all_states(self.model)\\n # for o in all_objs:\\n # print(o._name, o._parent)\\n for obj in all_objs:\\n assert all_objs.count(obj) == 1, f\\\"State {obj._name} has been used multiple times\\\"\\n assert obj._parent is not None, f\\\"State {obj._name} has no parent definition\\\"\\n\\n # logger.debug(\\\"updates:\\\")\\n all_objs = crest.get_all_updates(self.model)\\n # for o in all_objs:\\n # print(o._name, o._parent)\\n for obj in all_objs:\\n assert all_objs.count(obj) == 1, f\\\"Update {obj._name} has been used multiple times\\\"\\n assert obj._parent is not None, f\\\"Update {obj._name} has no parent definition\\\"\\n\\n # logger.debug(\\\"influences\\\")\\n all_objs = crest.get_all_influences(self.model)\\n # for o in all_objs:\\n # print(o._name, o._parent)\\n for obj in all_objs:\\n assert all_objs.count(obj) == 1, f\\\"Influence {obj._name} has been used multiple times\\\"\\n assert obj._parent is not None, f\\\"Influence {obj._name} has no parent definition\\\"\\n\\n # logger.debug(\\\"transitions:\\\")\\n all_objs = crest.get_all_transitions(self.model)\\n # for o in all_objs:\\n # print(o._name, o._parent)\\n for obj in all_objs:\\n assert all_objs.count(obj) == 1, f\\\"Transition '{obj._name}' has been used multiple times\\\"\\n assert obj._parent is not None, f\\\"Transition '{obj._name}' has no parent definition\\\"\",\n \"def __init__(self, state, parent, action, path_cost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.path_cost = path_cost\\n self.depth = 0\\n if parent:\\n self.depth = parent.depth + 1\",\n \"def _derived_features(self):\\n for created_feature, creator in self.feature_creators.items():\\n self.parameters[created_feature] = creator(self.parameters)\",\n \"def make(config):\\n # Create child folders\\n for func in (create_basic_structure,\\n copy_resources,\\n copy_databases,\\n copy_libraries,\\n copy_security,\\n copy_app_actions,\\n copy_pages,\\n create_application_info_file,\\n replace_all_guids):\\n\\n INFO(\\\"\\\")\\n INFO(\\\"+\\\"*70)\\n INFO(\\\"\\\")\\n func(config)\",\n \"def _prepareNewChild(self):\\n\\n # Register exit listener. We cannot immediately spawn new child when we\\n # get a modified event. Must wait that child has closed database etc.\\n atexit.register(self._childExitHandler)\\n\\n # Make sure that PID files and locks stay here, because dying child\\n # will clear them.\\n self.makeLockFile()\\n self.makePidFile()\\n\\n self.storage_index.restore()\\n\\n notify(NewChildForked(self))\\n\\n autoinclude.include_deferred()\\n fiveconfigure.install_deferred()\",\n \"def getChildren():\",\n \"def update_childs(self, _tasks):\\n tasks = copy.deepcopy(_tasks)\\n for child in tasks.keys():\\n\\n # only process init state tasks\\n if tasks[child].state != self.STATE_INIT:\\n continue\\n\\n # if erased and none\\n if not tasks[child].require:\\n continue\\n\\n # process all childs\\n for r_tid in tasks[child].require:\\n\\n # if child id is not me, ignore\\n if r_tid != self.tid:\\n continue\\n\\n # success\\n elif self.state == self.STATE_SUCCESS:\\n tasks[child].del_require(r_tid)\\n yield {tasks[child].tid: tasks[child]}\\n\\n # task running\\n elif self.state == self.STATE_RUNNING:\\n continue\\n\\n # task error\\n elif self.state < self.STATE_INIT:\\n tasks[child].state = self.STATE_DEPENDENCY\\n tasks[child].del_require(r_tid)\\n\\n yield {tasks[child].tid: tasks[child]}\\n\\n # recurse and mark child of child as dependency error\\n for item in tasks[child].update_childs(tasks):\\n yield item\",\n \"def gen_child(self, g, ng, child):\\n with About(child.debug, self.relation):\\n self.remap_node((g, child), g, child, ng, ng.apply())\",\n \"def __init__(self, obj, datamodel=None):\\n with RecursiveConverter.in_progress:\\n self.obj = obj\\n self.class_name = obj.__class__.__name__\\n self.datamodel = datamodel\\n self.is_root = datamodel is None\\n if self.is_root:\\n RecursiveConverter.converted_modules = {}\\n RecursiveConverter.typedefs = []\\n self.datamodel = VHDLModule('-', obj)\\n\\n # recursively convert all child modules\\n self.childs = []\\n\\n def conv(self, node):\\n if isinstance(node, VHDLList):\\n if node.elements_compatible_typed:\\n if isinstance(node.elems[0], VHDLModule):\\n if self.is_compatible_with_converted_module(node.elems[0]):\\n return\\n self.childs.append(RecursiveConverter(node.elems[0].current, node.elems[0]))\\n\\n else:\\n # dynamic list..need to convert all modules\\n for x in node.elems:\\n if isinstance(x, VHDLModule):\\n if self.is_compatible_with_converted_module(x):\\n return\\n self.childs.append(RecursiveConverter(x.current, x))\\n elif isinstance(node, VHDLModule):\\n if self.is_compatible_with_converted_module(node):\\n return\\n self.childs.append(RecursiveConverter(node.current, node))\\n\\n if self.is_root:\\n logger.info(f'Creating top.vhd ...')\\n self.top_vhdl = TopGenerator(obj)\\n\\n # maybe some input/output is a convertible module?\\n for node in self.inputs:\\n conv(self, node)\\n\\n for node in self.outputs:\\n conv(self, node)\\n\\n # iterate all functions and discover local variables that may need to be converted\\n for x in self.obj.__dict__.values():\\n if isinstance(x, PyhaFunc):\\n for key, val in x.get_local_types().items():\\n if isinstance(val, Hardware):\\n node = init_vhdl_type(key, val)\\n conv(self, node)\\n\\n # convert instance elements before the instance itself, recursive\\n for node in self.datamodel.elems:\\n conv(self, node)\\n\\n self.red_node = get_objects_rednode(obj)\\n convert_name = self.get_module_converted_name(self.datamodel)\\n logger.info(f'{convert_name} to VHDL ...')\\n\\n self.conv = convert(self.red_node, obj) # actual conversion happens here\\n\\n self.vhdl_conversion = str(self.conv)\\n RecursiveConverter.converted_modules[convert_name] = (self.datamodel, self.vhdl_conversion)\\n RecursiveConverter.typedefs.extend(self.conv.build_typedefs())\",\n \"def get_child_resource_nodes(self):\\n raise errors.Unimplemented()\",\n \"def _create_pipeline(self):\\n # Add boxes to the pipeline\\n if self.box_tag not in self.proto:\\n raise Exception(\\n \\\"Box defined in '{0}' has no '<{1}>' declared.\\\".format(\\n self._xmlfile, self.box_tag))\\n switch_descs = []\\n for box_item in self.proto[self.box_tag]:\\n for box_type in box_item.keys():\\n\\n # Create processing boxes (can be iterative)\\n if box_type == self.box_names[0]:\\n for boxdesc in box_item[box_type]:\\n self._add_box(boxdesc)\\n # Create switch boxes\\n elif box_type == self.box_names[1]:\\n for switchdesc in box_item[box_type]:\\n switch_descs.append(switchdesc)\\n # Unrecognize box type\\n else:\\n raise ValueError(\\n \\\"Box structure: '{0}' defined in '{1}' is not \\\"\\n \\\"supported. Supported boxes are '{2}'.\\\".format(\\n json.dumps(box_item, indent=2), self._xmlfile,\\n self.box_names))\\n\\n # Add switch to the pipeline\\n for switchdesc in switch_descs:\\n self._add_switch(switchdesc)\\n\\n # Add links between boxes\\n if self.link_tag not in self.proto:\\n raise Exception(\\n \\\"Box defined in '{0}' has no '<{1}>' declared.\\\".format(\\n self._xmlfile, self.link_tag))\\n for link_item in self.proto[self.link_tag]:\\n inner_tag = self.link_tag[:-1]\\n for linkdesc in link_item[inner_tag]:\\n if is_io_control(linkdesc[self.link_attributes[0]]):\\n linktype = \\\"input\\\"\\n elif is_io_control(linkdesc[self.link_attributes[1]]):\\n linktype = \\\"output\\\"\\n else:\\n linktype = \\\"link\\\"\\n self._add_link(linkdesc, linktype)\",\n \"def _initialize_trees(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.605448","0.5835285","0.57355165","0.57282794","0.56974614","0.5680976","0.56371605","0.5522915","0.54681087","0.5428466","0.54168093","0.5416636","0.5369338","0.5354371","0.53340364","0.5281433","0.5277179","0.52718735","0.52553463","0.5245438","0.52121687","0.51818347","0.5178032","0.51749575","0.515244","0.5150384","0.51493764","0.5127383","0.512326","0.5122019","0.51189744","0.5117783","0.5113059","0.50957495","0.508905","0.5083511","0.5083383","0.5071787","0.5070194","0.50414604","0.5040213","0.5032341","0.5012239","0.5002526","0.49990475","0.49908662","0.49844986","0.49753138","0.4971252","0.49599108","0.4957639","0.49544808","0.49503934","0.49498308","0.49421224","0.49401438","0.49303484","0.4926579","0.49228495","0.49122187","0.49105573","0.49046934","0.49010876","0.49000302","0.4872954","0.48725563","0.48707005","0.48686594","0.48680726","0.48661098","0.48658517","0.48591274","0.48567066","0.48524612","0.4849097","0.48474577","0.48458362","0.48436514","0.48435396","0.4841853","0.48407197","0.48341024","0.4833386","0.48293564","0.48221382","0.481177","0.480323","0.4800786","0.4798198","0.4796245","0.47961885","0.47954044","0.47870362","0.47843474","0.478383","0.47808605","0.47724915","0.47700295","0.47691032","0.47682974"],"string":"[\n \"0.605448\",\n \"0.5835285\",\n \"0.57355165\",\n \"0.57282794\",\n \"0.56974614\",\n \"0.5680976\",\n \"0.56371605\",\n \"0.5522915\",\n \"0.54681087\",\n \"0.5428466\",\n \"0.54168093\",\n \"0.5416636\",\n \"0.5369338\",\n \"0.5354371\",\n \"0.53340364\",\n \"0.5281433\",\n \"0.5277179\",\n \"0.52718735\",\n \"0.52553463\",\n \"0.5245438\",\n \"0.52121687\",\n \"0.51818347\",\n \"0.5178032\",\n \"0.51749575\",\n \"0.515244\",\n \"0.5150384\",\n \"0.51493764\",\n \"0.5127383\",\n \"0.512326\",\n \"0.5122019\",\n \"0.51189744\",\n \"0.5117783\",\n \"0.5113059\",\n \"0.50957495\",\n \"0.508905\",\n \"0.5083511\",\n \"0.5083383\",\n \"0.5071787\",\n \"0.5070194\",\n \"0.50414604\",\n \"0.5040213\",\n \"0.5032341\",\n \"0.5012239\",\n \"0.5002526\",\n \"0.49990475\",\n \"0.49908662\",\n \"0.49844986\",\n \"0.49753138\",\n \"0.4971252\",\n \"0.49599108\",\n \"0.4957639\",\n \"0.49544808\",\n \"0.49503934\",\n \"0.49498308\",\n \"0.49421224\",\n \"0.49401438\",\n \"0.49303484\",\n \"0.4926579\",\n \"0.49228495\",\n \"0.49122187\",\n \"0.49105573\",\n \"0.49046934\",\n \"0.49010876\",\n \"0.49000302\",\n \"0.4872954\",\n \"0.48725563\",\n \"0.48707005\",\n \"0.48686594\",\n \"0.48680726\",\n \"0.48661098\",\n \"0.48658517\",\n \"0.48591274\",\n \"0.48567066\",\n \"0.48524612\",\n \"0.4849097\",\n \"0.48474577\",\n \"0.48458362\",\n \"0.48436514\",\n \"0.48435396\",\n \"0.4841853\",\n \"0.48407197\",\n \"0.48341024\",\n \"0.4833386\",\n \"0.48293564\",\n \"0.48221382\",\n \"0.481177\",\n \"0.480323\",\n \"0.4800786\",\n \"0.4798198\",\n \"0.4796245\",\n \"0.47961885\",\n \"0.47954044\",\n \"0.47870362\",\n \"0.47843474\",\n \"0.478383\",\n \"0.47808605\",\n \"0.47724915\",\n \"0.47700295\",\n \"0.47691032\",\n \"0.47682974\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5138674"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":17098,"cells":{"query":{"kind":"string","value":"This function can sum any objects which have __add___"},"document":{"kind":"string","value":"def custom_sum(*args):\n return functools.reduce(lambda x, y: x + y, args)"},"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 __add__(self, other):\r\n return self.add(other)","def __add__(self, other):\n pass","def __add__(self, other):\n pass","def __add__(self, other):\n return self.add(other)","def add(obj):","def __add__(self, other):\n \"*** YOUR CODE HERE ***\"","def __add__(self, other):\n raise NotImplementedError","def __add__(self, other):\n raise NotImplementedError","def __add__(self,other):\n self._obj['u'] += other._obj['u']\n self._obj['v'] += other._obj['v']\n return self._obj","def __radd__(self, other):\n return self + other","def __radd__(self, other):\n return self + other","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __radd__(self, other):\n return self.__add__(other)","def __iadd__(self, other):\n\n return self + other","def __add__(self, other):\n base = deepcopy(self)\n base += other # (+=) == __iadd__\n return base","def __add__(self,l):\r\n\t\t\r\n\t\t# add\r\n\t\ta = self.add(l)\r\n\t\t\r\n\t\treturn a","def __radd__(self, other):\n\n return self.__add__(other)","def __add__(self, other):\n try:\n total = {self.var: 1, other.var: 1}\n return AutoDiffReverse(self.val + other.val, None, der=total)\n except AttributeError:\n return AutoDiffReverse(self.val + other, None, {self.var: 1})","def __add__(self, other):\n if isinstance(other, float) or isinstance(other, int):\n return Complex(self._reNum + other, self._imNum)\n if isinstance(other, complex):\n return Complex(self._reNum + other.real, self._imNum + other.imag)\n return Complex(self._reNum + other._reNum, self._imNum + other._imNum)","def __add__(self, other):\n raise NotImplementedError(\"Implement this if needed\")","def __radd__(self, other):\n return self.runtime.add(self, other)","def __iadd__(self, obj):\n # calls __add__\n tmp = self + obj\n self.data = tmp.data\n return self","def __add__(self, other):\n return add_mps(self, other)","def __iadd__(self, other):\n return (hasattr(other, '__iter__') and self.applyMaterFunc or self.applyScalarFunc)(other, '__add__')","def _add(self, other):\n raise NotImplementedError(\n \"{} does not support addition\".format(type(self)))","def __add__(self, other):\n return asarray(add(self, other))","def __add__(self, other):\n return self + [other]","def __add__(self, other):\n\n return self._binary_elementwise_op(other, np.add)","def add(self, *args):\n sum = 0\n for arg in args:\n sum += float(arg)\n return sum","def __add__(self, other):\n if (len(self.arg) < len(other.arg)):\n summ = Polynomial(other.arg)\n i = len(self.arg) - 1\n for x in self.arg:\n summ.arg[i] = self.arg[i] + summ.arg[i]\n i = i - 1\n else:\n summ = Polynomial(self.arg)\n i = len(other.arg) - 1\n for x in other.arg:\n summ.arg[i] = other.arg[i] + summ.arg[i]\n i = i - 1\n return summ","def __add__(self, other):\n # YOUR CODE HERE\n raise NotImplementedError()","def __add__(self, other: Any) -> None:\n self.add(item = other)\n return","def __add__(self, other: '__class__') -> '__class__':","def __add__(self, other):\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\n return self.sum_complex_num","def __add__(self, other):\n return union(self, other, check_convex=True)","def __add__(self, other):\n if other is None:\n return self\n\n return super().__add__(other)","def __add__(self, value):\r\n if isinstance(value, (int, dec.Decimal)):\r\n return self.__class__(self._real + value, self._imag)\r\n elif isinstance(value, self.__class__):\r\n return self.__class__(self._real + value._real, self._imag + value._imag)\r\n raise TypeError(\r\n 'unsupported operand type(s) for +: {!r} and {!r}'.format(\r\n self.__class__.__name__, value.__class__.__name__\r\n )\r\n )","def __iadd__(self, other: Any) -> None:\n self.add(item = other)\n return","def __add__(self,other):\n if isinstance(other, point):\n return self.add_points(other)\n else:\n return self.add_points_tuple(other)","def __add__(self,sample):\n self.add(sample)","def __add__(self, other):\n if other == 0:\n return self\n\n pmf = Pmf()\n for v1, p1 in self.items():\n for v2, p2 in other.items():\n pmf[v1 + v2] += p1 * p2\n return pmf","def __add__(self, other):\n if isinstance(other, EncryptedNumber):\n return self._add_encrypted(other)\n else:\n return self._add_scalar(other)","def test_add():\n l = [1, 2, 3, 4]\n assert s7.add(*l) == sum(l)\n assert s7.add(100, 200) == 300\n assert s7.add(1.0, 2.0, 100.0) == 103.0","def addition(self):\n\t\treturn lambda anything: self.__class__(\n\t\t\t(self[:], disj, checked_proposition(anything)[:])\n\t\t)","def __add__(self, other):\n if isinstance(other, Factorization):\n other = other.value()\n return self.value() + other","def __add__(self, value):\n out = self.copy()\n out.addMath(Query.Math.Add, value)\n return out","def ADD (self, n1, n2):","def __add__(self,that):\n return self.__opExpand2(that,np.add)","def add(self,*datas):\n\t\tresult = sum(datas)\n\t\treturn result","def __iadd__(self, other):\n raise NotImplementedError(\"Implement this if needed\")","def __iadd__(self,l):\r\n\t\t\r\n\t\treturn self.add(l)","def __add__(self, obj):\n if not (type(self) == type(obj)):\n return NotImplemented\n if not (self.size == obj.size):\n raise ValueError(\"Matrices must be the same size for '+'\")\n returnvalue = Matrix()\n for i in range(self._height):\n currentRow = list()\n for j in range(self._width):\n currentRow.append(self._value[i][j] + obj.value[i][j])\n returnvalue.addRow(*currentRow)\n return returnvalue","def __iadd__(self, obj):\n if not vedo.utils.is_sequence(obj):\n obj = [obj]\n for a in obj:\n if a:\n self.AddPart(a)\n return self","def __iadd__(self, other):\n\n if isinstance(other, float):\n self.iadd_scalar(other)\n else:\n self.iadd(other)","def __radd__(self, value):\r\n if isinstance(value, (int, dec.Decimal)):\r\n return self.__class__(value + self._real, self._imag)\r\n elif isinstance(value, self.__class__):\r\n return self.__class__(value._real + self._real, value._imag + self._imag)\r\n raise TypeError(\r\n 'unsupported operand type(s) for +: {!r} and {!r}'.format(\r\n value.__class__.__name__, self.__class__.__name__\r\n )\r\n )","def __add__(self, other):\n cls = self.__class__\n return cls(self.x+other.x, self.y+other.y, self.z+other.z)","def __add__(self, this):\n return self.add(this)","def add(self, a, b):\n return a + b","def add(self):\n return self._do_calc(self.adder)","def add(self):\n return self._do_calc(self.adder)","def add(self):\n return self._do_calc(self.adder)","def __add__(self, other):\n if not (isNumeric(other) or isinstance(other, Expression)):\n error_msg = (\n f'Invalid expression during addition to {self}: [{other}]'\n )\n raise excep.biogemeError(error_msg)\n return Plus(self, other)","def __add__(self, other):\n return self.getArea() + other.getArea()","def smart_add(*args):\n result = 0\n for item in args:\n result += item\n\n return result","def __add__(self, other):\n if isinstance(other, (int, type(Zero()))):\n if other == 0:\n return self\n self._check_dyadic(other)\n return Dyadic(self.args + other.args)","def __add__(self, other: PointOrIterableOrScalar) -> PointType:\n return self.__op(other, operator.add)","def kkAdd(*args):\n if (None in args):\n return None\n total = 0\n for arg in args:\n total += arg\n return total","def __radd__(self, other):\n if not (isNumeric(other) or isinstance(other, Expression)):\n error_msg = (\n f'Invalid expression during addition to {self}: [{other}]'\n )\n raise excep.biogemeError(error_msg)\n return Plus(other, self)","def __add__(self, other):\n return self.concatenate(other)","def __add__(self, other):\n return self.concatenate(other)","def __add__(self, other):\n if isinstance(other, complex):\n return Power(self.power + other, self.power_unit, self.freq, self.freq_unit)\n if self.power_unit != other.power_unit:\n raise ArithmeticError(f\"The objects' ohm units {self.power_unit} and {other.power_unit} are not the same.\")\n if self.freq != other.frequency:\n raise ArithmeticError(f\"The objects' frequency {self.freq} and {other.frequency} are not the same.\")\n if self.freq_unit != other.freq_unit:\n raise ArithmeticError(f\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \"\n f\"are not the same.\")\n power_sum = self.power + other.power\n return Power(power_sum, self.power_unit, self.freq, self.freq_unit)","def __add__( self, other ) :\n\n try :\n other = float( other )\n c_ls = self.copy( )\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] += other\n except :\n self.checkSameSeriesType( other )\n c_l1, c_l2 = self, other\n if( len( self ) < len( other ) ) : c_l1, c_l2 = other, self\n c_ls = c_l1.copy( )\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\n return( c_ls )","def __radd__(self, other):\n if other == 0:\n return self\n else:\n return self.__add__(other)","def __radd__(self, other):\n if other == 0:\n return self\n else:\n return self.__add__(other)","def _sum(self):\n s = 0\n for element, value in self.items():\n s += value\n return s","def __radd__(self, other):\n if isinstance(other, int):\n return self.__add__(other)\n return NotImplemented","def __add__(self, other):\n\n if isinstance(other, type(self)):\n # always create new fields, since otherwise c = a - b changes a as well!\n p = fields(self)\n p.elec[:] = self.elec + other.elec\n p.magn[:] = self.magn + other.magn\n return p\n else:\n raise DataError(\"Type error: cannot add %s to %s\" % (type(other), type(self)))","def __add__(self, obj):\n return self ^ obj","def add(self, value):","def __add__(self, y):\n addend = Counter()\n for key in self:\n if key in y:\n addend[key] = self[key] + y[key]\n else:\n addend[key] = self[key]\n for key in y:\n if key in self:\n continue\n addend[key] = y[key]\n return addend","def __add__(self, y):\n addend = Counter()\n for key in self:\n if key in y:\n addend[key] = self[key] + y[key]\n else:\n addend[key] = self[key]\n for key in y:\n if key in self:\n continue\n addend[key] = y[key]\n return addend","def __radd__(self, other):\n return asarray(add(numpy.asarray(other), self))","def __add__(self, other: t.Any) -> InspectableSet[_C]:\n return self._op_copy('__add__', other)","def __add__(self, _v):\n\t\tif len(self) == len(_v):\n\t\t\tans = copy.deepcopy(self)\n\t\t\tfor i in range(0, self.n):\n\t\t\t\tans[i] += _v[i]\n\t\t\treturn ans","def __add__(self, other) -> 'MultiVector':\n\n other, mv = self._checkOther(other)\n if not mv:\n if isinstance(other, np.ndarray):\n obj = self.__array__()\n return obj + other\n newValue = self.value + other.value\n\n return self._newMV(newValue)","def __add__(self, obj):\n if isinstance(obj, Matrix):\n if self.m != obj.m or self.n != obj.n:\n raise exc.ComformabilityError(\n \"matrices must have the same dimensions\")\n if type(self) is not type(obj):\n raise TypeError(\"matrices must be the same type\")\n data = [[self[i, j] + obj[i, j]\n for j in range(self.n)]\n for i in range(self.m)]\n elif Matrix.is_numeric(obj):\n self._validate_scalar(obj)\n data = [[self[i, j] + obj\n for j in range(self.n)]\n for i in range(self.m)]\n else:\n raise TypeError(\n \"cannot add object of type \" + type(obj).__name__ +\n \" to matrix\")\n return self.__class__(self.m, self.n, data)","def __iadd__(self, other):\n self.append(other)\n return self","def __add__(self,other):\n return Vector(self.x+other.x,self.y+other.y,self.z+other.z)","def __add__(self, other):\n if len(self) != len(other):\n raise ValueError('As dimensões devem ser iguais')\n\n result = Vector(len(self)) # inicia um novo array do tamanho do próprio\n for i in range(len(self)):\n result[i] = self[i] + other[i]\n return result","def add(self, x):\n if type(x) is int:\n self.real += x\n else:\n self.real = self.real + x.real\n self.imag = self.imag + x.imag","def basic_add(mv1, mv2):\n obj = expand(mv1.obj + mv2.obj)\n return MV(obj)","def add( a, b ):\n return a + b","def __add__(self, other):\n if isinstance(other, Trit):\n value = (other,)\n else:\n value = tuple(other)\n return Trits(self.trits + value)","def __iadd__(self, other):\n #print \"adding \", other, \" to \", self\n # need to do shallow copy, or otherwise smth like \"cm += cm\"\n # would loop forever and exhaust memory eventually\n othersets = copy.copy(other.__sets)\n for set in othersets:\n self.add(*set)#[0], set[1])\n return self","def sum(self):\n return sum(self.items())"],"string":"[\n \"def __add__(self, other):\\r\\n return self.add(other)\",\n \"def __add__(self, other):\\n pass\",\n \"def __add__(self, other):\\n pass\",\n \"def __add__(self, other):\\n return self.add(other)\",\n \"def add(obj):\",\n \"def __add__(self, other):\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def __add__(self, other):\\n raise NotImplementedError\",\n \"def __add__(self, other):\\n raise NotImplementedError\",\n \"def __add__(self,other):\\n self._obj['u'] += other._obj['u']\\n self._obj['v'] += other._obj['v']\\n return self._obj\",\n \"def __radd__(self, other):\\n return self + other\",\n \"def __radd__(self, other):\\n return self + other\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n return self.__add__(other)\",\n \"def __iadd__(self, other):\\n\\n return self + other\",\n \"def __add__(self, other):\\n base = deepcopy(self)\\n base += other # (+=) == __iadd__\\n return base\",\n \"def __add__(self,l):\\r\\n\\t\\t\\r\\n\\t\\t# add\\r\\n\\t\\ta = self.add(l)\\r\\n\\t\\t\\r\\n\\t\\treturn a\",\n \"def __radd__(self, other):\\n\\n return self.__add__(other)\",\n \"def __add__(self, other):\\n try:\\n total = {self.var: 1, other.var: 1}\\n return AutoDiffReverse(self.val + other.val, None, der=total)\\n except AttributeError:\\n return AutoDiffReverse(self.val + other, None, {self.var: 1})\",\n \"def __add__(self, other):\\n if isinstance(other, float) or isinstance(other, int):\\n return Complex(self._reNum + other, self._imNum)\\n if isinstance(other, complex):\\n return Complex(self._reNum + other.real, self._imNum + other.imag)\\n return Complex(self._reNum + other._reNum, self._imNum + other._imNum)\",\n \"def __add__(self, other):\\n raise NotImplementedError(\\\"Implement this if needed\\\")\",\n \"def __radd__(self, other):\\n return self.runtime.add(self, other)\",\n \"def __iadd__(self, obj):\\n # calls __add__\\n tmp = self + obj\\n self.data = tmp.data\\n return self\",\n \"def __add__(self, other):\\n return add_mps(self, other)\",\n \"def __iadd__(self, other):\\n return (hasattr(other, '__iter__') and self.applyMaterFunc or self.applyScalarFunc)(other, '__add__')\",\n \"def _add(self, other):\\n raise NotImplementedError(\\n \\\"{} does not support addition\\\".format(type(self)))\",\n \"def __add__(self, other):\\n return asarray(add(self, other))\",\n \"def __add__(self, other):\\n return self + [other]\",\n \"def __add__(self, other):\\n\\n return self._binary_elementwise_op(other, np.add)\",\n \"def add(self, *args):\\n sum = 0\\n for arg in args:\\n sum += float(arg)\\n return sum\",\n \"def __add__(self, other):\\n if (len(self.arg) < len(other.arg)):\\n summ = Polynomial(other.arg)\\n i = len(self.arg) - 1\\n for x in self.arg:\\n summ.arg[i] = self.arg[i] + summ.arg[i]\\n i = i - 1\\n else:\\n summ = Polynomial(self.arg)\\n i = len(other.arg) - 1\\n for x in other.arg:\\n summ.arg[i] = other.arg[i] + summ.arg[i]\\n i = i - 1\\n return summ\",\n \"def __add__(self, other):\\n # YOUR CODE HERE\\n raise NotImplementedError()\",\n \"def __add__(self, other: Any) -> None:\\n self.add(item = other)\\n return\",\n \"def __add__(self, other: '__class__') -> '__class__':\",\n \"def __add__(self, other):\\n self.sum_complex_num = Complex((self.real + other.real), (self.imaginary + other.imaginary))\\n return self.sum_complex_num\",\n \"def __add__(self, other):\\n return union(self, other, check_convex=True)\",\n \"def __add__(self, other):\\n if other is None:\\n return self\\n\\n return super().__add__(other)\",\n \"def __add__(self, value):\\r\\n if isinstance(value, (int, dec.Decimal)):\\r\\n return self.__class__(self._real + value, self._imag)\\r\\n elif isinstance(value, self.__class__):\\r\\n return self.__class__(self._real + value._real, self._imag + value._imag)\\r\\n raise TypeError(\\r\\n 'unsupported operand type(s) for +: {!r} and {!r}'.format(\\r\\n self.__class__.__name__, value.__class__.__name__\\r\\n )\\r\\n )\",\n \"def __iadd__(self, other: Any) -> None:\\n self.add(item = other)\\n return\",\n \"def __add__(self,other):\\n if isinstance(other, point):\\n return self.add_points(other)\\n else:\\n return self.add_points_tuple(other)\",\n \"def __add__(self,sample):\\n self.add(sample)\",\n \"def __add__(self, other):\\n if other == 0:\\n return self\\n\\n pmf = Pmf()\\n for v1, p1 in self.items():\\n for v2, p2 in other.items():\\n pmf[v1 + v2] += p1 * p2\\n return pmf\",\n \"def __add__(self, other):\\n if isinstance(other, EncryptedNumber):\\n return self._add_encrypted(other)\\n else:\\n return self._add_scalar(other)\",\n \"def test_add():\\n l = [1, 2, 3, 4]\\n assert s7.add(*l) == sum(l)\\n assert s7.add(100, 200) == 300\\n assert s7.add(1.0, 2.0, 100.0) == 103.0\",\n \"def addition(self):\\n\\t\\treturn lambda anything: self.__class__(\\n\\t\\t\\t(self[:], disj, checked_proposition(anything)[:])\\n\\t\\t)\",\n \"def __add__(self, other):\\n if isinstance(other, Factorization):\\n other = other.value()\\n return self.value() + other\",\n \"def __add__(self, value):\\n out = self.copy()\\n out.addMath(Query.Math.Add, value)\\n return out\",\n \"def ADD (self, n1, n2):\",\n \"def __add__(self,that):\\n return self.__opExpand2(that,np.add)\",\n \"def add(self,*datas):\\n\\t\\tresult = sum(datas)\\n\\t\\treturn result\",\n \"def __iadd__(self, other):\\n raise NotImplementedError(\\\"Implement this if needed\\\")\",\n \"def __iadd__(self,l):\\r\\n\\t\\t\\r\\n\\t\\treturn self.add(l)\",\n \"def __add__(self, obj):\\n if not (type(self) == type(obj)):\\n return NotImplemented\\n if not (self.size == obj.size):\\n raise ValueError(\\\"Matrices must be the same size for '+'\\\")\\n returnvalue = Matrix()\\n for i in range(self._height):\\n currentRow = list()\\n for j in range(self._width):\\n currentRow.append(self._value[i][j] + obj.value[i][j])\\n returnvalue.addRow(*currentRow)\\n return returnvalue\",\n \"def __iadd__(self, obj):\\n if not vedo.utils.is_sequence(obj):\\n obj = [obj]\\n for a in obj:\\n if a:\\n self.AddPart(a)\\n return self\",\n \"def __iadd__(self, other):\\n\\n if isinstance(other, float):\\n self.iadd_scalar(other)\\n else:\\n self.iadd(other)\",\n \"def __radd__(self, value):\\r\\n if isinstance(value, (int, dec.Decimal)):\\r\\n return self.__class__(value + self._real, self._imag)\\r\\n elif isinstance(value, self.__class__):\\r\\n return self.__class__(value._real + self._real, value._imag + self._imag)\\r\\n raise TypeError(\\r\\n 'unsupported operand type(s) for +: {!r} and {!r}'.format(\\r\\n value.__class__.__name__, self.__class__.__name__\\r\\n )\\r\\n )\",\n \"def __add__(self, other):\\n cls = self.__class__\\n return cls(self.x+other.x, self.y+other.y, self.z+other.z)\",\n \"def __add__(self, this):\\n return self.add(this)\",\n \"def add(self, a, b):\\n return a + b\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def add(self):\\n return self._do_calc(self.adder)\",\n \"def __add__(self, other):\\n if not (isNumeric(other) or isinstance(other, Expression)):\\n error_msg = (\\n f'Invalid expression during addition to {self}: [{other}]'\\n )\\n raise excep.biogemeError(error_msg)\\n return Plus(self, other)\",\n \"def __add__(self, other):\\n return self.getArea() + other.getArea()\",\n \"def smart_add(*args):\\n result = 0\\n for item in args:\\n result += item\\n\\n return result\",\n \"def __add__(self, other):\\n if isinstance(other, (int, type(Zero()))):\\n if other == 0:\\n return self\\n self._check_dyadic(other)\\n return Dyadic(self.args + other.args)\",\n \"def __add__(self, other: PointOrIterableOrScalar) -> PointType:\\n return self.__op(other, operator.add)\",\n \"def kkAdd(*args):\\n if (None in args):\\n return None\\n total = 0\\n for arg in args:\\n total += arg\\n return total\",\n \"def __radd__(self, other):\\n if not (isNumeric(other) or isinstance(other, Expression)):\\n error_msg = (\\n f'Invalid expression during addition to {self}: [{other}]'\\n )\\n raise excep.biogemeError(error_msg)\\n return Plus(other, self)\",\n \"def __add__(self, other):\\n return self.concatenate(other)\",\n \"def __add__(self, other):\\n return self.concatenate(other)\",\n \"def __add__(self, other):\\n if isinstance(other, complex):\\n return Power(self.power + other, self.power_unit, self.freq, self.freq_unit)\\n if self.power_unit != other.power_unit:\\n raise ArithmeticError(f\\\"The objects' ohm units {self.power_unit} and {other.power_unit} are not the same.\\\")\\n if self.freq != other.frequency:\\n raise ArithmeticError(f\\\"The objects' frequency {self.freq} and {other.frequency} are not the same.\\\")\\n if self.freq_unit != other.freq_unit:\\n raise ArithmeticError(f\\\"The objects' frequency units {self.freq_unit} and {other.freq_unit} \\\"\\n f\\\"are not the same.\\\")\\n power_sum = self.power + other.power\\n return Power(power_sum, self.power_unit, self.freq, self.freq_unit)\",\n \"def __add__( self, other ) :\\n\\n try :\\n other = float( other )\\n c_ls = self.copy( )\\n for l, c_l in enumerate( c_ls ) : c_ls.coefficients[l] += other\\n except :\\n self.checkSameSeriesType( other )\\n c_l1, c_l2 = self, other\\n if( len( self ) < len( other ) ) : c_l1, c_l2 = other, self\\n c_ls = c_l1.copy( )\\n for l, c_l in enumerate( c_l2 ) : c_ls.coefficients[l] += c_l\\n return( c_ls )\",\n \"def __radd__(self, other):\\n if other == 0:\\n return self\\n else:\\n return self.__add__(other)\",\n \"def __radd__(self, other):\\n if other == 0:\\n return self\\n else:\\n return self.__add__(other)\",\n \"def _sum(self):\\n s = 0\\n for element, value in self.items():\\n s += value\\n return s\",\n \"def __radd__(self, other):\\n if isinstance(other, int):\\n return self.__add__(other)\\n return NotImplemented\",\n \"def __add__(self, other):\\n\\n if isinstance(other, type(self)):\\n # always create new fields, since otherwise c = a - b changes a as well!\\n p = fields(self)\\n p.elec[:] = self.elec + other.elec\\n p.magn[:] = self.magn + other.magn\\n return p\\n else:\\n raise DataError(\\\"Type error: cannot add %s to %s\\\" % (type(other), type(self)))\",\n \"def __add__(self, obj):\\n return self ^ obj\",\n \"def add(self, value):\",\n \"def __add__(self, y):\\n addend = Counter()\\n for key in self:\\n if key in y:\\n addend[key] = self[key] + y[key]\\n else:\\n addend[key] = self[key]\\n for key in y:\\n if key in self:\\n continue\\n addend[key] = y[key]\\n return addend\",\n \"def __add__(self, y):\\n addend = Counter()\\n for key in self:\\n if key in y:\\n addend[key] = self[key] + y[key]\\n else:\\n addend[key] = self[key]\\n for key in y:\\n if key in self:\\n continue\\n addend[key] = y[key]\\n return addend\",\n \"def __radd__(self, other):\\n return asarray(add(numpy.asarray(other), self))\",\n \"def __add__(self, other: t.Any) -> InspectableSet[_C]:\\n return self._op_copy('__add__', other)\",\n \"def __add__(self, _v):\\n\\t\\tif len(self) == len(_v):\\n\\t\\t\\tans = copy.deepcopy(self)\\n\\t\\t\\tfor i in range(0, self.n):\\n\\t\\t\\t\\tans[i] += _v[i]\\n\\t\\t\\treturn ans\",\n \"def __add__(self, other) -> 'MultiVector':\\n\\n other, mv = self._checkOther(other)\\n if not mv:\\n if isinstance(other, np.ndarray):\\n obj = self.__array__()\\n return obj + other\\n newValue = self.value + other.value\\n\\n return self._newMV(newValue)\",\n \"def __add__(self, obj):\\n if isinstance(obj, Matrix):\\n if self.m != obj.m or self.n != obj.n:\\n raise exc.ComformabilityError(\\n \\\"matrices must have the same dimensions\\\")\\n if type(self) is not type(obj):\\n raise TypeError(\\\"matrices must be the same type\\\")\\n data = [[self[i, j] + obj[i, j]\\n for j in range(self.n)]\\n for i in range(self.m)]\\n elif Matrix.is_numeric(obj):\\n self._validate_scalar(obj)\\n data = [[self[i, j] + obj\\n for j in range(self.n)]\\n for i in range(self.m)]\\n else:\\n raise TypeError(\\n \\\"cannot add object of type \\\" + type(obj).__name__ +\\n \\\" to matrix\\\")\\n return self.__class__(self.m, self.n, data)\",\n \"def __iadd__(self, other):\\n self.append(other)\\n return self\",\n \"def __add__(self,other):\\n return Vector(self.x+other.x,self.y+other.y,self.z+other.z)\",\n \"def __add__(self, other):\\n if len(self) != len(other):\\n raise ValueError('As dimensões devem ser iguais')\\n\\n result = Vector(len(self)) # inicia um novo array do tamanho do próprio\\n for i in range(len(self)):\\n result[i] = self[i] + other[i]\\n return result\",\n \"def add(self, x):\\n if type(x) is int:\\n self.real += x\\n else:\\n self.real = self.real + x.real\\n self.imag = self.imag + x.imag\",\n \"def basic_add(mv1, mv2):\\n obj = expand(mv1.obj + mv2.obj)\\n return MV(obj)\",\n \"def add( a, b ):\\n return a + b\",\n \"def __add__(self, other):\\n if isinstance(other, Trit):\\n value = (other,)\\n else:\\n value = tuple(other)\\n return Trits(self.trits + value)\",\n \"def __iadd__(self, other):\\n #print \\\"adding \\\", other, \\\" to \\\", self\\n # need to do shallow copy, or otherwise smth like \\\"cm += cm\\\"\\n # would loop forever and exhaust memory eventually\\n othersets = copy.copy(other.__sets)\\n for set in othersets:\\n self.add(*set)#[0], set[1])\\n return self\",\n \"def sum(self):\\n return sum(self.items())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7702068","0.75945014","0.75945014","0.7573851","0.75017023","0.7357567","0.72784346","0.72784346","0.7203079","0.7149354","0.7149354","0.7116317","0.7116317","0.7116317","0.7116317","0.7116317","0.7116317","0.7116317","0.70699376","0.7068136","0.70541155","0.7032368","0.7031444","0.7028739","0.70065373","0.7004081","0.7004073","0.7002464","0.70023096","0.70006454","0.6988375","0.69779146","0.6962474","0.69487274","0.6937875","0.69221073","0.6871809","0.68681306","0.6866932","0.6864087","0.6861762","0.6859623","0.6840663","0.6809283","0.68046105","0.6799979","0.6793076","0.6791649","0.6783794","0.67834854","0.6777034","0.6769118","0.67681795","0.6768078","0.6766651","0.67614496","0.67563236","0.6721655","0.672145","0.67161673","0.6712805","0.6712632","0.6696866","0.6676656","0.6676656","0.6676656","0.66743726","0.66576153","0.66435826","0.6636419","0.6634274","0.6626048","0.66219914","0.6617335","0.6617335","0.6614757","0.6603998","0.6592594","0.6592594","0.6590566","0.6586178","0.65841687","0.65786976","0.65762204","0.65642446","0.65642446","0.6558596","0.655747","0.6547455","0.65433073","0.6525647","0.6523281","0.6511105","0.64965695","0.64940166","0.6489957","0.6484833","0.6483081","0.6467927","0.64585006"],"string":"[\n \"0.7702068\",\n \"0.75945014\",\n \"0.75945014\",\n \"0.7573851\",\n \"0.75017023\",\n \"0.7357567\",\n \"0.72784346\",\n \"0.72784346\",\n \"0.7203079\",\n \"0.7149354\",\n \"0.7149354\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.7116317\",\n \"0.70699376\",\n \"0.7068136\",\n \"0.70541155\",\n \"0.7032368\",\n \"0.7031444\",\n \"0.7028739\",\n \"0.70065373\",\n \"0.7004081\",\n \"0.7004073\",\n \"0.7002464\",\n \"0.70023096\",\n \"0.70006454\",\n \"0.6988375\",\n \"0.69779146\",\n \"0.6962474\",\n \"0.69487274\",\n \"0.6937875\",\n \"0.69221073\",\n \"0.6871809\",\n \"0.68681306\",\n \"0.6866932\",\n \"0.6864087\",\n \"0.6861762\",\n \"0.6859623\",\n \"0.6840663\",\n \"0.6809283\",\n \"0.68046105\",\n \"0.6799979\",\n \"0.6793076\",\n \"0.6791649\",\n \"0.6783794\",\n \"0.67834854\",\n \"0.6777034\",\n \"0.6769118\",\n \"0.67681795\",\n \"0.6768078\",\n \"0.6766651\",\n \"0.67614496\",\n \"0.67563236\",\n \"0.6721655\",\n \"0.672145\",\n \"0.67161673\",\n \"0.6712805\",\n \"0.6712632\",\n \"0.6696866\",\n \"0.6676656\",\n \"0.6676656\",\n \"0.6676656\",\n \"0.66743726\",\n \"0.66576153\",\n \"0.66435826\",\n \"0.6636419\",\n \"0.6634274\",\n \"0.6626048\",\n \"0.66219914\",\n \"0.6617335\",\n \"0.6617335\",\n \"0.6614757\",\n \"0.6603998\",\n \"0.6592594\",\n \"0.6592594\",\n \"0.6590566\",\n \"0.6586178\",\n \"0.65841687\",\n \"0.65786976\",\n \"0.65762204\",\n \"0.65642446\",\n \"0.65642446\",\n \"0.6558596\",\n \"0.655747\",\n \"0.6547455\",\n \"0.65433073\",\n \"0.6525647\",\n \"0.6523281\",\n \"0.6511105\",\n \"0.64965695\",\n \"0.64940166\",\n \"0.6489957\",\n \"0.6484833\",\n \"0.6483081\",\n \"0.6467927\",\n \"0.64585006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65717214"},"document_rank":{"kind":"string","value":"84"}}},{"rowIdx":17099,"cells":{"query":{"kind":"string","value":"Test a model on an example"},"document":{"kind":"string","value":"def infer(self, example, model):\n asp_input = model + '\\n\\n' + example + '\\n\\n' + inference_program_ec\n ctl = clingo.Control()\n ctl.add(\"base\", [], asp_input)\n ctl.ground([(\"base\", [])], context=self)\n ctl.solve(on_model=self.show_model)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_model():\n pass","def test_example(self):\n self.assertEqual(self.example.get_example(), True)","def testModel( self, classTest, classPred):","def test_model_found(arguments):\n ...","def testGetReigsteredModel(self):\n from soc.models.student import Student\n model = models_logic.getModel('soc.models.student.Student')\n self.assertEqual(model, Student)","def fixture_model_overview_example():\n test_example = ModelOverview(\n model_id=MODEL_ID,\n model_name=MODEL_NAME,\n model_description=MODEL_DESCRIPTION,\n model_version=MODEL_VERSION,\n problem_type=PROBLEM_TYPE,\n algorithm_type=ALGORITHM_TYPE,\n model_creator=MODEL_CREATOR,\n model_owner=MODEL_OWNER,\n model_artifact=MODEL_ARTIFACT,\n inference_environment=INFERENCE_ENVRIONMENT,\n )\n return test_example","def test_get_model(self) -> None:\n get_model()","def test_build_model(arguments):\n ...","def test_test_regression_model(self):\n model = RegressionTestModel()\n example = {'x_1': 3, 'x_2': 2}\n pred = list(model.predict([example]))[0]\n self.assertEqual(pred['score'], 20)","def test_instance(self):\n self.assertIsInstance(self.test1, BaseModel)","def test_model_initialization():\n MyModel(\"model\", SkillContext())","def __test_model(self, test, model, expected):\n prediction = model.predict(test)\n message = \"Prediction:\", *prediction, \"| Actual:\", expected\n self.__logger.info(message)","def test_simple_creation():\n # Get model file\n create.main(\"mlp\", \"10:12:8\", \"model_test.tar\")","def test_predictor():","def test_model_endpoint(request, client, fixture_name, detail_attr, comparison_attr):\n instance = request.getfixturevalue(fixture_name)\n model = instance.__class__\n resource_name = model.__name__.lower()\n\n # test list endpoint\n response = client.get(api_reverse(\"%s-list\" % resource_name))\n check_response(response)\n results = response.json()['results']\n assert results\n assert len(results) == model.objects.count()\n\n # test detail endpoint\n response = client.get(api_reverse(\"%s-detail\" % resource_name, args=[getattr(instance, detail_attr)]))\n check_response(response)\n results = response.json()\n assert results[comparison_attr] == getattr(instance, comparison_attr)","def model_switch_to_testing(self):\n pass","def test_10_test_model(self, example):\n res = example.calc_model()\n print(example.trips_ij)\n total_trips_target = example.persons_gi.sum()\n total_trips_actual = example.trips_ij.sum()\n np.testing.assert_almost_equal(total_trips_target, total_trips_actual)","def test_custom_models(model):\n atom = ATOMRegressor(X_reg, y_reg, random_state=1)\n atom.run(models=model, n_calls=2, n_initial_points=1)\n assert atom.rfr.fullname == \"RandomForestRegressor\"\n assert atom.rfr.estimator.get_params()[\"random_state\"] == 1","def setUp(self):\n self.example = Example()","def test_model_runs(self):\n\n for m in self.models:\n self.assertTrue(m is not None)\n self.assertTrue(isinstance(m, topic_model.TopicModel))","def test_model_info():\n with pytest.raises(InvalidDataError):\n ModelInfo('test description', {'f1': 0.9},\n None)","def test_example_runs(self):\n run_example(\n verbose=False,\n testapp=self.testapp,\n )","def test_test_model(self):\n\n dataset = ClassificationTestDataset()\n model = ClassificationTestModel(dataset)\n preds = list(model.predict(dataset.examples))\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\n self.assertEqual(np.argmax(preds[3]['preds']), 3)","def testGetModelsData(self):\n models = models_logic._getModelsData()\n self.assertTrue(models)","def test_pregenerated_model(sub_test, case):\n\n if case.startswith(\"sensi2\"):\n model_name = sub_test + \"_o2\"\n else:\n model_name = sub_test\n\n model_swig_folder = str(\n Path(__file__).parents[2]\n / \"build\"\n / \"tests\"\n / \"cpp\"\n / f\"external_{model_name}-prefix\"\n / \"src\"\n / f\"external_{model_name}-build\"\n / \"swig\"\n )\n\n test_model_module = amici.import_model_module(\n module_name=model_name, module_path=model_swig_folder\n )\n model = test_model_module.getModel()\n solver = model.getSolver()\n amici.readModelDataFromHDF5(\n options_file, model.get(), f\"/{sub_test}/{case}/options\"\n )\n amici.readSolverSettingsFromHDF5(\n options_file, solver.get(), f\"/{sub_test}/{case}/options\"\n )\n\n edata = None\n if \"data\" in expected_results[sub_test][case].keys():\n edata = amici.readSimulationExpData(\n str(expected_results_file), f\"/{sub_test}/{case}/data\", model.get()\n )\n rdata = amici.runAmiciSimulation(model, solver, edata)\n\n check_derivative_opts = dict()\n\n if model_name == \"model_nested_events\":\n check_derivative_opts[\"rtol\"] = 1e-2\n elif model_name == \"model_events\":\n check_derivative_opts[\"atol\"] = 1e-3\n\n if (\n edata\n and solver.getSensitivityMethod()\n and solver.getSensitivityOrder()\n and len(model.getParameterList())\n and not model_name.startswith(\"model_neuron\")\n and not case.endswith(\"byhandpreeq\")\n ):\n check_derivatives(model, solver, edata, **check_derivative_opts)\n\n verify_simulation_opts = dict()\n\n if model_name.startswith(\"model_neuron\"):\n verify_simulation_opts[\"atol\"] = 1e-5\n verify_simulation_opts[\"rtol\"] = 1e-2\n\n if model_name.startswith(\"model_robertson\") and case == \"sensiforwardSPBCG\":\n verify_simulation_opts[\"atol\"] = 1e-3\n verify_simulation_opts[\"rtol\"] = 1e-3\n\n verify_simulation_results(\n rdata, expected_results[sub_test][case][\"results\"], **verify_simulation_opts\n )\n\n if model_name == \"model_steadystate\" and case == \"sensiforwarderrorint\":\n edata = amici.amici.ExpData(model.get())\n\n # Test runAmiciSimulations: ensure running twice\n # with same ExpData yields same results\n if (\n edata\n and model_name != \"model_neuron_o2\"\n and not (model_name == \"model_robertson\" and case == \"sensiforwardSPBCG\")\n ):\n if isinstance(edata, amici.amici.ExpData):\n edatas = [edata, edata]\n else:\n edatas = [edata.get(), edata.get()]\n\n rdatas = amici.runAmiciSimulations(\n model, solver, edatas, num_threads=2, failfast=False\n )\n verify_simulation_results(\n rdatas[0],\n expected_results[sub_test][case][\"results\"],\n **verify_simulation_opts,\n )\n verify_simulation_results(\n rdatas[1],\n expected_results[sub_test][case][\"results\"],\n **verify_simulation_opts,\n )\n\n # test residuals mode\n if solver.getSensitivityMethod() == amici.SensitivityMethod.adjoint:\n with pytest.raises(RuntimeError):\n solver.setReturnDataReportingMode(amici.RDataReporting.residuals)\n else:\n solver.setReturnDataReportingMode(amici.RDataReporting.residuals)\n rdata = amici.runAmiciSimulation(model, solver, edata)\n verify_simulation_results(\n rdata,\n expected_results[sub_test][case][\"results\"],\n fields=[\"t\", \"res\", \"sres\", \"y\", \"sy\", \"sigmay\", \"ssigmay\"],\n **verify_simulation_opts,\n )\n with pytest.raises(RuntimeError):\n solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)\n\n chi2_ref = rdata.chi2\n\n # test likelihood mode\n solver.setReturnDataReportingMode(amici.RDataReporting.likelihood)\n rdata = amici.runAmiciSimulation(model, solver, edata)\n verify_simulation_results(\n rdata,\n expected_results[sub_test][case][\"results\"],\n fields=[\"t\", \"llh\", \"sllh\", \"s2llh\", \"FIM\"],\n **verify_simulation_opts,\n )\n\n # test sigma residuals\n\n if (\n model_name == \"model_jakstat_adjoint\"\n and solver.getSensitivityMethod() != amici.SensitivityMethod.adjoint\n ):\n model.setAddSigmaResiduals(True)\n solver.setReturnDataReportingMode(amici.RDataReporting.full)\n rdata = amici.runAmiciSimulation(model, solver, edata)\n # check whether activation changes chi2\n assert chi2_ref != rdata.chi2\n\n if (\n edata\n and solver.getSensitivityMethod()\n and solver.getSensitivityOrder()\n and len(model.getParameterList())\n ):\n check_derivatives(model, solver, edata, **check_derivative_opts)\n\n chi2_ref = rdata.chi2\n res_ref = rdata.res\n\n model.setMinimumSigmaResiduals(100)\n rdata = amici.runAmiciSimulation(model, solver, edata)\n # check whether changing the minimum changes res but not chi2\n assert np.isclose(chi2_ref, rdata.chi2)\n assert not np.allclose(res_ref, rdata.res)\n\n model.setMinimumSigmaResiduals(-10)\n rdata = amici.runAmiciSimulation(model, solver, edata)\n # check whether having a bad minimum results in nan chi2\n assert np.isnan(rdata.chi2)\n\n with pytest.raises(RuntimeError):\n model.getParameterByName(\"thisParameterDoesNotExist\")","def create_model(self):\n self.skipTest(\"Base module should not be tested.\")","def test_user_model():\n assert isinstance(user_model_instance, UserModel), \"user model not correctly instatiating\"\n # TODO add more tests here to confirm user_model_instance","def test_test_client_model(self):\n pass","def test_machine_learning():","def __call__(self, example):\n return self.test(example)","def test_training(self):\n warnings.filterwarnings('ignore')\n example_args = example_args_parser()\n example_args.unittest = True\n # prepare data\n example_args.stage = 'prepare'\n example_wrapper(example_args)\n # train goalDNN model\n example_args.stage = 'train'\n example_args.model = 'goalDNN'\n example_wrapper(example_args)\n # train cVAE model\n example_args.model = 'cVAE'\n example_wrapper(example_args)\n # train gcVAE model\n example_args.model = 'gcVAE'\n example_wrapper(example_args)\n # cVAE harmonization\n example_args.stage = 'predict'\n example_args.model = 'cVAE'\n example_wrapper(example_args)\n # gcVAE harmonization\n example_args.model = 'gcVAE'\n example_wrapper(example_args)\n # goalDNN prediction\n example_args.model = 'goalDNN'\n example_wrapper(example_args)\n # XGBoost\n example_args.stage = 'train'\n example_args.model = 'XGBoost'\n example_wrapper(example_args)\n # compare with reference results\n check_args = check_results_args_parser()\n check_args.unittest = True\n check_reference_results(check_args)","def test02(self):\n\t\tself.model = DomainModel('Test Domain Model',\n\t\t\tActor('Driver',\n\t\t\t\t\"\"\"Person who drives a car\"\"\",\n\t\t\t\tisA('Person')\n\t\t\t),\n\t\t\tActor('Passenger',\n\t\t\t\t\"\"\"Person who rides in a car\"\"\",\n\t\t\t\tisA('Person')\n\t\t\t),\n\t\t\tActor('Person',\n\t\t\t\t\"\"\"A human being, capable of driving and being driven\"\"\"\n\t\t\t),\n\t\t\tNoun('Car',\n\t\t\t\t\"\"\"A type of vehicle\"\"\",\n\t\t\t\thas('Driver','Passengers')\n\t\t\t)\n\t\t)","def run_tests():\n source1 = TextModel('prep')\n source1.add_file('source_model_1.txt')\n \n source2 = TextModel('athletes')\n source2.add_file('source_model_2.txt')\n\n new1 = TextModel('my_writing')\n new1.add_file('my_writing.txt')\n new1.classify(source1, source2)\n\n # Add code for three other new models below.","def test_valid_model(self):\n model_cls = ModelContainer(APP_LABEL, TestModel2._meta.db_table).model_cls\n self.assertTrue(model_cls.__class__.__name__ is models.Model.__class__.__name__)","def test_predict_from_examples():\n examples = []\n for i in range(len(DATA)):\n (value, attribute_map) = DATA[i]\n print 'tuple created : \\n1:' + str(value) + \"\\n2:\" + str(attribute_map)\n ex = VowpalExample(i, value)\n #Extracting the features from all of the namespaces in the map. \n for (featureNamespace, features) in attribute_map.items():\n #Each \"section\" is \n ex.add_section(featureNamespace, features)\n examples.append(ex)\n train = examples[:-2]\n test = examples[-2:]\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\n preds = vw.predict_from_examples(train, test)\n for (id, value) in preds:\n print 'prediction for %s is %s' % (id, value)","def test_training(self):\n\t\tpass","def test_model_info_basic():\n model = ModelInfo('test description', {'f1': 0.9},\n BaseLocation('protoc://something:8080/thingy'))\n assert 'test description' in model.items['description']\n assert model.items['metrics']['f1'] == 0.9\n assert model.items['location'].get_host() == 'something:8080'\n assert model.items['hash'] is not None","def test_generate_data_model():\n params = dict(name=\"test\", type_=str, is_required=True)\n\n data_model = DataModel(\"test\", [Attribute(**params)])\n\n assert generate_data_model(\"test\", {\"test\": \"str\"}) == data_model","def test(self, example):\n #just get input; don't care about class label\n x = self._transformEx(example)[0] \n Y = self._propagateInput(x)[0]\n \n return Y","def test_deep_learning_models():\n atom = ATOMClassifier(*mnist, n_rows=0.1, random_state=1)\n pytest.raises(PermissionError, atom.clean)\n atom.run(KerasClassifier(neural_network, epochs=1, batch_size=512, verbose=0))","def __init__(self,model,X_test, y_test):\n self.model = model\n self.X_test = X_test\n self.y_test = y_test","def test_example(self, example_dataset, expected_result):\n\n transformer = PreprocessFeatures()\n result = transformer.fit_transform(example_dataset)\n\n assert (result == expected_result).all()","def test_custom_model(self):\n\n try:\n pp = Lexpp(external_dict=pkg_resources.resource_filename(\"lexpp\", \"tests/test.dict\"))\n except Exception:\n self.fail(\"init was failed\")","def pywemo_model_fixture():\n return \"LightSwitch\"","def test_model_processor():\n global model_processor_called\n\n model_str = 'first 34 45 7 A 45 65 B true C \"dfdf\"'\n\n metamodel = metamodel_from_str(grammar)\n metamodel.register_model_processor(model_processor)\n\n metamodel.model_from_str(model_str)\n\n assert model_processor_called","def test_get(self):\n self.assertEqual(self.expected_described_model, self.mapped_model.get(\"described_model_type\"))","def test_model_returns_readable_representation(self):\n response = CreateArticle().create_article()\n self.assertIn(str(response), \"My awesome title\")","def test_Demo(self):\n self._run(self._example_scenarios, \"Demo\")","def test_KGE_methods(model_name):\n testing_function(model_name)","def fake_model():\n app.config['FAKE_MODEL'] = True","def test():\n source1 = TextModel('source1')\n source1.add_string('It is interesting that she is interested.')\n source2 = TextModel('source2')\n source2.add_string('I am very, very excited about this!')\n \n\n mystery = TextModel('mystery')\n mystery.add_string('Is he interested? No, but I am.')\n mystery.classify(source1, source2)","def test_books_model_name(self):\n data = self.data1\n self.assertEqual(str(data),\"The Ultimate Guide to using YouTube Live to Engage Your Audience\")","def test_example(decorated_example):\n import visual_coding_2p_analysis","def test_integration_test_add_model(\n test_input, properties, required, defaults\n):\n with patch_registry() as registry:\n swagger.add_model(test_input)\n\n assert test_input.__name__ in registry[\"models\"]\n assert \"description\" in registry[\"models\"][test_input.__name__]\n assert \"notes\" in registry[\"models\"][test_input.__name__]\n\n if \"resource_fields\" not in dir(test_input) and \"__init__\" not in dir(\n test_input\n ):\n # in py2, classes without __init__ or resource_fields defined\n # will cause issues.\n # note, no issue in PY3.\n pytest.fail(\n \"do not call without resource_fields or __init__ defined.\"\n )\n\n if \"resource_fields\" in dir(test_input):\n if hasattr(test_input, \"required\"):\n assert \"required\" in registry[\"models\"][test_input.__name__]\n elif \"__init__\" in dir(test_input):\n assert \"required\" in registry[\"models\"][test_input.__name__]\n\n assert \"properties\" in registry[\"models\"][test_input.__name__]","def test(ctx, input_file, model, output_file):\n # parse extra input args\n kwargs = {ctx.args[i][2:]: ctx.args[i+1].strip('\"') for i in range(0, len(ctx.args), 2)}\n if 'use_groups' in kwargs:\n if kwargs['use_groups']:\n no_groups = 0\n else:\n no_groups = 1\n else:\n no_groups = 1\n click.echo('Init model from: ' + model)\n model_class = MDCASClassifier.init(True, None, None)\n click.echo('Make prediction on: ' + input_file)\n pred_df = model_class.test(model_bundle_file = model, test_set_file=input_file, gt_set_file=None, input_format='joblib', verbose=True, prob=1, no_groups=no_groups)\n click.echo('Save predictions to: ' + output_file)\n model_class.export_test(output_file)\n click.echo('Saved')","def make_test(self, model_type: str, model_serializer, url_name: str):\n\n for author_id in [1, 2]:\n username = getattr(self, f'author_{author_id}').username\n\n instances = getattr(self, f'{model_type}_by_author_{author_id}')\n instances_data = model_serializer(instances, many=True).data\n\n response = self.client.get(reverse(url_name, kwargs={\n 'username': username\n }))\n data = u.get_json(response)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(data['count'], len(instances_data))","def test_articles_model(self):\n self.assertEqual(self.article.author.email, \"iroq@sims.andela\")\n self.assertEqual(self.article.__str__(), self.title)","def test_full_model(model, documents, request):\n topic_model = copy.deepcopy(request.getfixturevalue(model))\n if model == \"base_topic_model\":\n topic_model.save(\"model_dir\", serialization=\"pytorch\", save_ctfidf=True, save_embedding_model=\"sentence-transformers/all-MiniLM-L6-v2\")\n topic_model = BERTopic.load(\"model_dir\")\n topics = topic_model.topics_\n\n for topic in set(topics):\n words = topic_model.get_topic(topic)[:10]\n assert len(words) == 10\n\n for topic in topic_model.get_topic_freq().Topic:\n words = topic_model.get_topic(topic)[:10]\n assert len(words) == 10\n\n assert len(topic_model.get_topic_freq()) > 2\n assert len(topic_model.get_topics()) == len(topic_model.get_topic_freq())\n\n # Test extraction of document info\n document_info = topic_model.get_document_info(documents)\n assert len(document_info) == len(documents)\n\n # Test transform\n doc = \"This is a new document to predict.\"\n topics_test, probs_test = topic_model.transform([doc, doc])\n\n assert len(topics_test) == 2\n\n # Test topics over time\n timestamps = [i % 10 for i in range(len(documents))]\n topics_over_time = topic_model.topics_over_time(documents, timestamps)\n\n assert topics_over_time.Frequency.sum() == len(documents)\n assert len(topics_over_time.Topic.unique()) == len(set(topics))\n\n # Test hierarchical topics\n hier_topics = topic_model.hierarchical_topics(documents)\n\n assert len(hier_topics) > 0\n assert hier_topics.Parent_ID.astype(int).min() > max(topics)\n\n # Test creation of topic tree\n tree = topic_model.get_topic_tree(hier_topics, tight_layout=False)\n assert isinstance(tree, str)\n assert len(tree) > 10\n\n # Test find topic\n similar_topics, similarity = topic_model.find_topics(\"query\", top_n=2)\n assert len(similar_topics) == 2\n assert len(similarity) == 2\n assert max(similarity) <= 1\n\n # Test topic reduction\n nr_topics = len(set(topics))\n nr_topics = 2 if nr_topics < 2 else nr_topics - 1\n topic_model.reduce_topics(documents, nr_topics=nr_topics)\n\n assert len(topic_model.get_topic_freq()) == nr_topics\n assert len(topic_model.topics_) == len(topics)\n\n # Test update topics\n topic = topic_model.get_topic(1)[:10]\n vectorizer_model = topic_model.vectorizer_model\n topic_model.update_topics(documents, n_gram_range=(2, 2))\n\n updated_topic = topic_model.get_topic(1)[:10]\n\n topic_model.update_topics(documents, vectorizer_model=vectorizer_model)\n original_topic = topic_model.get_topic(1)[:10]\n\n assert topic != updated_topic\n if topic_model.representation_model is not None:\n assert topic != original_topic\n\n # Test updating topic labels\n topic_labels = topic_model.generate_topic_labels(nr_words=3, topic_prefix=False, word_length=10, separator=\", \")\n assert len(topic_labels) == len(set(topic_model.topics_))\n\n # Test setting topic labels\n topic_model.set_topic_labels(topic_labels)\n assert topic_model.custom_labels_ == topic_labels\n\n # Test merging topics\n freq = topic_model.get_topic_freq(0)\n topics_to_merge = [0, 1]\n topic_model.merge_topics(documents, topics_to_merge)\n assert freq < topic_model.get_topic_freq(0)\n\n # Test reduction of outliers\n if -1 in topics:\n new_topics = topic_model.reduce_outliers(documents, topics, threshold=0.0)\n nr_outliers_topic_model = sum([1 for topic in topic_model.topics_ if topic == -1])\n nr_outliers_new_topics = sum([1 for topic in new_topics if topic == -1])\n\n if topic_model._outliers == 1:\n assert nr_outliers_topic_model > nr_outliers_new_topics\n\n # # Save and load model\n # if topic_model.topic_embeddings_ is not None:\n # topic_model.save(\"model_dir\", serialization=\"pytorch\", save_ctfidf=True)\n # loaded_model = BERTopic.load(\"model_dir\")","def test_missing_model():\n\n with pytest.raises(KeyError):\n Instafilter(\"xxx\")","def test():\n source1 = TextModel('source1')\n source1.add_string('It is interesting that she is interested.')\n\n source2 = TextModel('source2')\n source2.add_string('I am very, very excited about this!')\n\n mystery = TextModel('mystery')\n mystery.add_string('Is he interested? No, but I am.')\n mystery.classify(source1, source2)","def test():\n source1 = TextModel('source1')\n source1.add_string('It is interesting that she is interested.')\n\n source2 = TextModel('source2')\n source2.add_string('I am very, very excited about this!')\n\n mystery = TextModel('mystery')\n mystery.add_string('Is he interested? No, but I am.')\n mystery.classify(source1, source2)","def test_models_regression(model):\n atom = ATOMRegressor(X_reg, y_reg, test_size=0.24, random_state=1)\n atom.run(\n models=model,\n metric=\"neg_mean_absolute_error\",\n n_calls=2,\n n_initial_points=1,\n bo_params={\"base_estimator\": \"gbrt\", \"cv\": 1},\n )\n assert not atom.errors\n assert hasattr(atom, model)","def test_dog_says(self):\n dog = models.Dog(name='Snoopy')\n self.assertEqual(dog.says(), 'woof')","def test_model(model, dataObj, index):\n\t(s,m,l), img = dataObj.__getitem__(index)\n\timg = img.float().unsqueeze(0)\n\t\n\tif next(model.parameters()).is_cuda:\n\t\toutput = model(img.cuda()) \n\telse:\n\t\toutput = model(img)\n\n\ts_pred,m_pred,l_pred = output[0].squeeze(0).cpu(), output[1].squeeze(0).cpu(), output[2].squeeze(0).cpu()\n\ts_pred = s_pred.detach().numpy()\n\tm_pred = m_pred.detach().numpy()\n\tl_pred = l_pred.detach().numpy()\n\n\timg = img.float().squeeze(0)\n\timg = img.permute(1,2,0)\n\n\tfor j in range(22):\n\t\tvisualize(img, s[j], m[j], l[j], s_pred[j], m_pred[j], l_pred[j])\n\t\tk = np.array(s[j])","def test_load_model():\n model = BERTopic(language=\"Dutch\", embedding_model=None, n_components=12)\n model.save(\"test\")\n loaded_model = BERTopic.load(\"test\")\n assert type(model) == type(loaded_model)\n assert model.language == loaded_model.language\n assert model.embedding_model == loaded_model.embedding_model\n assert model.top_n_words == loaded_model.top_n_words\n assert model.n_neighbors == loaded_model.n_neighbors\n assert model.n_components == loaded_model.n_components","def test_load_model():\n spectrum_binner, test_generator = get_test_binner_and_generator()\n\n model_file = TEST_RESOURCES_PATH / \"testmodel.hdf5\"\n model = load_model(model_file)\n assert model.spectrum_binner.__dict__ == spectrum_binner.__dict__, \"Expected different spectrum binner\"\n\n # Test model layer shapes\n assert model.model.layers[2].to_json() == model.base.to_json(), \\\n \"Expected based model to be identical to part of main model.\"\n\n # Test base model inference\n X, y = test_generator.__getitem__(0)\n embeddings = model.base.predict(X[0])\n assert isinstance(embeddings, np.ndarray), \"Expected numpy array\"\n assert embeddings.shape[0] == test_generator.settings[\"batch_size\"] == 32, \\\n \"Expected different batch size\"\n assert embeddings.shape[1] == model.base.output_shape[1] == 200, \\\n \"Expected different embedding size\"","def test():\r\n source1 = TextModel('source1')\r\n source1.add_string('It is interesting that she is interested.')\r\n\r\n source2 = TextModel('source2')\r\n source2.add_string('I am very, very excited about this!')\r\n\r\n mystery = TextModel('mystery')\r\n mystery.add_string('Is he interested? No, but I am.')\r\n mystery.classify(source1, source2)","def test_model_obj():\n # Get the ambient profile data\n profile = get_profile()\n\n # Initialize a Model object\n sbm = single_bubble_model.Model(profile)\n\n # Check the model attributes\n assert_approx_equal(sbm.p.rho_r, 1031.035855535142, significant=6)\n (T, S, P) = profile.get_values(1000., ['temperature', 'salinity',\n 'pressure'])\n (Tp, Sp, Pp) = sbm.profile.get_values(1000., ['temperature', 'salinity',\n 'pressure'])\n assert Tp == T\n assert Sp == S\n assert Pp == P","def test_models_multiclass(model):\n atom = ATOMClassifier(X_class2, y_class2, test_size=0.24, random_state=1)\n atom.run(\n models=model,\n metric=\"f1_micro\",\n n_calls=2,\n n_initial_points=1,\n bo_params={\"base_estimator\": \"rf\", \"cv\": 1},\n )\n assert not atom.errors\n assert hasattr(atom, model)","def test_same_models(self):\n\t\t\n\t\t# TODO: finish\n\t\tpass","def test_predict_from_example_stream():\n stream = ExampleStream('vw.stream.txt')\n examples = []\n for i in xrange(len(DATA)):\n (value, all_sections) = DATA[i]\n ex = VowpalExample(i, value)\n for (namespace, section) in all_sections.items():\n ex.add_section(namespace, section)\n stream.add_example(ex)\n train = examples[:-2]\n test = examples[-2:]\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\n preds = vw.predict_from_example_stream(stream)\n for (id, value) in preds:\n print 'prediction for %s is %s' % (id, value)","def test_coupledmodels_post(self):\n pass","def test_model_can_import():\n assert hasattr(model, \"SEIR_model_publish_w_risk\")\n assert hasattr(model, \"compute_R0\")","def test_get_model_list():\n with app.test_client() as c:\n response = c.get('/REST/api/v1.0/model_list') \n assert response.status_code == 201","def target(self, example):\n raise NotImplementedError()","def run_tests():\n source1 = TextModel('hilary_speaches')\n source1.add_file('hilary_source_text.txt')\n\n source2 = TextModel('bernie_speaches')\n source2.add_file('bernie_source_text.txt')\n\n new1 = TextModel('trump_speach')\n new1.add_file('trump_text.txt')\n new1.classify(source1, source2)\n\n new2 = TextModel('hilary_test')\n new2.add_file('hilary_test.txt')\n new2.classify(source1, source2)\n\n new3 = TextModel('bernie_test')\n new3.add_file('bernie_test.txt')\n new3.classify(source1, source2)\n\n new4 = TextModel('bill_clinton_test')\n new4.add_file('bill_clinton_source.txt')\n new4.classify(source1, source2)","def test_proof_model():\n m = build_proof_model()\n with m:\n trace = pm.sample(50)\n assert trace.report.ok","def test_model_info_Generator():\n model = ModelInfo('test description', {'f1': 0.9},\n BaseLocation('protoc://something'), TestGenerator())\n assert 'test description' in model.items['description']\n assert model.items['metrics']['f1'] == 0.9\n assert model.items['location'].get_host() == 'something'\n assert model.items['hash'] is 5","def test_train_house_price_model():\n with app.test_client()as c:\n response = c.get('/REST/api/v1.0/train')\n assert response.status_code == 201","def test_sample_one_id(self):\r\n self.assertEqual(self.test_sample.id, 1)","def test_workflow_api_model(self):\n self.assure_category_exists('test_admin_category', admin=True)\n self.load_test_spec('simple_form')\n self.load_test_spec('hello_world', category_id='test_admin_category')\n\n simple_form_workflow = self.create_workflow('simple_form')\n hello_world_workflow = self.create_workflow('hello_world')\n # Make sure both workflows use the same study\n self.assertEqual(hello_world_workflow.study.id, simple_form_workflow.study.id)\n study = hello_world_workflow.study\n # Make sure the study status is in_progress\n self.assertEqual(StudyStatus.in_progress, study.status)\n\n rv_simple_form_1 = self.app.get('/v1.0/workflow/%s' % simple_form_workflow.id,\n follow_redirects=True,\n content_type=\"application/json\",\n headers=self.logged_in_headers())\n self.assert_success(rv_simple_form_1)\n json_data_simple_1 = json.loads(rv_simple_form_1.get_data(as_text=True))\n self.assertFalse(json_data_simple_1['is_admin_workflow'])\n\n rv_hello_world_1 = self.app.get('/v1.0/workflow/%s' % hello_world_workflow.id,\n follow_redirects=True,\n content_type=\"application/json\",\n headers=self.logged_in_headers())\n self.assert_success(rv_hello_world_1)\n json_data_hello_1 = json.loads(rv_hello_world_1.get_data(as_text=True))\n self.assertTrue(json_data_hello_1['is_admin_workflow'])","def test_coupledmodels_get(self):\n pass","def test_invalid_model(self):\n self.assertRaises(ModelNotFoundError, lambda: ModelContainer('web', 'model').model_cls)","def test_model(base, fake_session):\n\n # Make a dummy model\n\n # these fields should be ignored and should not appear in the model\n ignored = (\"field1\", \"field2\", \"field3\")\n\n # these fields are in the model, but should not get dumped to json\n loadonly = (\"field6\", \"field7\")\n\n @add_schema\n class MyModel(base):\n fields = dict(ignore=ignored, load_only=loadonly)\n\n # load the model from dummy data\n values = range(10)\n keys = [\"field{}\".format(x) for x in values]\n data = dict(zip(keys, values))\n m = MyModel.load_from(data, fake_session)\n\n return m, ignored, loadonly, data, MyModel","def test_model_import(self, iris_astore):\n model = register_model(\n iris_astore, self.MODEL_NAME, self.PROJECT_NAME, force=True\n )\n\n assert self.MODEL_NAME == model.name","def setUp(self):\n super().setUp()\n described_model_kwargs = {\"name\": \"Name\", \"description\": \"Description\"}\n self.mapped_model = MappedModel[DescribedModel].parse_obj({\"described_model_type\": described_model_kwargs})\n self.expected_described_model = DescribedModel(**described_model_kwargs)","def test__extract_features(self):\n text_sample = \"I really really love this movie\"\n feature_sample = ['really','love','good']\n feature_score_type = \"presence\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':1,'love':1,'good':0})\n feature_score_type = \"term_frequency\"\n model_sample = Model(feature_sample,feature_score_type)\n result_features = model_sample.extract_features(text_sample)\n assert_equal(result_features,{'really':2,'love':1,'good':0})","def test_get_item(self):\n self.assertEqual(self.expected_described_model, self.mapped_model[\"described_model_type\"])","def test_get_talks_model(self):\r\n self.assertIsInstance(self.db.get_talks_model(\"SC2011\", \"T105\"), QtSql.QSqlQueryModel)","def test_multiple_base_models(engine):\n with pytest.raises(ValueError):\n bloop.model.BaseModel(engine)","def test_im_model(name, xtrain_short=None, ytrain_short=None, nodisplay=False, \n summary=False, do_test=False):\n print(\"Loading model...\")\n objs = {\"accuracy\": fret_accuracy()}\n model = keras.models.load_model(\"models/\"+name+\".hdf5\", custom_objects=objs)\n\n if summary:\n # if we are just loading and have not trained\n model.summary()\n\n # if (batchsize, guitarstringindex, probabilities) then categorical, else \n # (batchsize, stringpred) is regression-type\n shape = model.get_output_shape_at(-1)\n if len(shape) > 2:\n categorical = True\n else:\n categorical = False\n\n \"\"\"\n testing\n \"\"\"\n data = load_all_data(\"data/inference_model_train\", num_splits=0, \n display=(not nodisplay), do_test=do_test)\n xtest, _, _, ytest, _, _ = data\n\n print(\"Evaluating on test set w/ no transitions\")\n print(len(xtest), \"testing images\")\n results = model.evaluate(xtest, ytest, verbose=1)\n with open(\"stats/\"+name+\"/stats.txt\", \"a\") as f:\n f.write(\"\\nTest results (no transitions):\\n\")\n for i,metric in enumerate(model.metrics_names):\n print(\" \", metric+\":\", results[i])\n f.write(metric+\": \"+str(results[i])+\"\\n\")\n\n # free memory\n del data, xtest, ytest\n import gc; gc.collect()\n\n data = load_all_data(\"data/inference_model_train\", num_splits=0, \n display=(not nodisplay), do_test=do_test, no_transitions=False)\n xtest, _, _, ytest, _, _ = data\n\n print(\"Evaluating on test set w/ transitions\")\n print(len(xtest), \"testing images\")\n results = model.evaluate(xtest, ytest, verbose=1)\n with open(\"stats/\"+name+\"/stats.txt\", \"a\") as f:\n f.write(\"\\nTest results (with transitions):\\n\")\n for i,metric in enumerate(model.metrics_names):\n print(\" \", metric+\":\", results[i])\n f.write(metric+\": \"+str(results[i])+\"\\n\")\n\n scaleup = 2.0\n\n # on training set, if available\n if xtrain_short is not None:\n print(\"Generating video on train set predictions\")\n trainpreds = model.predict(xtrain_short, verbose=1)\n\n vid = [cv.resize(i, dsize=(0,0), fx=scaleup, fy=scaleup, \\\n interpolation=cv.INTER_LINEAR) for i in xtrain_short]\n\n annotate_vid(vid, trainpreds, ytrain_short, categorical)\n if not nodisplay:\n showvid(vid, name=\"train ims\", ms=300)\n writevid(vid, \"stats/\"+name+\"/results_visualization_trainset\")\n\n # on test set\n print(\"Generating video on test set predictions\")\n numframes = 1000\n testpreds = model.predict(xtest[:numframes], verbose=1)\n\n vid = [cv.resize(i, dsize=(0,0), fx=scaleup, fy=scaleup, \\\n interpolation=cv.INTER_LINEAR) for i in xtest[:numframes]]\n\n annotate_vid(vid, testpreds, ytest[:numframes], categorical)\n if not nodisplay:\n showvid(vid, name=\"test set\", ms=35)\n writevid(vid, \"stats/\"+name+\"/results_visualization_testset\")","def test_constructor(self):\n # Record the model types of all the models to be created\n all_model_types = model_type_to_display_name.keys()\n\n # Record the attribute / value pairs that are common to all models.\n common_attr_value_dict = {\"data\": self.fake_df,\n \"name_spec\": self.fake_names,\n \"design\": self.fake_design,\n \"ind_var_names\": self.fake_names[\"x\"],\n \"alt_id_col\": self.alt_id_col,\n \"obs_id_col\": self.obs_id_col,\n \"choice_col\": self.choice_col,\n \"specification\": self.fake_specification,\n \"alt_IDs\": self.fake_df[\"alt_id\"].values,\n \"choices\": self.fake_df[\"choice\"].values}\n\n # Create a shape name dictionary to relate the various models to the\n # names of their shape parameters.\n shape_name_dict = {\"MNL\": None,\n \"Asym\": self.fake_shape_names[:2],\n \"Cloglog\": None,\n \"Scobit\": self.fake_shape_names,\n \"Uneven\": self.fake_shape_names,\n \"Nested Logit\": None,\n \"Mixed Logit\": None}\n\n # Create a shape reference position dictionary to relate the various\n # models to their shape reference positions.\n shape_ref_dict = {}\n for key in shape_name_dict:\n shape_ref_dict[key] = (None if key != \"Asym\" else\n self.fake_shape_ref_pos)\n\n # Create an intercept_names and intercept_ref_position dictionary to\n # relate the various models to their respective kwargs.\n intercept_names_dict = {}\n intercept_ref_dict = {}\n for key in shape_name_dict:\n if key in [\"MNL\", \"Nested Logit\", \"Mixed Logit\"]:\n intercept_names_dict[key] = None\n intercept_ref_dict[key] = None\n else:\n intercept_names_dict[key] = self.fake_intercept_names\n intercept_ref_dict[key] = self.fake_intercept_ref_pos\n\n # Create a nest_names dictionary to relate the various models to their\n # nest_name attributes\n nest_name_dict = {}\n nest_spec_dict = {}\n for key in shape_name_dict:\n if key != \"Nested Logit\":\n nest_name_dict[key] = None\n nest_spec_dict[key] = None\n else:\n nest_name_dict[key] = list(self.fake_nest_spec.keys())\n nest_spec_dict[key] = self.fake_nest_spec\n\n # Create dictionaries for the mixing_id_col, mixing_vars, and\n # mixing_pos attributes\n mixing_id_col_dict = {}\n mixing_vars_dict = {}\n mixing_pos_dict = {}\n\n for key in shape_name_dict:\n if key != \"Mixed Logit\":\n mixing_id_col_dict[key] = None\n mixing_vars_dict[key] = None\n mixing_pos_dict[key] = None\n else:\n mixing_id_col_dict[key] = self.obs_id_col\n mixing_vars_dict[key] = self.fake_names[\"x\"]\n mixing_pos_dict[key] = [0]\n\n # Record the attribute / value pairs that vary across models\n varying_attr_value_dict = {\"model_type\": model_type_to_display_name,\n \"intercept_names\": intercept_names_dict,\n \"intercept_ref_position\":\n intercept_ref_dict,\n \"shape_names\": shape_name_dict,\n \"shape_ref_position\": shape_ref_dict,\n \"nest_names\": nest_name_dict,\n \"nest_spec\": nest_spec_dict,\n \"mixing_id_col\": mixing_id_col_dict,\n \"mixing_vars\": mixing_vars_dict,\n \"mixing_pos\": mixing_pos_dict}\n\n # Set up the keyword arguments that are needed for each of the model\n # types\n variable_kwargs = {}\n for model_name in all_model_types:\n variable_kwargs[model_name] = {}\n variable_kwargs[model_name][\"intercept_names\"] =\\\n intercept_names_dict[model_name]\n variable_kwargs[model_name][\"intercept_ref_pos\"] =\\\n intercept_ref_dict[model_name]\n variable_kwargs[model_name][\"shape_ref_pos\"] =\\\n shape_ref_dict[model_name]\n variable_kwargs[model_name][\"shape_names\"] =\\\n shape_name_dict[model_name]\n variable_kwargs[model_name][\"nest_spec\"] =\\\n nest_spec_dict[model_name]\n variable_kwargs[model_name][\"mixing_id_col\"] =\\\n mixing_id_col_dict[model_name]\n variable_kwargs[model_name][\"mixing_vars\"] =\\\n mixing_vars_dict[model_name]\n\n # Execute the test for each model type\n for model_name in all_model_types:\n # Update the model type in the list of constructor args\n self.constructor_args[-1] = model_name\n\n # Use this specific model's keyword arguments\n self.constructor_kwargs.update(variable_kwargs[model_name])\n\n # Construct the model object\n model_obj = pylogit.create_choice_model(*self.constructor_args,\n **self.constructor_kwargs)\n\n # Make sure that the constructor has all of the required attributes\n for attr in common_attr_value_dict:\n value = common_attr_value_dict[attr]\n if isinstance(value, pd.DataFrame):\n self.assertTrue(value.equals(model_obj.data))\n elif isinstance(value, np.ndarray):\n npt.assert_allclose(value,\n model_obj.__getattribute__(attr))\n else:\n self.assertEqual(value,\n model_obj.__getattribute__(attr))\n\n for attr in varying_attr_value_dict:\n value = varying_attr_value_dict[attr][model_name]\n\n self.assertEqual(value,\n model_obj.__getattribute__(attr))\n\n return None","def test_api_predictors_get(self):\n pass","def test_model_post(self):\n\n new_model = dummy_data()\n element_key_to_delete = random.choice(list(new_model.elements.keys()))\n new_model.elements[element_key_to_delete].deleted = True\n test_json = new_model.to_json()\n\n result = self.client().post(\n '/model',\n json=test_json)\n\n self.assertEqual(result.status_code, 201)\n\n result = self.client().get('/model')\n data = Model.from_json(result.data.decode())\n\n self.assertEqual(result.status_code, 200)\n\n self.assertEqual(data, new_model)","def test_is_pipeline(model):\n assert type(model) == Pipeline","def test_train_model_type_good():\n\tdf = pd.read_csv(\"test/sample_features.csv\")\n\n\ty_train = df['price']\n\tX_train = df.loc[:, df.columns != 'price']\n\n\tparams = {'n_estimators': 5, 'random_state': 2}\n\trf_test = train(X_train, y_train, params)\n\n\t# test model type\n\ttest_model_type = str(type(rf_test))\n\ttrue_model_type = \"<class 'sklearn.ensemble._forest.RandomForestRegressor'>\"\n\tassert test_model_type == true_model_type","def test_prepare_model_medium_objective(raw_model, expected_model, config):\n essential.configure_model(raw_model, config)\n raw_id = find_objective_function(raw_model)[0].id\n expected_id = find_objective_function(expected_model)[0].id\n assert raw_id == expected_id","def test_model(self, model_name, nncf, category=\"shapes\", path=\"\"):\n with tempfile.TemporaryDirectory() as project_path:\n # Train test\n config, datamodule, model, trainer = setup_model_train(\n model_name,\n dataset_path=path,\n project_path=project_path,\n nncf=nncf,\n category=category,\n fast_run=True,\n )\n results = trainer.test(model=model, datamodule=datamodule)[0]\n\n # Test model load\n model_load_test(config, datamodule, results)","def test_create_a_car_model(car_model):\n car_models = models.CarMake.objects.all()\n\n assert car_model\n assert car_model.name == \"Golf\"\n assert car_model.car_make.name == \"Volkswagen\"\n assert len(car_models) == 1","def test_no_model(self):\n\n with self.assertRaisesRegex(ValueError,\n 'Please provide a model for this generator'):\n self._gen.generate(\n example=self._example,\n model=None,\n dataset=self._dataset,\n config=self._config)","def test_prepare_sample_to_forward(self):\n sample = [\n {\"src\": \"ola mundo\", \"ref\": \"hi world\", \"mt\": \"hey world!\", \"score\": 0.8},\n {\"src\": \"ola mundo\", \"ref\": \"hi world\", \"mt\": \"hey world!\", \"score\": 0.8},\n ]\n\n model_input, target = self.estimator.prepare_sample(sample)\n model_output = self.estimator(**model_input)\n self.assertTrue(model_output[\"score\"].shape[0] == 2)\n self.assertTrue(model_output[\"score\"].shape[1] == 1)"],"string":"[\n \"def test_model():\\n pass\",\n \"def test_example(self):\\n self.assertEqual(self.example.get_example(), True)\",\n \"def testModel( self, classTest, classPred):\",\n \"def test_model_found(arguments):\\n ...\",\n \"def testGetReigsteredModel(self):\\n from soc.models.student import Student\\n model = models_logic.getModel('soc.models.student.Student')\\n self.assertEqual(model, Student)\",\n \"def fixture_model_overview_example():\\n test_example = ModelOverview(\\n model_id=MODEL_ID,\\n model_name=MODEL_NAME,\\n model_description=MODEL_DESCRIPTION,\\n model_version=MODEL_VERSION,\\n problem_type=PROBLEM_TYPE,\\n algorithm_type=ALGORITHM_TYPE,\\n model_creator=MODEL_CREATOR,\\n model_owner=MODEL_OWNER,\\n model_artifact=MODEL_ARTIFACT,\\n inference_environment=INFERENCE_ENVRIONMENT,\\n )\\n return test_example\",\n \"def test_get_model(self) -> None:\\n get_model()\",\n \"def test_build_model(arguments):\\n ...\",\n \"def test_test_regression_model(self):\\n model = RegressionTestModel()\\n example = {'x_1': 3, 'x_2': 2}\\n pred = list(model.predict([example]))[0]\\n self.assertEqual(pred['score'], 20)\",\n \"def test_instance(self):\\n self.assertIsInstance(self.test1, BaseModel)\",\n \"def test_model_initialization():\\n MyModel(\\\"model\\\", SkillContext())\",\n \"def __test_model(self, test, model, expected):\\n prediction = model.predict(test)\\n message = \\\"Prediction:\\\", *prediction, \\\"| Actual:\\\", expected\\n self.__logger.info(message)\",\n \"def test_simple_creation():\\n # Get model file\\n create.main(\\\"mlp\\\", \\\"10:12:8\\\", \\\"model_test.tar\\\")\",\n \"def test_predictor():\",\n \"def test_model_endpoint(request, client, fixture_name, detail_attr, comparison_attr):\\n instance = request.getfixturevalue(fixture_name)\\n model = instance.__class__\\n resource_name = model.__name__.lower()\\n\\n # test list endpoint\\n response = client.get(api_reverse(\\\"%s-list\\\" % resource_name))\\n check_response(response)\\n results = response.json()['results']\\n assert results\\n assert len(results) == model.objects.count()\\n\\n # test detail endpoint\\n response = client.get(api_reverse(\\\"%s-detail\\\" % resource_name, args=[getattr(instance, detail_attr)]))\\n check_response(response)\\n results = response.json()\\n assert results[comparison_attr] == getattr(instance, comparison_attr)\",\n \"def model_switch_to_testing(self):\\n pass\",\n \"def test_10_test_model(self, example):\\n res = example.calc_model()\\n print(example.trips_ij)\\n total_trips_target = example.persons_gi.sum()\\n total_trips_actual = example.trips_ij.sum()\\n np.testing.assert_almost_equal(total_trips_target, total_trips_actual)\",\n \"def test_custom_models(model):\\n atom = ATOMRegressor(X_reg, y_reg, random_state=1)\\n atom.run(models=model, n_calls=2, n_initial_points=1)\\n assert atom.rfr.fullname == \\\"RandomForestRegressor\\\"\\n assert atom.rfr.estimator.get_params()[\\\"random_state\\\"] == 1\",\n \"def setUp(self):\\n self.example = Example()\",\n \"def test_model_runs(self):\\n\\n for m in self.models:\\n self.assertTrue(m is not None)\\n self.assertTrue(isinstance(m, topic_model.TopicModel))\",\n \"def test_model_info():\\n with pytest.raises(InvalidDataError):\\n ModelInfo('test description', {'f1': 0.9},\\n None)\",\n \"def test_example_runs(self):\\n run_example(\\n verbose=False,\\n testapp=self.testapp,\\n )\",\n \"def test_test_model(self):\\n\\n dataset = ClassificationTestDataset()\\n model = ClassificationTestModel(dataset)\\n preds = list(model.predict(dataset.examples))\\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\\n self.assertEqual(np.argmax(preds[3]['preds']), 3)\",\n \"def testGetModelsData(self):\\n models = models_logic._getModelsData()\\n self.assertTrue(models)\",\n \"def test_pregenerated_model(sub_test, case):\\n\\n if case.startswith(\\\"sensi2\\\"):\\n model_name = sub_test + \\\"_o2\\\"\\n else:\\n model_name = sub_test\\n\\n model_swig_folder = str(\\n Path(__file__).parents[2]\\n / \\\"build\\\"\\n / \\\"tests\\\"\\n / \\\"cpp\\\"\\n / f\\\"external_{model_name}-prefix\\\"\\n / \\\"src\\\"\\n / f\\\"external_{model_name}-build\\\"\\n / \\\"swig\\\"\\n )\\n\\n test_model_module = amici.import_model_module(\\n module_name=model_name, module_path=model_swig_folder\\n )\\n model = test_model_module.getModel()\\n solver = model.getSolver()\\n amici.readModelDataFromHDF5(\\n options_file, model.get(), f\\\"/{sub_test}/{case}/options\\\"\\n )\\n amici.readSolverSettingsFromHDF5(\\n options_file, solver.get(), f\\\"/{sub_test}/{case}/options\\\"\\n )\\n\\n edata = None\\n if \\\"data\\\" in expected_results[sub_test][case].keys():\\n edata = amici.readSimulationExpData(\\n str(expected_results_file), f\\\"/{sub_test}/{case}/data\\\", model.get()\\n )\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n\\n check_derivative_opts = dict()\\n\\n if model_name == \\\"model_nested_events\\\":\\n check_derivative_opts[\\\"rtol\\\"] = 1e-2\\n elif model_name == \\\"model_events\\\":\\n check_derivative_opts[\\\"atol\\\"] = 1e-3\\n\\n if (\\n edata\\n and solver.getSensitivityMethod()\\n and solver.getSensitivityOrder()\\n and len(model.getParameterList())\\n and not model_name.startswith(\\\"model_neuron\\\")\\n and not case.endswith(\\\"byhandpreeq\\\")\\n ):\\n check_derivatives(model, solver, edata, **check_derivative_opts)\\n\\n verify_simulation_opts = dict()\\n\\n if model_name.startswith(\\\"model_neuron\\\"):\\n verify_simulation_opts[\\\"atol\\\"] = 1e-5\\n verify_simulation_opts[\\\"rtol\\\"] = 1e-2\\n\\n if model_name.startswith(\\\"model_robertson\\\") and case == \\\"sensiforwardSPBCG\\\":\\n verify_simulation_opts[\\\"atol\\\"] = 1e-3\\n verify_simulation_opts[\\\"rtol\\\"] = 1e-3\\n\\n verify_simulation_results(\\n rdata, expected_results[sub_test][case][\\\"results\\\"], **verify_simulation_opts\\n )\\n\\n if model_name == \\\"model_steadystate\\\" and case == \\\"sensiforwarderrorint\\\":\\n edata = amici.amici.ExpData(model.get())\\n\\n # Test runAmiciSimulations: ensure running twice\\n # with same ExpData yields same results\\n if (\\n edata\\n and model_name != \\\"model_neuron_o2\\\"\\n and not (model_name == \\\"model_robertson\\\" and case == \\\"sensiforwardSPBCG\\\")\\n ):\\n if isinstance(edata, amici.amici.ExpData):\\n edatas = [edata, edata]\\n else:\\n edatas = [edata.get(), edata.get()]\\n\\n rdatas = amici.runAmiciSimulations(\\n model, solver, edatas, num_threads=2, failfast=False\\n )\\n verify_simulation_results(\\n rdatas[0],\\n expected_results[sub_test][case][\\\"results\\\"],\\n **verify_simulation_opts,\\n )\\n verify_simulation_results(\\n rdatas[1],\\n expected_results[sub_test][case][\\\"results\\\"],\\n **verify_simulation_opts,\\n )\\n\\n # test residuals mode\\n if solver.getSensitivityMethod() == amici.SensitivityMethod.adjoint:\\n with pytest.raises(RuntimeError):\\n solver.setReturnDataReportingMode(amici.RDataReporting.residuals)\\n else:\\n solver.setReturnDataReportingMode(amici.RDataReporting.residuals)\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n verify_simulation_results(\\n rdata,\\n expected_results[sub_test][case][\\\"results\\\"],\\n fields=[\\\"t\\\", \\\"res\\\", \\\"sres\\\", \\\"y\\\", \\\"sy\\\", \\\"sigmay\\\", \\\"ssigmay\\\"],\\n **verify_simulation_opts,\\n )\\n with pytest.raises(RuntimeError):\\n solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)\\n\\n chi2_ref = rdata.chi2\\n\\n # test likelihood mode\\n solver.setReturnDataReportingMode(amici.RDataReporting.likelihood)\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n verify_simulation_results(\\n rdata,\\n expected_results[sub_test][case][\\\"results\\\"],\\n fields=[\\\"t\\\", \\\"llh\\\", \\\"sllh\\\", \\\"s2llh\\\", \\\"FIM\\\"],\\n **verify_simulation_opts,\\n )\\n\\n # test sigma residuals\\n\\n if (\\n model_name == \\\"model_jakstat_adjoint\\\"\\n and solver.getSensitivityMethod() != amici.SensitivityMethod.adjoint\\n ):\\n model.setAddSigmaResiduals(True)\\n solver.setReturnDataReportingMode(amici.RDataReporting.full)\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n # check whether activation changes chi2\\n assert chi2_ref != rdata.chi2\\n\\n if (\\n edata\\n and solver.getSensitivityMethod()\\n and solver.getSensitivityOrder()\\n and len(model.getParameterList())\\n ):\\n check_derivatives(model, solver, edata, **check_derivative_opts)\\n\\n chi2_ref = rdata.chi2\\n res_ref = rdata.res\\n\\n model.setMinimumSigmaResiduals(100)\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n # check whether changing the minimum changes res but not chi2\\n assert np.isclose(chi2_ref, rdata.chi2)\\n assert not np.allclose(res_ref, rdata.res)\\n\\n model.setMinimumSigmaResiduals(-10)\\n rdata = amici.runAmiciSimulation(model, solver, edata)\\n # check whether having a bad minimum results in nan chi2\\n assert np.isnan(rdata.chi2)\\n\\n with pytest.raises(RuntimeError):\\n model.getParameterByName(\\\"thisParameterDoesNotExist\\\")\",\n \"def create_model(self):\\n self.skipTest(\\\"Base module should not be tested.\\\")\",\n \"def test_user_model():\\n assert isinstance(user_model_instance, UserModel), \\\"user model not correctly instatiating\\\"\\n # TODO add more tests here to confirm user_model_instance\",\n \"def test_test_client_model(self):\\n pass\",\n \"def test_machine_learning():\",\n \"def __call__(self, example):\\n return self.test(example)\",\n \"def test_training(self):\\n warnings.filterwarnings('ignore')\\n example_args = example_args_parser()\\n example_args.unittest = True\\n # prepare data\\n example_args.stage = 'prepare'\\n example_wrapper(example_args)\\n # train goalDNN model\\n example_args.stage = 'train'\\n example_args.model = 'goalDNN'\\n example_wrapper(example_args)\\n # train cVAE model\\n example_args.model = 'cVAE'\\n example_wrapper(example_args)\\n # train gcVAE model\\n example_args.model = 'gcVAE'\\n example_wrapper(example_args)\\n # cVAE harmonization\\n example_args.stage = 'predict'\\n example_args.model = 'cVAE'\\n example_wrapper(example_args)\\n # gcVAE harmonization\\n example_args.model = 'gcVAE'\\n example_wrapper(example_args)\\n # goalDNN prediction\\n example_args.model = 'goalDNN'\\n example_wrapper(example_args)\\n # XGBoost\\n example_args.stage = 'train'\\n example_args.model = 'XGBoost'\\n example_wrapper(example_args)\\n # compare with reference results\\n check_args = check_results_args_parser()\\n check_args.unittest = True\\n check_reference_results(check_args)\",\n \"def test02(self):\\n\\t\\tself.model = DomainModel('Test Domain Model',\\n\\t\\t\\tActor('Driver',\\n\\t\\t\\t\\t\\\"\\\"\\\"Person who drives a car\\\"\\\"\\\",\\n\\t\\t\\t\\tisA('Person')\\n\\t\\t\\t),\\n\\t\\t\\tActor('Passenger',\\n\\t\\t\\t\\t\\\"\\\"\\\"Person who rides in a car\\\"\\\"\\\",\\n\\t\\t\\t\\tisA('Person')\\n\\t\\t\\t),\\n\\t\\t\\tActor('Person',\\n\\t\\t\\t\\t\\\"\\\"\\\"A human being, capable of driving and being driven\\\"\\\"\\\"\\n\\t\\t\\t),\\n\\t\\t\\tNoun('Car',\\n\\t\\t\\t\\t\\\"\\\"\\\"A type of vehicle\\\"\\\"\\\",\\n\\t\\t\\t\\thas('Driver','Passengers')\\n\\t\\t\\t)\\n\\t\\t)\",\n \"def run_tests():\\n source1 = TextModel('prep')\\n source1.add_file('source_model_1.txt')\\n \\n source2 = TextModel('athletes')\\n source2.add_file('source_model_2.txt')\\n\\n new1 = TextModel('my_writing')\\n new1.add_file('my_writing.txt')\\n new1.classify(source1, source2)\\n\\n # Add code for three other new models below.\",\n \"def test_valid_model(self):\\n model_cls = ModelContainer(APP_LABEL, TestModel2._meta.db_table).model_cls\\n self.assertTrue(model_cls.__class__.__name__ is models.Model.__class__.__name__)\",\n \"def test_predict_from_examples():\\n examples = []\\n for i in range(len(DATA)):\\n (value, attribute_map) = DATA[i]\\n print 'tuple created : \\\\n1:' + str(value) + \\\"\\\\n2:\\\" + str(attribute_map)\\n ex = VowpalExample(i, value)\\n #Extracting the features from all of the namespaces in the map. \\n for (featureNamespace, features) in attribute_map.items():\\n #Each \\\"section\\\" is \\n ex.add_section(featureNamespace, features)\\n examples.append(ex)\\n train = examples[:-2]\\n test = examples[-2:]\\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\\n preds = vw.predict_from_examples(train, test)\\n for (id, value) in preds:\\n print 'prediction for %s is %s' % (id, value)\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def test_model_info_basic():\\n model = ModelInfo('test description', {'f1': 0.9},\\n BaseLocation('protoc://something:8080/thingy'))\\n assert 'test description' in model.items['description']\\n assert model.items['metrics']['f1'] == 0.9\\n assert model.items['location'].get_host() == 'something:8080'\\n assert model.items['hash'] is not None\",\n \"def test_generate_data_model():\\n params = dict(name=\\\"test\\\", type_=str, is_required=True)\\n\\n data_model = DataModel(\\\"test\\\", [Attribute(**params)])\\n\\n assert generate_data_model(\\\"test\\\", {\\\"test\\\": \\\"str\\\"}) == data_model\",\n \"def test(self, example):\\n #just get input; don't care about class label\\n x = self._transformEx(example)[0] \\n Y = self._propagateInput(x)[0]\\n \\n return Y\",\n \"def test_deep_learning_models():\\n atom = ATOMClassifier(*mnist, n_rows=0.1, random_state=1)\\n pytest.raises(PermissionError, atom.clean)\\n atom.run(KerasClassifier(neural_network, epochs=1, batch_size=512, verbose=0))\",\n \"def __init__(self,model,X_test, y_test):\\n self.model = model\\n self.X_test = X_test\\n self.y_test = y_test\",\n \"def test_example(self, example_dataset, expected_result):\\n\\n transformer = PreprocessFeatures()\\n result = transformer.fit_transform(example_dataset)\\n\\n assert (result == expected_result).all()\",\n \"def test_custom_model(self):\\n\\n try:\\n pp = Lexpp(external_dict=pkg_resources.resource_filename(\\\"lexpp\\\", \\\"tests/test.dict\\\"))\\n except Exception:\\n self.fail(\\\"init was failed\\\")\",\n \"def pywemo_model_fixture():\\n return \\\"LightSwitch\\\"\",\n \"def test_model_processor():\\n global model_processor_called\\n\\n model_str = 'first 34 45 7 A 45 65 B true C \\\"dfdf\\\"'\\n\\n metamodel = metamodel_from_str(grammar)\\n metamodel.register_model_processor(model_processor)\\n\\n metamodel.model_from_str(model_str)\\n\\n assert model_processor_called\",\n \"def test_get(self):\\n self.assertEqual(self.expected_described_model, self.mapped_model.get(\\\"described_model_type\\\"))\",\n \"def test_model_returns_readable_representation(self):\\n response = CreateArticle().create_article()\\n self.assertIn(str(response), \\\"My awesome title\\\")\",\n \"def test_Demo(self):\\n self._run(self._example_scenarios, \\\"Demo\\\")\",\n \"def test_KGE_methods(model_name):\\n testing_function(model_name)\",\n \"def fake_model():\\n app.config['FAKE_MODEL'] = True\",\n \"def test():\\n source1 = TextModel('source1')\\n source1.add_string('It is interesting that she is interested.')\\n source2 = TextModel('source2')\\n source2.add_string('I am very, very excited about this!')\\n \\n\\n mystery = TextModel('mystery')\\n mystery.add_string('Is he interested? No, but I am.')\\n mystery.classify(source1, source2)\",\n \"def test_books_model_name(self):\\n data = self.data1\\n self.assertEqual(str(data),\\\"The Ultimate Guide to using YouTube Live to Engage Your Audience\\\")\",\n \"def test_example(decorated_example):\\n import visual_coding_2p_analysis\",\n \"def test_integration_test_add_model(\\n test_input, properties, required, defaults\\n):\\n with patch_registry() as registry:\\n swagger.add_model(test_input)\\n\\n assert test_input.__name__ in registry[\\\"models\\\"]\\n assert \\\"description\\\" in registry[\\\"models\\\"][test_input.__name__]\\n assert \\\"notes\\\" in registry[\\\"models\\\"][test_input.__name__]\\n\\n if \\\"resource_fields\\\" not in dir(test_input) and \\\"__init__\\\" not in dir(\\n test_input\\n ):\\n # in py2, classes without __init__ or resource_fields defined\\n # will cause issues.\\n # note, no issue in PY3.\\n pytest.fail(\\n \\\"do not call without resource_fields or __init__ defined.\\\"\\n )\\n\\n if \\\"resource_fields\\\" in dir(test_input):\\n if hasattr(test_input, \\\"required\\\"):\\n assert \\\"required\\\" in registry[\\\"models\\\"][test_input.__name__]\\n elif \\\"__init__\\\" in dir(test_input):\\n assert \\\"required\\\" in registry[\\\"models\\\"][test_input.__name__]\\n\\n assert \\\"properties\\\" in registry[\\\"models\\\"][test_input.__name__]\",\n \"def test(ctx, input_file, model, output_file):\\n # parse extra input args\\n kwargs = {ctx.args[i][2:]: ctx.args[i+1].strip('\\\"') for i in range(0, len(ctx.args), 2)}\\n if 'use_groups' in kwargs:\\n if kwargs['use_groups']:\\n no_groups = 0\\n else:\\n no_groups = 1\\n else:\\n no_groups = 1\\n click.echo('Init model from: ' + model)\\n model_class = MDCASClassifier.init(True, None, None)\\n click.echo('Make prediction on: ' + input_file)\\n pred_df = model_class.test(model_bundle_file = model, test_set_file=input_file, gt_set_file=None, input_format='joblib', verbose=True, prob=1, no_groups=no_groups)\\n click.echo('Save predictions to: ' + output_file)\\n model_class.export_test(output_file)\\n click.echo('Saved')\",\n \"def make_test(self, model_type: str, model_serializer, url_name: str):\\n\\n for author_id in [1, 2]:\\n username = getattr(self, f'author_{author_id}').username\\n\\n instances = getattr(self, f'{model_type}_by_author_{author_id}')\\n instances_data = model_serializer(instances, many=True).data\\n\\n response = self.client.get(reverse(url_name, kwargs={\\n 'username': username\\n }))\\n data = u.get_json(response)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(data['count'], len(instances_data))\",\n \"def test_articles_model(self):\\n self.assertEqual(self.article.author.email, \\\"iroq@sims.andela\\\")\\n self.assertEqual(self.article.__str__(), self.title)\",\n \"def test_full_model(model, documents, request):\\n topic_model = copy.deepcopy(request.getfixturevalue(model))\\n if model == \\\"base_topic_model\\\":\\n topic_model.save(\\\"model_dir\\\", serialization=\\\"pytorch\\\", save_ctfidf=True, save_embedding_model=\\\"sentence-transformers/all-MiniLM-L6-v2\\\")\\n topic_model = BERTopic.load(\\\"model_dir\\\")\\n topics = topic_model.topics_\\n\\n for topic in set(topics):\\n words = topic_model.get_topic(topic)[:10]\\n assert len(words) == 10\\n\\n for topic in topic_model.get_topic_freq().Topic:\\n words = topic_model.get_topic(topic)[:10]\\n assert len(words) == 10\\n\\n assert len(topic_model.get_topic_freq()) > 2\\n assert len(topic_model.get_topics()) == len(topic_model.get_topic_freq())\\n\\n # Test extraction of document info\\n document_info = topic_model.get_document_info(documents)\\n assert len(document_info) == len(documents)\\n\\n # Test transform\\n doc = \\\"This is a new document to predict.\\\"\\n topics_test, probs_test = topic_model.transform([doc, doc])\\n\\n assert len(topics_test) == 2\\n\\n # Test topics over time\\n timestamps = [i % 10 for i in range(len(documents))]\\n topics_over_time = topic_model.topics_over_time(documents, timestamps)\\n\\n assert topics_over_time.Frequency.sum() == len(documents)\\n assert len(topics_over_time.Topic.unique()) == len(set(topics))\\n\\n # Test hierarchical topics\\n hier_topics = topic_model.hierarchical_topics(documents)\\n\\n assert len(hier_topics) > 0\\n assert hier_topics.Parent_ID.astype(int).min() > max(topics)\\n\\n # Test creation of topic tree\\n tree = topic_model.get_topic_tree(hier_topics, tight_layout=False)\\n assert isinstance(tree, str)\\n assert len(tree) > 10\\n\\n # Test find topic\\n similar_topics, similarity = topic_model.find_topics(\\\"query\\\", top_n=2)\\n assert len(similar_topics) == 2\\n assert len(similarity) == 2\\n assert max(similarity) <= 1\\n\\n # Test topic reduction\\n nr_topics = len(set(topics))\\n nr_topics = 2 if nr_topics < 2 else nr_topics - 1\\n topic_model.reduce_topics(documents, nr_topics=nr_topics)\\n\\n assert len(topic_model.get_topic_freq()) == nr_topics\\n assert len(topic_model.topics_) == len(topics)\\n\\n # Test update topics\\n topic = topic_model.get_topic(1)[:10]\\n vectorizer_model = topic_model.vectorizer_model\\n topic_model.update_topics(documents, n_gram_range=(2, 2))\\n\\n updated_topic = topic_model.get_topic(1)[:10]\\n\\n topic_model.update_topics(documents, vectorizer_model=vectorizer_model)\\n original_topic = topic_model.get_topic(1)[:10]\\n\\n assert topic != updated_topic\\n if topic_model.representation_model is not None:\\n assert topic != original_topic\\n\\n # Test updating topic labels\\n topic_labels = topic_model.generate_topic_labels(nr_words=3, topic_prefix=False, word_length=10, separator=\\\", \\\")\\n assert len(topic_labels) == len(set(topic_model.topics_))\\n\\n # Test setting topic labels\\n topic_model.set_topic_labels(topic_labels)\\n assert topic_model.custom_labels_ == topic_labels\\n\\n # Test merging topics\\n freq = topic_model.get_topic_freq(0)\\n topics_to_merge = [0, 1]\\n topic_model.merge_topics(documents, topics_to_merge)\\n assert freq < topic_model.get_topic_freq(0)\\n\\n # Test reduction of outliers\\n if -1 in topics:\\n new_topics = topic_model.reduce_outliers(documents, topics, threshold=0.0)\\n nr_outliers_topic_model = sum([1 for topic in topic_model.topics_ if topic == -1])\\n nr_outliers_new_topics = sum([1 for topic in new_topics if topic == -1])\\n\\n if topic_model._outliers == 1:\\n assert nr_outliers_topic_model > nr_outliers_new_topics\\n\\n # # Save and load model\\n # if topic_model.topic_embeddings_ is not None:\\n # topic_model.save(\\\"model_dir\\\", serialization=\\\"pytorch\\\", save_ctfidf=True)\\n # loaded_model = BERTopic.load(\\\"model_dir\\\")\",\n \"def test_missing_model():\\n\\n with pytest.raises(KeyError):\\n Instafilter(\\\"xxx\\\")\",\n \"def test():\\n source1 = TextModel('source1')\\n source1.add_string('It is interesting that she is interested.')\\n\\n source2 = TextModel('source2')\\n source2.add_string('I am very, very excited about this!')\\n\\n mystery = TextModel('mystery')\\n mystery.add_string('Is he interested? No, but I am.')\\n mystery.classify(source1, source2)\",\n \"def test():\\n source1 = TextModel('source1')\\n source1.add_string('It is interesting that she is interested.')\\n\\n source2 = TextModel('source2')\\n source2.add_string('I am very, very excited about this!')\\n\\n mystery = TextModel('mystery')\\n mystery.add_string('Is he interested? No, but I am.')\\n mystery.classify(source1, source2)\",\n \"def test_models_regression(model):\\n atom = ATOMRegressor(X_reg, y_reg, test_size=0.24, random_state=1)\\n atom.run(\\n models=model,\\n metric=\\\"neg_mean_absolute_error\\\",\\n n_calls=2,\\n n_initial_points=1,\\n bo_params={\\\"base_estimator\\\": \\\"gbrt\\\", \\\"cv\\\": 1},\\n )\\n assert not atom.errors\\n assert hasattr(atom, model)\",\n \"def test_dog_says(self):\\n dog = models.Dog(name='Snoopy')\\n self.assertEqual(dog.says(), 'woof')\",\n \"def test_model(model, dataObj, index):\\n\\t(s,m,l), img = dataObj.__getitem__(index)\\n\\timg = img.float().unsqueeze(0)\\n\\t\\n\\tif next(model.parameters()).is_cuda:\\n\\t\\toutput = model(img.cuda()) \\n\\telse:\\n\\t\\toutput = model(img)\\n\\n\\ts_pred,m_pred,l_pred = output[0].squeeze(0).cpu(), output[1].squeeze(0).cpu(), output[2].squeeze(0).cpu()\\n\\ts_pred = s_pred.detach().numpy()\\n\\tm_pred = m_pred.detach().numpy()\\n\\tl_pred = l_pred.detach().numpy()\\n\\n\\timg = img.float().squeeze(0)\\n\\timg = img.permute(1,2,0)\\n\\n\\tfor j in range(22):\\n\\t\\tvisualize(img, s[j], m[j], l[j], s_pred[j], m_pred[j], l_pred[j])\\n\\t\\tk = np.array(s[j])\",\n \"def test_load_model():\\n model = BERTopic(language=\\\"Dutch\\\", embedding_model=None, n_components=12)\\n model.save(\\\"test\\\")\\n loaded_model = BERTopic.load(\\\"test\\\")\\n assert type(model) == type(loaded_model)\\n assert model.language == loaded_model.language\\n assert model.embedding_model == loaded_model.embedding_model\\n assert model.top_n_words == loaded_model.top_n_words\\n assert model.n_neighbors == loaded_model.n_neighbors\\n assert model.n_components == loaded_model.n_components\",\n \"def test_load_model():\\n spectrum_binner, test_generator = get_test_binner_and_generator()\\n\\n model_file = TEST_RESOURCES_PATH / \\\"testmodel.hdf5\\\"\\n model = load_model(model_file)\\n assert model.spectrum_binner.__dict__ == spectrum_binner.__dict__, \\\"Expected different spectrum binner\\\"\\n\\n # Test model layer shapes\\n assert model.model.layers[2].to_json() == model.base.to_json(), \\\\\\n \\\"Expected based model to be identical to part of main model.\\\"\\n\\n # Test base model inference\\n X, y = test_generator.__getitem__(0)\\n embeddings = model.base.predict(X[0])\\n assert isinstance(embeddings, np.ndarray), \\\"Expected numpy array\\\"\\n assert embeddings.shape[0] == test_generator.settings[\\\"batch_size\\\"] == 32, \\\\\\n \\\"Expected different batch size\\\"\\n assert embeddings.shape[1] == model.base.output_shape[1] == 200, \\\\\\n \\\"Expected different embedding size\\\"\",\n \"def test():\\r\\n source1 = TextModel('source1')\\r\\n source1.add_string('It is interesting that she is interested.')\\r\\n\\r\\n source2 = TextModel('source2')\\r\\n source2.add_string('I am very, very excited about this!')\\r\\n\\r\\n mystery = TextModel('mystery')\\r\\n mystery.add_string('Is he interested? No, but I am.')\\r\\n mystery.classify(source1, source2)\",\n \"def test_model_obj():\\n # Get the ambient profile data\\n profile = get_profile()\\n\\n # Initialize a Model object\\n sbm = single_bubble_model.Model(profile)\\n\\n # Check the model attributes\\n assert_approx_equal(sbm.p.rho_r, 1031.035855535142, significant=6)\\n (T, S, P) = profile.get_values(1000., ['temperature', 'salinity',\\n 'pressure'])\\n (Tp, Sp, Pp) = sbm.profile.get_values(1000., ['temperature', 'salinity',\\n 'pressure'])\\n assert Tp == T\\n assert Sp == S\\n assert Pp == P\",\n \"def test_models_multiclass(model):\\n atom = ATOMClassifier(X_class2, y_class2, test_size=0.24, random_state=1)\\n atom.run(\\n models=model,\\n metric=\\\"f1_micro\\\",\\n n_calls=2,\\n n_initial_points=1,\\n bo_params={\\\"base_estimator\\\": \\\"rf\\\", \\\"cv\\\": 1},\\n )\\n assert not atom.errors\\n assert hasattr(atom, model)\",\n \"def test_same_models(self):\\n\\t\\t\\n\\t\\t# TODO: finish\\n\\t\\tpass\",\n \"def test_predict_from_example_stream():\\n stream = ExampleStream('vw.stream.txt')\\n examples = []\\n for i in xrange(len(DATA)):\\n (value, all_sections) = DATA[i]\\n ex = VowpalExample(i, value)\\n for (namespace, section) in all_sections.items():\\n ex.add_section(namespace, section)\\n stream.add_example(ex)\\n train = examples[:-2]\\n test = examples[-2:]\\n vw = Vowpal(PATH_VW, './vw.%s', {'--passes' : '10' })\\n preds = vw.predict_from_example_stream(stream)\\n for (id, value) in preds:\\n print 'prediction for %s is %s' % (id, value)\",\n \"def test_coupledmodels_post(self):\\n pass\",\n \"def test_model_can_import():\\n assert hasattr(model, \\\"SEIR_model_publish_w_risk\\\")\\n assert hasattr(model, \\\"compute_R0\\\")\",\n \"def test_get_model_list():\\n with app.test_client() as c:\\n response = c.get('/REST/api/v1.0/model_list') \\n assert response.status_code == 201\",\n \"def target(self, example):\\n raise NotImplementedError()\",\n \"def run_tests():\\n source1 = TextModel('hilary_speaches')\\n source1.add_file('hilary_source_text.txt')\\n\\n source2 = TextModel('bernie_speaches')\\n source2.add_file('bernie_source_text.txt')\\n\\n new1 = TextModel('trump_speach')\\n new1.add_file('trump_text.txt')\\n new1.classify(source1, source2)\\n\\n new2 = TextModel('hilary_test')\\n new2.add_file('hilary_test.txt')\\n new2.classify(source1, source2)\\n\\n new3 = TextModel('bernie_test')\\n new3.add_file('bernie_test.txt')\\n new3.classify(source1, source2)\\n\\n new4 = TextModel('bill_clinton_test')\\n new4.add_file('bill_clinton_source.txt')\\n new4.classify(source1, source2)\",\n \"def test_proof_model():\\n m = build_proof_model()\\n with m:\\n trace = pm.sample(50)\\n assert trace.report.ok\",\n \"def test_model_info_Generator():\\n model = ModelInfo('test description', {'f1': 0.9},\\n BaseLocation('protoc://something'), TestGenerator())\\n assert 'test description' in model.items['description']\\n assert model.items['metrics']['f1'] == 0.9\\n assert model.items['location'].get_host() == 'something'\\n assert model.items['hash'] is 5\",\n \"def test_train_house_price_model():\\n with app.test_client()as c:\\n response = c.get('/REST/api/v1.0/train')\\n assert response.status_code == 201\",\n \"def test_sample_one_id(self):\\r\\n self.assertEqual(self.test_sample.id, 1)\",\n \"def test_workflow_api_model(self):\\n self.assure_category_exists('test_admin_category', admin=True)\\n self.load_test_spec('simple_form')\\n self.load_test_spec('hello_world', category_id='test_admin_category')\\n\\n simple_form_workflow = self.create_workflow('simple_form')\\n hello_world_workflow = self.create_workflow('hello_world')\\n # Make sure both workflows use the same study\\n self.assertEqual(hello_world_workflow.study.id, simple_form_workflow.study.id)\\n study = hello_world_workflow.study\\n # Make sure the study status is in_progress\\n self.assertEqual(StudyStatus.in_progress, study.status)\\n\\n rv_simple_form_1 = self.app.get('/v1.0/workflow/%s' % simple_form_workflow.id,\\n follow_redirects=True,\\n content_type=\\\"application/json\\\",\\n headers=self.logged_in_headers())\\n self.assert_success(rv_simple_form_1)\\n json_data_simple_1 = json.loads(rv_simple_form_1.get_data(as_text=True))\\n self.assertFalse(json_data_simple_1['is_admin_workflow'])\\n\\n rv_hello_world_1 = self.app.get('/v1.0/workflow/%s' % hello_world_workflow.id,\\n follow_redirects=True,\\n content_type=\\\"application/json\\\",\\n headers=self.logged_in_headers())\\n self.assert_success(rv_hello_world_1)\\n json_data_hello_1 = json.loads(rv_hello_world_1.get_data(as_text=True))\\n self.assertTrue(json_data_hello_1['is_admin_workflow'])\",\n \"def test_coupledmodels_get(self):\\n pass\",\n \"def test_invalid_model(self):\\n self.assertRaises(ModelNotFoundError, lambda: ModelContainer('web', 'model').model_cls)\",\n \"def test_model(base, fake_session):\\n\\n # Make a dummy model\\n\\n # these fields should be ignored and should not appear in the model\\n ignored = (\\\"field1\\\", \\\"field2\\\", \\\"field3\\\")\\n\\n # these fields are in the model, but should not get dumped to json\\n loadonly = (\\\"field6\\\", \\\"field7\\\")\\n\\n @add_schema\\n class MyModel(base):\\n fields = dict(ignore=ignored, load_only=loadonly)\\n\\n # load the model from dummy data\\n values = range(10)\\n keys = [\\\"field{}\\\".format(x) for x in values]\\n data = dict(zip(keys, values))\\n m = MyModel.load_from(data, fake_session)\\n\\n return m, ignored, loadonly, data, MyModel\",\n \"def test_model_import(self, iris_astore):\\n model = register_model(\\n iris_astore, self.MODEL_NAME, self.PROJECT_NAME, force=True\\n )\\n\\n assert self.MODEL_NAME == model.name\",\n \"def setUp(self):\\n super().setUp()\\n described_model_kwargs = {\\\"name\\\": \\\"Name\\\", \\\"description\\\": \\\"Description\\\"}\\n self.mapped_model = MappedModel[DescribedModel].parse_obj({\\\"described_model_type\\\": described_model_kwargs})\\n self.expected_described_model = DescribedModel(**described_model_kwargs)\",\n \"def test__extract_features(self):\\n text_sample = \\\"I really really love this movie\\\"\\n feature_sample = ['really','love','good']\\n feature_score_type = \\\"presence\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':1,'love':1,'good':0})\\n feature_score_type = \\\"term_frequency\\\"\\n model_sample = Model(feature_sample,feature_score_type)\\n result_features = model_sample.extract_features(text_sample)\\n assert_equal(result_features,{'really':2,'love':1,'good':0})\",\n \"def test_get_item(self):\\n self.assertEqual(self.expected_described_model, self.mapped_model[\\\"described_model_type\\\"])\",\n \"def test_get_talks_model(self):\\r\\n self.assertIsInstance(self.db.get_talks_model(\\\"SC2011\\\", \\\"T105\\\"), QtSql.QSqlQueryModel)\",\n \"def test_multiple_base_models(engine):\\n with pytest.raises(ValueError):\\n bloop.model.BaseModel(engine)\",\n \"def test_im_model(name, xtrain_short=None, ytrain_short=None, nodisplay=False, \\n summary=False, do_test=False):\\n print(\\\"Loading model...\\\")\\n objs = {\\\"accuracy\\\": fret_accuracy()}\\n model = keras.models.load_model(\\\"models/\\\"+name+\\\".hdf5\\\", custom_objects=objs)\\n\\n if summary:\\n # if we are just loading and have not trained\\n model.summary()\\n\\n # if (batchsize, guitarstringindex, probabilities) then categorical, else \\n # (batchsize, stringpred) is regression-type\\n shape = model.get_output_shape_at(-1)\\n if len(shape) > 2:\\n categorical = True\\n else:\\n categorical = False\\n\\n \\\"\\\"\\\"\\n testing\\n \\\"\\\"\\\"\\n data = load_all_data(\\\"data/inference_model_train\\\", num_splits=0, \\n display=(not nodisplay), do_test=do_test)\\n xtest, _, _, ytest, _, _ = data\\n\\n print(\\\"Evaluating on test set w/ no transitions\\\")\\n print(len(xtest), \\\"testing images\\\")\\n results = model.evaluate(xtest, ytest, verbose=1)\\n with open(\\\"stats/\\\"+name+\\\"/stats.txt\\\", \\\"a\\\") as f:\\n f.write(\\\"\\\\nTest results (no transitions):\\\\n\\\")\\n for i,metric in enumerate(model.metrics_names):\\n print(\\\" \\\", metric+\\\":\\\", results[i])\\n f.write(metric+\\\": \\\"+str(results[i])+\\\"\\\\n\\\")\\n\\n # free memory\\n del data, xtest, ytest\\n import gc; gc.collect()\\n\\n data = load_all_data(\\\"data/inference_model_train\\\", num_splits=0, \\n display=(not nodisplay), do_test=do_test, no_transitions=False)\\n xtest, _, _, ytest, _, _ = data\\n\\n print(\\\"Evaluating on test set w/ transitions\\\")\\n print(len(xtest), \\\"testing images\\\")\\n results = model.evaluate(xtest, ytest, verbose=1)\\n with open(\\\"stats/\\\"+name+\\\"/stats.txt\\\", \\\"a\\\") as f:\\n f.write(\\\"\\\\nTest results (with transitions):\\\\n\\\")\\n for i,metric in enumerate(model.metrics_names):\\n print(\\\" \\\", metric+\\\":\\\", results[i])\\n f.write(metric+\\\": \\\"+str(results[i])+\\\"\\\\n\\\")\\n\\n scaleup = 2.0\\n\\n # on training set, if available\\n if xtrain_short is not None:\\n print(\\\"Generating video on train set predictions\\\")\\n trainpreds = model.predict(xtrain_short, verbose=1)\\n\\n vid = [cv.resize(i, dsize=(0,0), fx=scaleup, fy=scaleup, \\\\\\n interpolation=cv.INTER_LINEAR) for i in xtrain_short]\\n\\n annotate_vid(vid, trainpreds, ytrain_short, categorical)\\n if not nodisplay:\\n showvid(vid, name=\\\"train ims\\\", ms=300)\\n writevid(vid, \\\"stats/\\\"+name+\\\"/results_visualization_trainset\\\")\\n\\n # on test set\\n print(\\\"Generating video on test set predictions\\\")\\n numframes = 1000\\n testpreds = model.predict(xtest[:numframes], verbose=1)\\n\\n vid = [cv.resize(i, dsize=(0,0), fx=scaleup, fy=scaleup, \\\\\\n interpolation=cv.INTER_LINEAR) for i in xtest[:numframes]]\\n\\n annotate_vid(vid, testpreds, ytest[:numframes], categorical)\\n if not nodisplay:\\n showvid(vid, name=\\\"test set\\\", ms=35)\\n writevid(vid, \\\"stats/\\\"+name+\\\"/results_visualization_testset\\\")\",\n \"def test_constructor(self):\\n # Record the model types of all the models to be created\\n all_model_types = model_type_to_display_name.keys()\\n\\n # Record the attribute / value pairs that are common to all models.\\n common_attr_value_dict = {\\\"data\\\": self.fake_df,\\n \\\"name_spec\\\": self.fake_names,\\n \\\"design\\\": self.fake_design,\\n \\\"ind_var_names\\\": self.fake_names[\\\"x\\\"],\\n \\\"alt_id_col\\\": self.alt_id_col,\\n \\\"obs_id_col\\\": self.obs_id_col,\\n \\\"choice_col\\\": self.choice_col,\\n \\\"specification\\\": self.fake_specification,\\n \\\"alt_IDs\\\": self.fake_df[\\\"alt_id\\\"].values,\\n \\\"choices\\\": self.fake_df[\\\"choice\\\"].values}\\n\\n # Create a shape name dictionary to relate the various models to the\\n # names of their shape parameters.\\n shape_name_dict = {\\\"MNL\\\": None,\\n \\\"Asym\\\": self.fake_shape_names[:2],\\n \\\"Cloglog\\\": None,\\n \\\"Scobit\\\": self.fake_shape_names,\\n \\\"Uneven\\\": self.fake_shape_names,\\n \\\"Nested Logit\\\": None,\\n \\\"Mixed Logit\\\": None}\\n\\n # Create a shape reference position dictionary to relate the various\\n # models to their shape reference positions.\\n shape_ref_dict = {}\\n for key in shape_name_dict:\\n shape_ref_dict[key] = (None if key != \\\"Asym\\\" else\\n self.fake_shape_ref_pos)\\n\\n # Create an intercept_names and intercept_ref_position dictionary to\\n # relate the various models to their respective kwargs.\\n intercept_names_dict = {}\\n intercept_ref_dict = {}\\n for key in shape_name_dict:\\n if key in [\\\"MNL\\\", \\\"Nested Logit\\\", \\\"Mixed Logit\\\"]:\\n intercept_names_dict[key] = None\\n intercept_ref_dict[key] = None\\n else:\\n intercept_names_dict[key] = self.fake_intercept_names\\n intercept_ref_dict[key] = self.fake_intercept_ref_pos\\n\\n # Create a nest_names dictionary to relate the various models to their\\n # nest_name attributes\\n nest_name_dict = {}\\n nest_spec_dict = {}\\n for key in shape_name_dict:\\n if key != \\\"Nested Logit\\\":\\n nest_name_dict[key] = None\\n nest_spec_dict[key] = None\\n else:\\n nest_name_dict[key] = list(self.fake_nest_spec.keys())\\n nest_spec_dict[key] = self.fake_nest_spec\\n\\n # Create dictionaries for the mixing_id_col, mixing_vars, and\\n # mixing_pos attributes\\n mixing_id_col_dict = {}\\n mixing_vars_dict = {}\\n mixing_pos_dict = {}\\n\\n for key in shape_name_dict:\\n if key != \\\"Mixed Logit\\\":\\n mixing_id_col_dict[key] = None\\n mixing_vars_dict[key] = None\\n mixing_pos_dict[key] = None\\n else:\\n mixing_id_col_dict[key] = self.obs_id_col\\n mixing_vars_dict[key] = self.fake_names[\\\"x\\\"]\\n mixing_pos_dict[key] = [0]\\n\\n # Record the attribute / value pairs that vary across models\\n varying_attr_value_dict = {\\\"model_type\\\": model_type_to_display_name,\\n \\\"intercept_names\\\": intercept_names_dict,\\n \\\"intercept_ref_position\\\":\\n intercept_ref_dict,\\n \\\"shape_names\\\": shape_name_dict,\\n \\\"shape_ref_position\\\": shape_ref_dict,\\n \\\"nest_names\\\": nest_name_dict,\\n \\\"nest_spec\\\": nest_spec_dict,\\n \\\"mixing_id_col\\\": mixing_id_col_dict,\\n \\\"mixing_vars\\\": mixing_vars_dict,\\n \\\"mixing_pos\\\": mixing_pos_dict}\\n\\n # Set up the keyword arguments that are needed for each of the model\\n # types\\n variable_kwargs = {}\\n for model_name in all_model_types:\\n variable_kwargs[model_name] = {}\\n variable_kwargs[model_name][\\\"intercept_names\\\"] =\\\\\\n intercept_names_dict[model_name]\\n variable_kwargs[model_name][\\\"intercept_ref_pos\\\"] =\\\\\\n intercept_ref_dict[model_name]\\n variable_kwargs[model_name][\\\"shape_ref_pos\\\"] =\\\\\\n shape_ref_dict[model_name]\\n variable_kwargs[model_name][\\\"shape_names\\\"] =\\\\\\n shape_name_dict[model_name]\\n variable_kwargs[model_name][\\\"nest_spec\\\"] =\\\\\\n nest_spec_dict[model_name]\\n variable_kwargs[model_name][\\\"mixing_id_col\\\"] =\\\\\\n mixing_id_col_dict[model_name]\\n variable_kwargs[model_name][\\\"mixing_vars\\\"] =\\\\\\n mixing_vars_dict[model_name]\\n\\n # Execute the test for each model type\\n for model_name in all_model_types:\\n # Update the model type in the list of constructor args\\n self.constructor_args[-1] = model_name\\n\\n # Use this specific model's keyword arguments\\n self.constructor_kwargs.update(variable_kwargs[model_name])\\n\\n # Construct the model object\\n model_obj = pylogit.create_choice_model(*self.constructor_args,\\n **self.constructor_kwargs)\\n\\n # Make sure that the constructor has all of the required attributes\\n for attr in common_attr_value_dict:\\n value = common_attr_value_dict[attr]\\n if isinstance(value, pd.DataFrame):\\n self.assertTrue(value.equals(model_obj.data))\\n elif isinstance(value, np.ndarray):\\n npt.assert_allclose(value,\\n model_obj.__getattribute__(attr))\\n else:\\n self.assertEqual(value,\\n model_obj.__getattribute__(attr))\\n\\n for attr in varying_attr_value_dict:\\n value = varying_attr_value_dict[attr][model_name]\\n\\n self.assertEqual(value,\\n model_obj.__getattribute__(attr))\\n\\n return None\",\n \"def test_api_predictors_get(self):\\n pass\",\n \"def test_model_post(self):\\n\\n new_model = dummy_data()\\n element_key_to_delete = random.choice(list(new_model.elements.keys()))\\n new_model.elements[element_key_to_delete].deleted = True\\n test_json = new_model.to_json()\\n\\n result = self.client().post(\\n '/model',\\n json=test_json)\\n\\n self.assertEqual(result.status_code, 201)\\n\\n result = self.client().get('/model')\\n data = Model.from_json(result.data.decode())\\n\\n self.assertEqual(result.status_code, 200)\\n\\n self.assertEqual(data, new_model)\",\n \"def test_is_pipeline(model):\\n assert type(model) == Pipeline\",\n \"def test_train_model_type_good():\\n\\tdf = pd.read_csv(\\\"test/sample_features.csv\\\")\\n\\n\\ty_train = df['price']\\n\\tX_train = df.loc[:, df.columns != 'price']\\n\\n\\tparams = {'n_estimators': 5, 'random_state': 2}\\n\\trf_test = train(X_train, y_train, params)\\n\\n\\t# test model type\\n\\ttest_model_type = str(type(rf_test))\\n\\ttrue_model_type = \\\"<class 'sklearn.ensemble._forest.RandomForestRegressor'>\\\"\\n\\tassert test_model_type == true_model_type\",\n \"def test_prepare_model_medium_objective(raw_model, expected_model, config):\\n essential.configure_model(raw_model, config)\\n raw_id = find_objective_function(raw_model)[0].id\\n expected_id = find_objective_function(expected_model)[0].id\\n assert raw_id == expected_id\",\n \"def test_model(self, model_name, nncf, category=\\\"shapes\\\", path=\\\"\\\"):\\n with tempfile.TemporaryDirectory() as project_path:\\n # Train test\\n config, datamodule, model, trainer = setup_model_train(\\n model_name,\\n dataset_path=path,\\n project_path=project_path,\\n nncf=nncf,\\n category=category,\\n fast_run=True,\\n )\\n results = trainer.test(model=model, datamodule=datamodule)[0]\\n\\n # Test model load\\n model_load_test(config, datamodule, results)\",\n \"def test_create_a_car_model(car_model):\\n car_models = models.CarMake.objects.all()\\n\\n assert car_model\\n assert car_model.name == \\\"Golf\\\"\\n assert car_model.car_make.name == \\\"Volkswagen\\\"\\n assert len(car_models) == 1\",\n \"def test_no_model(self):\\n\\n with self.assertRaisesRegex(ValueError,\\n 'Please provide a model for this generator'):\\n self._gen.generate(\\n example=self._example,\\n model=None,\\n dataset=self._dataset,\\n config=self._config)\",\n \"def test_prepare_sample_to_forward(self):\\n sample = [\\n {\\\"src\\\": \\\"ola mundo\\\", \\\"ref\\\": \\\"hi world\\\", \\\"mt\\\": \\\"hey world!\\\", \\\"score\\\": 0.8},\\n {\\\"src\\\": \\\"ola mundo\\\", \\\"ref\\\": \\\"hi world\\\", \\\"mt\\\": \\\"hey world!\\\", \\\"score\\\": 0.8},\\n ]\\n\\n model_input, target = self.estimator.prepare_sample(sample)\\n model_output = self.estimator(**model_input)\\n self.assertTrue(model_output[\\\"score\\\"].shape[0] == 2)\\n self.assertTrue(model_output[\\\"score\\\"].shape[1] == 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77361155","0.74117136","0.7402094","0.7367298","0.6964708","0.6916549","0.68771887","0.68725353","0.6861734","0.6753478","0.6733257","0.6683285","0.66675687","0.66135466","0.6555324","0.65510744","0.6531237","0.6518147","0.6501927","0.65007454","0.6486974","0.6442517","0.6411669","0.6407157","0.6400093","0.63454473","0.6338303","0.63189816","0.630879","0.62857157","0.6258359","0.6248877","0.62414473","0.62379533","0.62103057","0.62038285","0.6198202","0.6190815","0.6163505","0.6146882","0.6131103","0.61261654","0.61070216","0.6099232","0.6090917","0.60904217","0.60708576","0.606638","0.60658187","0.6045611","0.60380226","0.60360014","0.6023457","0.6021293","0.6007496","0.60046434","0.59971184","0.5994066","0.5991836","0.59881353","0.59881353","0.5981419","0.5980894","0.59808344","0.59770316","0.5975683","0.59714186","0.5967286","0.59590536","0.5953755","0.59519863","0.5946311","0.5943505","0.5940735","0.59382427","0.5934348","0.59279096","0.5920875","0.5917673","0.59019333","0.58964956","0.589091","0.5888481","0.5885948","0.5867418","0.58617437","0.5854354","0.58535165","0.5850858","0.5848467","0.5841705","0.5840781","0.58387405","0.58371896","0.5834524","0.5833631","0.5830849","0.58221364","0.58221084","0.5818772","0.58094037"],"string":"[\n \"0.77361155\",\n \"0.74117136\",\n \"0.7402094\",\n \"0.7367298\",\n \"0.6964708\",\n \"0.6916549\",\n \"0.68771887\",\n \"0.68725353\",\n \"0.6861734\",\n \"0.6753478\",\n \"0.6733257\",\n \"0.6683285\",\n \"0.66675687\",\n \"0.66135466\",\n \"0.6555324\",\n \"0.65510744\",\n \"0.6531237\",\n \"0.6518147\",\n \"0.6501927\",\n \"0.65007454\",\n \"0.6486974\",\n \"0.6442517\",\n \"0.6411669\",\n \"0.6407157\",\n \"0.6400093\",\n \"0.63454473\",\n \"0.6338303\",\n \"0.63189816\",\n \"0.630879\",\n \"0.62857157\",\n \"0.6258359\",\n \"0.6248877\",\n \"0.62414473\",\n \"0.62379533\",\n \"0.62103057\",\n \"0.62038285\",\n \"0.6198202\",\n \"0.6190815\",\n \"0.6163505\",\n \"0.6146882\",\n \"0.6131103\",\n \"0.61261654\",\n \"0.61070216\",\n \"0.6099232\",\n \"0.6090917\",\n \"0.60904217\",\n \"0.60708576\",\n \"0.606638\",\n \"0.60658187\",\n \"0.6045611\",\n \"0.60380226\",\n \"0.60360014\",\n \"0.6023457\",\n \"0.6021293\",\n \"0.6007496\",\n \"0.60046434\",\n \"0.59971184\",\n \"0.5994066\",\n \"0.5991836\",\n \"0.59881353\",\n \"0.59881353\",\n \"0.5981419\",\n \"0.5980894\",\n \"0.59808344\",\n \"0.59770316\",\n \"0.5975683\",\n \"0.59714186\",\n \"0.5967286\",\n \"0.59590536\",\n \"0.5953755\",\n \"0.59519863\",\n \"0.5946311\",\n \"0.5943505\",\n \"0.5940735\",\n \"0.59382427\",\n \"0.5934348\",\n \"0.59279096\",\n \"0.5920875\",\n \"0.5917673\",\n \"0.59019333\",\n \"0.58964956\",\n \"0.589091\",\n \"0.5888481\",\n \"0.5885948\",\n \"0.5867418\",\n \"0.58617437\",\n \"0.5854354\",\n \"0.58535165\",\n \"0.5850858\",\n \"0.5848467\",\n \"0.5841705\",\n \"0.5840781\",\n \"0.58387405\",\n \"0.58371896\",\n \"0.5834524\",\n \"0.5833631\",\n \"0.5830849\",\n \"0.58221364\",\n \"0.58221084\",\n \"0.5818772\",\n \"0.58094037\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":170,"numItemsPerPage":100,"numTotalItems":95772,"offset":17000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjIxMjYyNywianRpIjoiOWJmNDE3ODktMmZiYi00ZWE2LWI1YzQtZTRkN2RmM2RiNzU3Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMTYyMjcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.h7ThfNIElSxk03v6hd2LDPGcjSFzLvTr8FkSVWwaoqXyAc4jX4WOs7pal4r3MQKxln_dGnwscNNe-VZkDffQAQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Test with the default `key` function. | def test_default(self):
iterables = [xrange(4), xrange(7), xrange(3, 6)]
eq_(sorted(reduce(list.__add__, [list(it) for it in iterables])),
list(collate(*iterables))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def func2(key):\n return key in my_test_dict.keys()",
"def func4(key):\n return key in list(my_test_dict.keys())",
"def _check_key(self, key):\n raise NotImplementedError",
"def def_key(x):\n return x",
"def match_key(name, func, fallback=None, default=None):\n return key_predicate(name,... | [
"0.7282693",
"0.71756196",
"0.71305937",
"0.7098984",
"0.7057804",
"0.7001745",
"0.6984697",
"0.69285727",
"0.6883116",
"0.68428445",
"0.681415",
"0.681415",
"0.67970467",
"0.6711432",
"0.6591156",
"0.6535495",
"0.6524363",
"0.65238",
"0.64847535",
"0.6474364",
"0.64628536",
... | 0.0 | -1 |
Test using a custom `key` function. | def test_key(self):
iterables = [xrange(5, 0, -1), xrange(4, 0, -1)]
eq_(list(sorted(reduce(list.__add__,
[list(it) for it in iterables]),
reverse=True)),
list(collate(*iterables, key=lambda x: -x))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def func2(key):\n return key in my_test_dict.keys()",
"def func4(key):\n return key in list(my_test_dict.keys())",
"def test_key_predicate(datum):\n return 0 < datum",
"def check_key(key, value):\n return lambda event, data: data[key] == value",
"def def_key(x):\n return x",
"def m... | [
"0.7484835",
"0.72601134",
"0.7210287",
"0.7091431",
"0.6978449",
"0.69044787",
"0.69040096",
"0.6876834",
"0.66988754",
"0.6654753",
"0.6654753",
"0.6654383",
"0.6632204",
"0.6570202",
"0.6456564",
"0.6436678",
"0.64096034",
"0.6403737",
"0.6399561",
"0.6399555",
"0.63975805... | 0.0 | -1 |
Be nice if passed an empty list of iterables. | def test_empty(self):
eq_([], list(collate())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _assert_non_empty(iterable):\n first_elem = six.next(iterable, None)\n assert first_elem is not None, first_elem\n return itertools.chain([first_elem], iterable)",
"def safe_iterator(i):\n return i or []",
"def non_none(iterable: Iterable[Optional[_T]]) -> Iterable[_T]:\n return (x for x in ... | [
"0.697166",
"0.6827782",
"0.6481945",
"0.640688",
"0.640688",
"0.636432",
"0.6197909",
"0.6123634",
"0.6121327",
"0.6044029",
"0.60292834",
"0.60119545",
"0.5998964",
"0.59287125",
"0.5925197",
"0.5832315",
"0.5824543",
"0.5822089",
"0.5778827",
"0.5768213",
"0.57573366",
"... | 0.53930485 | 83 |
Work when only 1 iterable is passed. | def test_one(self):
eq_([0, 1], list(collate(xrange(2)))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterable(arg):\n return isinstance(arg, collections.Iterable) and not isinstance(arg, six.string_types)",
"def oneIteration(self):\n\t\traise NotImplementedError",
"def _ensure_iterable(x):\n if isinstance(x[0], Iterable):\n if len(x) > 1:\n raise TypeError(\"Either Iterable or vari... | [
"0.66168714",
"0.64325726",
"0.62727374",
"0.6237593",
"0.6157956",
"0.6146108",
"0.60707337",
"0.6051359",
"0.5916164",
"0.588313",
"0.5857233",
"0.5807984",
"0.57936543",
"0.5764656",
"0.57329",
"0.5730603",
"0.5715446",
"0.5656539",
"0.56495816",
"0.5647118",
"0.56263393",... | 0.0 | -1 |
Test the `reverse` kwarg. | def test_reverse(self):
iterables = [xrange(4, 0, -1), xrange(7, 0, -1), xrange(3, 6, -1)]
eq_(sorted(reduce(list.__add__, [list(it) for it in iterables]),
reverse=True),
list(collate(*iterables, reverse=True))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _can_reverse(self):\n return not bool(self._reverse_callback())",
"def set_reverse(rev):\n global is_reverse\n is_reverse = rev",
"def testSortingReverse(self):\n if self.sortingReverse.lower() in [\"1\", \"yes\", \"true\", \"on\"]:\n self.assertTrue(\n self.co... | [
"0.73392296",
"0.68163896",
"0.6537939",
"0.6523438",
"0.63412285",
"0.6307833",
"0.6299878",
"0.6275159",
"0.61790586",
"0.613202",
"0.6116976",
"0.60824007",
"0.6046022",
"0.5983002",
"0.5976699",
"0.5970638",
"0.594553",
"0.59288",
"0.59192276",
"0.58404404",
"0.574365",
... | 0.0 | -1 |
Return a value corresponding to the specified key in the (possibly nested) dictionary d. If there is no item with that key, return default. | def search(d, key, default=None):
stack = [iter(d.items())]
while stack:
for k, v in stack[-1]:
if isinstance(v, dict):
stack.append(iter(v.items()))
break
elif k == key:
return v
else:
stack.pop()
return def... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_default(ddict, key, default):\n if ddict is None or key not in ddict or ddict[key] is None:\n return default\n return ddict[key]",
"def get(self, k, d=None):\n try:\n return self[k]\n except KeyError:\n return d",
"def get_from_dict(d, k):\n try:\n ... | [
"0.7717753",
"0.76185805",
"0.7615463",
"0.7520465",
"0.72834295",
"0.72716373",
"0.7218349",
"0.7151886",
"0.71330154",
"0.71017414",
"0.7101235",
"0.7039617",
"0.70120084",
"0.7002762",
"0.69949806",
"0.6990771",
"0.6963007",
"0.6906186",
"0.690185",
"0.68835884",
"0.684690... | 0.7036676 | 12 |
This function get latest block from diffetent APIs and write in json file | def get_info():
with open('explorers.json', 'r') as file:
block_expl_info = json.load(file)
BLOCK_EXPL_INFO['block_explorers'] = [{'analytics': [None, None]} for i in range(len(block_expl_info))]
analytic_thread = threading.Thread(target=get_analytics)
analytic_thread.start()
print(analytic_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_latest_data():\n try:\n print '\\nRequesting new data.....\\n'\n response = get(\"https://api.myjson.com/bins/2csub\")\n if response.status_code is 200:\n print '\\nSuccess (200) in downloading data\\n'\n current_json = response.json()\n set_backup_d... | [
"0.6503777",
"0.6334233",
"0.62467307",
"0.62189907",
"0.61117643",
"0.6050079",
"0.60054547",
"0.58136255",
"0.58010566",
"0.57338744",
"0.5697717",
"0.5620307",
"0.55549675",
"0.5551227",
"0.55333763",
"0.55333763",
"0.55144376",
"0.5498901",
"0.5490922",
"0.5452683",
"0.54... | 0.5848694 | 7 |
benanne lasagne ortho init (faster than qr approach) | def orthogonal(shape):
# taken from https://gist.github.com/kastnerkyle/f7464d98fe8ca14f2a1a
flat_shape = (shape[0], np.prod(shape[1:]))
a = np.random.normal(0.0, 1.0, flat_shape)
u, _, v = np.linalg.svd(a, full_matrices=False)
q = u if u.shape == flat_shape else v # pick the one with the correct s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orthopyroxene():\n\n rho = 3304.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 236.9; C[0,1] = 79.6; C[0,2] = 63.2; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 180.5; C[1,2] = 56.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\n... | [
"0.64098346",
"0.63685274",
"0.60832596",
"0.6028435",
"0.5947269",
"0.59407026",
"0.579842",
"0.5745779",
"0.5697982",
"0.5618773",
"0.5618319",
"0.56166106",
"0.5591402",
"0.55160123",
"0.55101013",
"0.55034405",
"0.54688793",
"0.5467705",
"0.54606175",
"0.54093295",
"0.539... | 0.5047098 | 62 |
Adds a text element to a specified parent. | def appendElement(document, parentEl, elementType, elementText):
el = document.createElement(elementType)
textEl = document.createTextNode(elementText)
el.appendChild(textEl)
parentEl.appendChild(el) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def appendXmlTextNode(tag_name, text, parent):\n\tel = xmlTextNode(tag_name, text)\n\tparent.append(el)\n\treturn el",
"def newTextChild(self, parent, name, content):\n if parent is None: parent__o = None\n else: parent__o = parent._o\n ret = libxml2mod.xmlNewTextChild(parent__o, self._o, na... | [
"0.7619326",
"0.7439826",
"0.6652759",
"0.64436185",
"0.6351779",
"0.63348407",
"0.6281517",
"0.62726134",
"0.62400335",
"0.6226029",
"0.6225046",
"0.6085889",
"0.60642475",
"0.60318387",
"0.60238725",
"0.60130715",
"0.5980843",
"0.5944152",
"0.59254986",
"0.5901929",
"0.5814... | 0.69940925 | 2 |
Returns the text of a child node found by name. Only one such named child is expected. | def getSingleChildTextByName(rootNode, name):
try:
nodeList = [e.firstChild.data for e in rootNode.childNodes if e.localName == name]
if len(nodeList) > 0:
return nodeList[0]
else:
return None
except AttributeError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_child(self, name):\n for n in self.children:\n if n.name == name:\n return n\n\n raise ChildError(\"Can't find child node '{name}'\".format(**locals()))",
"def get_child(node, name):\r\n for child in node.childNodes:\r\n if child.localName == name:\r\n ... | [
"0.73368084",
"0.727436",
"0.709972",
"0.69880795",
"0.6772942",
"0.66547203",
"0.6558581",
"0.6543391",
"0.63135356",
"0.6266445",
"0.61968386",
"0.6183661",
"0.6125282",
"0.610355",
"0.6097007",
"0.60358995",
"0.6027794",
"0.6010082",
"0.5985832",
"0.5980697",
"0.5976921",
... | 0.7597116 | 0 |
Returns the text of a child node found by name and namespaceURI. Only one such named child is expected. | def getSingleChildTextByNameNS(rootNode, ns, name):
try:
nodeList = [e.firstChild.data for e in rootNode.childNodes if e.localName == name and e.namespaceURI == ns]
if len(nodeList) > 0:
return nodeList[0]
else:
return None
except AttributeError:
return No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_child(node, name):\r\n for child in node.childNodes:\r\n if child.localName == name:\r\n return child",
"def getSingleChildTextByName(rootNode, name):\n try:\n nodeList = [e.firstChild.data for e in rootNode.childNodes if e.localName == name]\n if len(nodeList) > 0:\... | [
"0.70851547",
"0.70435005",
"0.6444718",
"0.6246965",
"0.6225065",
"0.61497194",
"0.60729676",
"0.59668297",
"0.5915806",
"0.58188534",
"0.5817289",
"0.58145833",
"0.5802411",
"0.57501686",
"0.5727612",
"0.57120925",
"0.5695159",
"0.5669567",
"0.5641456",
"0.5641404",
"0.5610... | 0.7306041 | 0 |
Returns a child node found by name. Only one such named child is expected. | def getSingleChildByName(rootNode, name):
nodeList = [e for e in rootNode.childNodes if e.localName == name]
if len(nodeList) > 0:
return nodeList[0]
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_child(self, name):\n for n in self.children:\n if n.name == name:\n return n\n\n raise ChildError(\"Can't find child node '{name}'\".format(**locals()))",
"def get_child(self, name):\n return next((x for x in self.children if x.name == name), None)",
"def ... | [
"0.86502516",
"0.8376062",
"0.8369748",
"0.8116588",
"0.8055217",
"0.80475324",
"0.74776024",
"0.72721773",
"0.7254135",
"0.70476526",
"0.7046877",
"0.6960973",
"0.6834015",
"0.68138915",
"0.67392963",
"0.67390233",
"0.6701957",
"0.6683626",
"0.6664809",
"0.6658932",
"0.66554... | 0.7313616 | 7 |
Returns a child node found by name and namespaceURI. Only one such named child is expected. | def getSingleChildByNameNS(rootNode, ns, name):
nodeList = [e for e in rootNode.childNodes if e.localName == name and e.namespaceURI == ns]
if len(nodeList) > 0:
return nodeList[0]
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_child(node, name):\r\n for child in node.childNodes:\r\n if child.localName == name:\r\n return child",
"def get_child(self, name):\n for n in self.children:\n if n.name == name:\n return n\n\n raise ChildError(\"Can't find child node '{name}'\... | [
"0.7954468",
"0.7309337",
"0.68384355",
"0.6826391",
"0.6678914",
"0.6557882",
"0.65442234",
"0.64864975",
"0.64746964",
"0.63713264",
"0.6350687",
"0.63305914",
"0.6259071",
"0.6197164",
"0.61778927",
"0.6077632",
"0.60627794",
"0.6056079",
"0.602803",
"0.5981976",
"0.595238... | 0.7256824 | 2 |
Returns a descendent node found by a list of names forming a path. The path is expected to define a unique node. | def getSingleChildByPath(rootNode, path):
parentNode = rootNode
for name in path:
node = getSingleChildByName(parentNode, name)
if node == None:
return None
else:
parentNode = node
return node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_find_by_name( fdt, node_name, starting_node = 0, multi_match=False ):\n\n matching_nodes = []\n matching_node = None\n\n search_active = False\n if starting_node == \"/\" or starting_node == 0:\n search_active = True\n\n for node in fdt.node_iter():\n ... | [
"0.6124487",
"0.6115838",
"0.593276",
"0.5823367",
"0.5745633",
"0.569657",
"0.56698596",
"0.5564221",
"0.55456084",
"0.5510131",
"0.5459823",
"0.5403007",
"0.5365805",
"0.5351223",
"0.5350362",
"0.5321328",
"0.52815527",
"0.5258361",
"0.5242366",
"0.51757175",
"0.5166429",
... | 0.552407 | 9 |
Returns a descendent node found by a list of names and namespaceURIs forming a path. The path is expected to define a unique node. | def getSingleChildByPathNS(rootNode, path):
parentNode = rootNode
for (ns, name) in path:
node = getSingleChildByNameNS(parentNode, ns, name)
if node == None:
return None
else:
parentNode = node
return node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ParsePath(p_names: Iterable[Text]) -> gnmi_pb2.Path:\n gnmi_elems = []\n for word in p_names:\n word_search = _RE_PATH_COMPONENT.search(word)\n if not word_search: # Invalid path specified.\n raise XpathError('xpath component parse error: %s' % word)\n if word_search.group('key') is not None: ... | [
"0.5617993",
"0.5379932",
"0.5344396",
"0.52256453",
"0.5165489",
"0.5163145",
"0.5140036",
"0.49797037",
"0.49483255",
"0.49193937",
"0.4904224",
"0.4882593",
"0.48682582",
"0.48599708",
"0.48452106",
"0.482554",
"0.47848898",
"0.4771717",
"0.47439066",
"0.47428063",
"0.4738... | 0.5693317 | 0 |
Returns all child nodes of a specified name. | def getChildrenByName(rootNode, name):
return [e for e in rootNode.childNodes if e.localName == name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def findChildren(self, name):\n\n # Note: this returns a list of all the children of a given\n # name, irrespective of the depth of look-up.\n \n children = []\n \n for child in self.getAllChildren():\n if child.getName() == name:\n children.appen... | [
"0.78755844",
"0.76069707",
"0.70648605",
"0.6875181",
"0.686096",
"0.68549895",
"0.6836145",
"0.67805845",
"0.6676841",
"0.6539384",
"0.65334934",
"0.65248793",
"0.6507252",
"0.6486434",
"0.6399938",
"0.6362787",
"0.63362265",
"0.6320614",
"0.6318085",
"0.6318085",
"0.629610... | 0.79214627 | 0 |
Returns all child nodes of a specified name and namespaceURI. | def getChildrenByNameNS(rootNode, ns, name):
return [e for e in rootNode.childNodes if e.localName == name and e.namespaceURI == ns] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getChildrenByName(rootNode, name):\n return [e for e in rootNode.childNodes if e.localName == name]",
"def getElements(self, name=\"\"):\n\n if not name:\n return self.children\n else:\n elements = []\n for element in self.children:\n if elemen... | [
"0.7223935",
"0.6433308",
"0.6407375",
"0.6367358",
"0.63064814",
"0.6166133",
"0.6032213",
"0.59840125",
"0.59068906",
"0.5855462",
"0.5814537",
"0.58058417",
"0.577752",
"0.5765865",
"0.5721846",
"0.5721846",
"0.5707831",
"0.5676966",
"0.5676966",
"0.564972",
"0.5647398",
... | 0.77882755 | 0 |
Returns the value of an attribute specified by local name. The attribute's namespace is ignored. | def getAttributeByLocalName(element, localName):
attrs = element.attributes
for idx in xrange(attrs.length):
attr = attrs.item(idx)
if attr.localName == localName:
return attr.value
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getattribute(self, name):\n return self.attributes[name]",
"def getAttribute(self, name):\n \n return self[self._name][name]",
"def get_attr(attributes, name):\n try:\n return attributes.getValue(name)\n except KeyError:\n return None",
"def get_attribute_by_name(... | [
"0.70017785",
"0.6997067",
"0.68574476",
"0.68190736",
"0.68038845",
"0.67893267",
"0.6683643",
"0.66774267",
"0.66566056",
"0.6655",
"0.66367906",
"0.6598971",
"0.6485137",
"0.6479439",
"0.6449892",
"0.635203",
"0.6340864",
"0.62663764",
"0.6259211",
"0.6237172",
"0.6237172"... | 0.69933337 | 2 |
Process a /results command. | def results(update: Update, context: CallbackContext):
#update.effective_message.reply_text(text="here are all new results")
if update is not None:
context.bot.send_chat_action(
chat_id=update.effective_chat.id, action=ChatAction.TYPING)
get_latest_result(update, context)
if update.e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_result(self, results: List[Dict], **info):\n pass",
"def process(self, results):\n raise NotImplementedError",
"def process_results(self, response, results):\n return results",
"def process_results(self, response, results):\n return results",
"def process_results(self... | [
"0.6734966",
"0.67013997",
"0.65604585",
"0.65604585",
"0.6508539",
"0.6383611",
"0.63752776",
"0.628759",
"0.62337244",
"0.60858846",
"0.60244346",
"0.5963668",
"0.5954561",
"0.5951688",
"0.592082",
"0.58933157",
"0.58777326",
"0.5819628",
"0.5786597",
"0.5752275",
"0.573779... | 0.55912423 | 33 |
Add new node to the Pipeline | def add_node(self, new_node: 'GraphNode'):
self.operator.add_node(new_node) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_node(self, node):",
"def add_node(self, node):\n self.nodes.append(node)",
"def add_node (self, node):\n raise NotImplementedError",
"def add_node(self, node):\n self.nodes.add(node)",
"def addNode(self, node: Node):\n self.nodes.append(node)",
"def add_node(self, node):\n... | [
"0.78037673",
"0.75197977",
"0.74303645",
"0.74014753",
"0.7204696",
"0.7202427",
"0.7178709",
"0.7173464",
"0.715541",
"0.7050441",
"0.7048333",
"0.70343333",
"0.703212",
"0.70309037",
"0.7029448",
"0.7029448",
"0.70204383",
"0.70176816",
"0.7000545",
"0.69609106",
"0.693755... | 0.7537602 | 1 |
Replace old_node with new one. | def update_node(self, old_node: 'GraphNode', new_node: 'GraphNode'):
self.operator.update_node(old_node, new_node) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_node(old_node: Node, new_node: Node):\n assert old_node.graph is new_node.graph\n graph = old_node.graph\n # save output edges and reconnect them to new node\n for i in range(len(old_node.out_nodes())):\n graph.add_edge(new_node.id, old_node.out_node(i).id, **old_node.out_edge(i))\n ... | [
"0.7680387",
"0.7633826",
"0.7320932",
"0.73136884",
"0.7191044",
"0.7059257",
"0.6879529",
"0.6699083",
"0.65904534",
"0.6554778",
"0.6548092",
"0.6536816",
"0.6461663",
"0.64516395",
"0.6449112",
"0.63957167",
"0.63931674",
"0.6388096",
"0.6375951",
"0.6366883",
"0.63541114... | 0.73606163 | 2 |
Replace the subtrees with old and new nodes as subroots | def update_subtree(self, old_subroot: 'GraphNode', new_subroot: 'GraphNode'):
self.operator.update_subtree(old_subroot, new_subroot) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def root_replace(self,node):\r\n self.feature_index = node.feature_index\r\n self.threshold = node.threshold\r\n self.label = node.label\r\n self.left = node.left\r\n self.right = node.right\r\n self.substitute = node.substitute\r\n if node.left is not None and node... | [
"0.7107235",
"0.65856475",
"0.6365465",
"0.63301456",
"0.625012",
"0.6236693",
"0.61715674",
"0.61310095",
"0.6120327",
"0.60683495",
"0.6065253",
"0.6024953",
"0.6012735",
"0.5961078",
"0.5948224",
"0.5947182",
"0.59322995",
"0.5925321",
"0.5905774",
"0.5905076",
"0.58694637... | 0.6714457 | 1 |
Delete chosen node redirecting all its parents to the child. | def delete_node(self, node: 'GraphNode'):
self.operator.delete_node(node) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n self.parent.delete_node(self)",
"def delete_one_child(self, node):\n if node.left != None:\n child = node.left\n else:\n child = node.right\n \n parent = node.parent\n if parent.left == node:\n parent.left = ch... | [
"0.78784764",
"0.7650336",
"0.715978",
"0.71591645",
"0.71019995",
"0.70694184",
"0.70303255",
"0.6992636",
"0.6982972",
"0.696881",
"0.6946081",
"0.6915932",
"0.6914303",
"0.6887968",
"0.6835174",
"0.6793784",
"0.67868143",
"0.67830443",
"0.677916",
"0.67647326",
"0.6760859"... | 0.62219507 | 71 |
Delete the subtree with node as subroot. | def delete_subtree(self, subroot: 'GraphNode'):
self.operator.delete_subtree(subroot) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_root(self, node):\n current = node\n successor = self.find_successor(current) \n temp_height = current.height\n current.height = successor.height\n successor.height = temp_height\n\n if successor != None:\n self.root = successor\n parent = ... | [
"0.75925773",
"0.7480435",
"0.7424216",
"0.71247655",
"0.70918965",
"0.70537895",
"0.6969854",
"0.6895656",
"0.68567795",
"0.682668",
"0.67609817",
"0.66893965",
"0.66813046",
"0.6672785",
"0.667115",
"0.66323125",
"0.6606388",
"0.6594874",
"0.6567626",
"0.6545911",
"0.652475... | 0.8428926 | 0 |
compute the style factor ret | def get_factor_ret(date,date_lag):
ret = get_ret(date_lag)
cap = get_cap(date)
style_factor = get_barra_factor_from_sql(date)
data_all = pd.concat([ret,cap,style_factor],axis = 1,join = 'inner')
X = pd.DataFrame(data_all.iloc[:,2:])
X = sm.add_constant(X)
wls_model = sm.WLS(pd.DataFrame(data... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def css(self):\n return (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / \\\n ((self.table[0, 0] + self.table[0, 1]) * (self.table[1, 0] + self.table[1, 1]))",
"def get_style_loss(curr_style,target_style):\n height,width,channels = curr_style.get_shape().as_li... | [
"0.6677056",
"0.5938655",
"0.5827328",
"0.5765011",
"0.5739071",
"0.56346804",
"0.54632366",
"0.54539573",
"0.53806096",
"0.53754634",
"0.5356752",
"0.5328772",
"0.5323262",
"0.5297223",
"0.5296184",
"0.5294494",
"0.5294494",
"0.5257359",
"0.52487844",
"0.52442724",
"0.523510... | 0.0 | -1 |
compute the style factor's ret, use WLS regression | def factor_ret(self):
factor_ret_all = pd.DataFrame([])
for i in range(len(self.trade_date) - self.timelog):
date = self.trade_date.iloc[i,0]
date_lag = self.trade_date.iloc[i + self.timelog,0]
factor_ret = get_factor_ret(date,date_lag)
factor_ret_all = p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WLS(store):\n calcweighted(store)\n store['regsampler'].update_yvec(store['yvectil'])\n store['regsampler'].update_xmat(store['xmattil'])\n return store['regsampler'].sample()",
"def get_factor_ret(date,date_lag):\n ret = get_ret(date_lag)\n cap = get_cap(date)\n style_factor = get_barra... | [
"0.6541837",
"0.6528602",
"0.6300997",
"0.5896583",
"0.5835056",
"0.58338577",
"0.5816256",
"0.5798426",
"0.5788605",
"0.5721435",
"0.57168084",
"0.5705413",
"0.56867045",
"0.56772465",
"0.5673809",
"0.5667356",
"0.56673163",
"0.56629777",
"0.5637043",
"0.56341547",
"0.560991... | 0.0 | -1 |
compute the hs300 and zz500 weekly exposure on style factors | def factor_exposure(self):
exp_hs_all = pd.DataFrame([])
exp_zz_all = pd.DataFrame([])
for i in range(len(self.weekly_date)):
date = self.weekly_date.iloc[i,0]
factor = get_barra_factor_from_sql(date)
factor['secID'] = factor.index.tolist()
stockli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exposure():\n def r(x):\n return x/6e4\n\n def w(x):\n return int(x*6e4)\n return r, w",
"def get_weight(ew1, ew2):\n dw = flu.delta_epiweeks(ew1, ew2)\n yr = 52.2\n hl1, hl2, bw = yr, 1, 4\n a = 0.05\n #b = (np.cos(2 * np.pi * (dw / yr)) + ... | [
"0.61604285",
"0.56509274",
"0.55025834",
"0.53923845",
"0.53762066",
"0.5370133",
"0.5294281",
"0.52752477",
"0.5265615",
"0.520303",
"0.5171824",
"0.51513815",
"0.5132893",
"0.5092595",
"0.5088409",
"0.5087371",
"0.50813",
"0.5065104",
"0.50638103",
"0.5060144",
"0.50426376... | 0.5779782 | 1 |
r""" Run black on the current source tree (all ``.py`` files). | def blacken(
c, line_length=79, folders=None, check=False, diff=False, find_opts=None
):
config = c.config.get("blacken", {})
default_folders = ["."]
configured_folders = config.get("folders", default_folders)
folders = folders or configured_folders
default_find_opts = ""
configured_find_op... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blacken(session):\n session.install(DEPS[\"black\"])\n check_black = get_path(\"scripts\", \"blacken_all_files.py\")\n session.run(\"python\", check_black)",
"def black(context):\n exec_cmd = \"black --check --diff .\"\n run_cmd(context, exec_cmd)",
"def test_black(self):\n chdir(REPO... | [
"0.733671",
"0.7141421",
"0.6959907",
"0.6956898",
"0.68009764",
"0.6798593",
"0.6255054",
"0.5877577",
"0.5772148",
"0.5749536",
"0.5534074",
"0.54764223",
"0.54479384",
"0.53870153",
"0.5380241",
"0.5284122",
"0.52231586",
"0.5213798",
"0.51873237",
"0.5178605",
"0.5165765"... | 0.5832402 | 8 |
Run all common formatters/linters for the project. | def all_(c):
# TODO: contextmanager config, if we don't already have that
c.config.run.echo = True
blacken(c)
lint(c) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commands_all():\n lint()\n complexity()\n coverage()",
"def run(self):\n check_paths = PACKAGES + [\n 'setup.py',\n 'tests',\n 'util',\n ]\n ignore = [\n 'doc/',\n ]\n\n # try to install missing dependencies a... | [
"0.6045163",
"0.59757775",
"0.5945999",
"0.5914624",
"0.58727103",
"0.5807249",
"0.57904285",
"0.5688181",
"0.5572407",
"0.5500889",
"0.54245555",
"0.5423646",
"0.5422726",
"0.539087",
"0.53885156",
"0.5384772",
"0.5380067",
"0.5378278",
"0.5339264",
"0.53275114",
"0.53085154... | 0.5965984 | 2 |
Read taxonomy nodes.dmp file into pandas DataFrame | def read_nodes_dmp(fname):
df = pd.read_csv(fname, sep="|", header=None, index_col=False,
names=['tax_id',
'parent_tax_id',
'rank',
'embl_code',
'division_id',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_node_file(self):\n self.node_df = gt.remove_colons(pd.read_csv(self.node_file, dtype=str))",
"def nodes_df_creation(self, path: str) -> pyspark.sql.dataframe.DataFrame:\n try:\n nodes_df = self.spark.read.parquet(path)\n except OSError:\n print('cannot open', ... | [
"0.6789381",
"0.6212274",
"0.615097",
"0.6114801",
"0.6108535",
"0.5889607",
"0.5821102",
"0.58102983",
"0.57548654",
"0.56308955",
"0.5610583",
"0.56097096",
"0.5609186",
"0.55935985",
"0.5593163",
"0.5582398",
"0.55768555",
"0.55726385",
"0.55648285",
"0.55583286",
"0.55448... | 0.78661364 | 0 |
Read taxonomy names.dmp file into pandas DataFrame | def read_names_dmp(fname):
df = pd.read_csv(fname, sep="|", header=None, index_col=False,
names=["tax_id",
"name_txt",
"unique_name",
"name_class"])
return df.assign(name_txt = lambda x: x['name_txt'].str.strip(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_nodes_dmp(fname):\n df = pd.read_csv(fname, sep=\"|\", header=None, index_col=False,\n names=['tax_id', \n 'parent_tax_id',\n 'rank', \n 'embl_code',\n 'division_id', \n ... | [
"0.68054324",
"0.5834878",
"0.5798597",
"0.5793068",
"0.57881135",
"0.57818484",
"0.5780603",
"0.5767426",
"0.5762671",
"0.5683659",
"0.5658958",
"0.5644294",
"0.56357336",
"0.557491",
"0.55712473",
"0.55641025",
"0.55571115",
"0.5556157",
"0.5546592",
"0.55335677",
"0.550611... | 0.7467837 | 0 |
args one or more file names containing descriptor code kwargs a dict containing a mapping between descriptor filename extensions and actual paths to the definition files in the future this could be replaced with the preloaded context for the extension but this is easiest for now | def vidl(*args, **kwargs):
loadstring = ''
#now read the file definitions
for file in args:
ext = os.path.splitext(file)[1][1:] # get the extension without the dot
if ext == 'ddf':
loadstring += open(file).read()
continue
elif ext == 'rdf':
continu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_file_args(self):\n spec = {\n 'input': [\n '$[[codeFile]]'\n ]\n }\n parameters = pd.create_parameter_index([\n {\n 'id': 'codeFile',\n 'datatype': 'file',\n 'defaultValue': 'src/helloworld.py... | [
"0.5796783",
"0.55400974",
"0.5462255",
"0.5362446",
"0.5343054",
"0.5336746",
"0.53364706",
"0.5328841",
"0.5306926",
"0.5260287",
"0.5257919",
"0.5232348",
"0.5188024",
"0.51780456",
"0.51419365",
"0.5123478",
"0.5110492",
"0.50916123",
"0.5067574",
"0.5067574",
"0.50532025... | 0.5347166 | 4 |
This does the ranking of whether the Patient is a match/possible/No | def categorize_distances(row):
category_name = ""
try:
distance_value = row["dist"]
value = float(distance_value)
if value == 0.000000:
category_name = "Match"
elif 0.000001 <= value <= 0.1:
category_name = "Possible Match"
elif value > 0.1:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def arsenalResults(dat):\n arsScore = int(dat[0])\n othScore = int(dat[2])\n if arsScore > othScore:\n res = 1\n elif arsScore == othScore:\n res = 2\n else:\n res = 0\n return res",
"def recip_rank(recs, truth):\n good = recs['item'].isin(truth.index)\n npz, = np.non... | [
"0.58622277",
"0.5766292",
"0.5724738",
"0.5672559",
"0.56332046",
"0.5531462",
"0.5514099",
"0.5505791",
"0.55048496",
"0.54982716",
"0.5472145",
"0.54713345",
"0.54514253",
"0.5431467",
"0.5430985",
"0.541267",
"0.5409298",
"0.53975964",
"0.53651744",
"0.5355841",
"0.535556... | 0.0 | -1 |
Checks authorization of a rule against the target in this context. This function is not to be called directly. Calling the function with a target that evaluates to None may result in policy bypass. Use 'authorize_on_' calls instead. | def __authorize(context, rule, target=None):
target = target or {'tenant': context.tenant}
return get_enforcer().authorize(
rule, target, context.to_dict(), do_raise=True,
exc=trove_exceptions.PolicyNotAuthorized, action=rule) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wrap_check_policy(func):\n @functools.wraps(func)\n def wrapped(self, context, target_obj, *args, **kwargs):\n check_policy(context, func.__name__, target_obj)\n return func(self, context, target_obj, *args, **kwargs)\n\n return wrapped",
"def authorization_rule(self) -> Optional[pulum... | [
"0.59729636",
"0.58791226",
"0.57168037",
"0.56584775",
"0.55937326",
"0.5568693",
"0.55458856",
"0.55406976",
"0.5506479",
"0.550026",
"0.5477174",
"0.5477174",
"0.5420243",
"0.53873324",
"0.5317387",
"0.5297428",
"0.5296398",
"0.52627957",
"0.52248955",
"0.5222644",
"0.5208... | 0.7202618 | 0 |
'To assume as true in the absence of proof to the contrary.' Returns a modified transaction with this value set if the value of the item is not already known. If a value has already been fetched or presumed, this will be a noop. If modified, the presumed value will be available via `get`, and will additionally check yo... | def presume(
transaction: VersionedTransaction,
table: TableNameOrResource,
item_key: ItemKey,
item_value: Optional[Item],
) -> VersionedTransaction:
if item_value is not None:
for key_attr, key_val in item_key.items():
assert item_value[key_attr] == key_val, "Item key must match... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_batch_get_lazy_load():\n t = VersionedTransaction(dict())\n table_a = ItemTable(\"a\")\n table_b = ItemTable(\"b\")\n\n a1_k = dict(id=\"a1\")\n a2_k = dict(id=\"a2\")\n b1_k = dict(id=\"b1\")\n\n a3_k = dict(id=\"a3\")\n\n def triple_get(t: VersionedTransaction) -> VersionedTransa... | [
"0.5932803",
"0.5802937",
"0.5779788",
"0.5756236",
"0.5724148",
"0.56774515",
"0.5541173",
"0.55110294",
"0.5491138",
"0.5489476",
"0.53459036",
"0.5339431",
"0.5324479",
"0.52662617",
"0.522534",
"0.5209724",
"0.520189",
"0.51962876",
"0.5192975",
"0.51924634",
"0.5159292",... | 0.6724734 | 0 |
Idempotent definition of key attribute schema for the given table without forcing any IO operations/effects up front. The main reason you might want to do this is if you need to do a `put`, because `put` cannot infer the shape of your key. If the table definition is already present, this is a noop. | def define_table(
transaction: VersionedTransaction, table: TableNameOrResource, *key_attributes: str,
) -> VersionedTransaction:
assert len(key_attributes) > 0 and len(key_attributes) <= 2
if _table_name(table) in transaction.tables:
return transaction
return VersionedTransaction(
table... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_table_schema(table_desc, table_name, schema):\n table_desc['TableName'] = table_name\n table_desc['AttributeDefinitions'] = [{\n 'AttributeName': item['name'],\n 'AttributeType': DynamoStubber._encode_type(item['type'])\n } for item in schema]\n ... | [
"0.60570586",
"0.5902038",
"0.5678898",
"0.5671591",
"0.5581425",
"0.55520034",
"0.5543876",
"0.55083936",
"0.53274363",
"0.53022087",
"0.52965194",
"0.5224999",
"0.52233547",
"0.5223007",
"0.5222796",
"0.52002573",
"0.51673585",
"0.5139907",
"0.5126423",
"0.51261",
"0.511605... | 0.6186573 | 0 |
Given a relpath like drake/pkg/res.txt or external/repo/pkg/res.txt, find the data file and return its path | def find_data(relpath):
# Because we are in a py_binary, Bazel's wrapper script sets up our
# $PYTHONPATH to have our resources somewhere on a sys.path entry.
for one_path in sys.path:
possible = os.path.join(one_path, relpath)
if os.path.exists(possible):
return possible
rai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_path(data_path):\n\treturn os.path.dirname(os.path.realpath(__file__)) + os.sep + data_path",
"def get_data_file(f):\n if os.path.isfile(f):\n path = f\n\n else:\n p = pkg_resources.resource_filename('PaSDqc', \"db/{}\".format(f))\n \n if os.path.isfile(p):\n ... | [
"0.71274626",
"0.6904814",
"0.6769969",
"0.6497312",
"0.6490332",
"0.6470966",
"0.64500815",
"0.64413446",
"0.64217675",
"0.6399083",
"0.63932604",
"0.63386345",
"0.6311808",
"0.62965494",
"0.62960714",
"0.6275206",
"0.62670004",
"0.62568855",
"0.62269145",
"0.62260854",
"0.6... | 0.7789457 | 0 |
convert kitti points(N, >=3) to voxels. This version calculate everything in one loop. now it takes only 4.2ms(complete point cloud) with jit and 3.2ghz cpu.(don't calculate other features) | def points_to_voxel_plus(
points,
voxel_size,
coors_range,
max_points=35,
reverse_index=True,
max_voxels=20000,
):
if not isinstance(voxel_size, np.ndarray):
voxel_size = np.array(voxel_size, dtype=points.dtype)
if not isinstance(coors_range, np.ndarra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def voxelize(self, points):\n voxels, coors, num_points = [], [], []\n for res in points:\n res_voxels, res_coors, res_num_points = self.pts_voxel_layer(res)\n voxels.append(res_voxels)\n coors.append(res_coors)\n num_points.append(res_num_points)\n ... | [
"0.6589704",
"0.65418935",
"0.654082",
"0.6479842",
"0.6015914",
"0.6004015",
"0.5937598",
"0.5853999",
"0.58375835",
"0.5777515",
"0.5760727",
"0.5734398",
"0.5712557",
"0.5698626",
"0.56847566",
"0.5652651",
"0.5626064",
"0.56038326",
"0.5576575",
"0.5576291",
"0.5574701",
... | 0.50797534 | 81 |
Create simple routes and then register api blueprints. | def register_blueprints(app):
@app.route('/')
def hello():
return '<html><body>{{ cookiecutter.project_name }} - Hello World</body></html>'
@app.route('/healthz')
def healthz():
{% if cookiecutter.use_sqlalchemy == 'True' %}
"""
Verify the DB is there.
:return: ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_routes(api: Api):\n api.add_resource(SignUpApi, '/user/signup/')\n api.add_resource(LoginApi, '/user/login/')\n\n api.add_resource(UsersApi, '/users/')\n\n api.add_resource(CafeteriasCreationAPI, '/createcafeteria/')\n api.add_resource(CreateItemsAPI, '/createcafeteriaitems/')",
"def in... | [
"0.80723184",
"0.7742963",
"0.75816625",
"0.750119",
"0.7224631",
"0.7081037",
"0.705355",
"0.702835",
"0.6989628",
"0.69582707",
"0.6948669",
"0.692166",
"0.68536395",
"0.6782817",
"0.6780066",
"0.6779047",
"0.6709916",
"0.6695856",
"0.6689925",
"0.66680044",
"0.6630894",
... | 0.63309956 | 33 |
Build a userinput_listener coroutine. | def user_input_listener(state: SharedState): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _listen(self):\n users = fileIO.load_json(\"users.json\")\n print(\"The list of users is: \")\n for i in users:\n print(users[i][\"name\"])\n name = False\n while not name: #Loop until valid user given\n name = input(\"Please enter the user that you woul... | [
"0.60229254",
"0.5902512",
"0.5665694",
"0.5660546",
"0.5540109",
"0.552596",
"0.55182016",
"0.5446837",
"0.54210794",
"0.53281254",
"0.53130955",
"0.5302447",
"0.52767766",
"0.52541715",
"0.5171928",
"0.51666707",
"0.5162627",
"0.51598024",
"0.51451725",
"0.5137769",
"0.5034... | 0.74263144 | 0 |
Build a websocket stream coroutine for every symbol. | def candle_producers(state: SharedState, manager: BinanceSocketManager): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def open_websocket_server(sock, filter=None): # pylint: disable=W0622\n ws = await create_websocket_server(sock, filter=filter)\n try:\n yield ws\n finally:\n await ws.close()",
"def connect(self):\n self.wss.start()\n while not self.wss.conn.connected.is_set():\n ... | [
"0.5675283",
"0.5632832",
"0.5602713",
"0.5536626",
"0.55332685",
"0.54705304",
"0.5417256",
"0.5412137",
"0.5374019",
"0.5361107",
"0.5324008",
"0.52814776",
"0.5270162",
"0.5264434",
"0.5173382",
"0.5166334",
"0.5157106",
"0.5140275",
"0.51327926",
"0.51196957",
"0.51107293... | 0.4692814 | 66 |
Build one coroutine that downloads candle history for each symbol and time interval. | def historical_candle_producer(state: SharedState, client: AsyncClient): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def fetch_history(stock, start, end):\n disable_stdout()\n with timer(logtime(\"ts.get_h_data('%s', autype=None, start='%s', end='%s', drop_factor=False)\" % (stock, start, end))):\n df = await wait_concurrent(event_loop, proc_pool, ts.get_h_data, stock, autype=None, start=start, end=end, drop_f... | [
"0.62406814",
"0.6226014",
"0.619598",
"0.6178408",
"0.6124466",
"0.6044843",
"0.59872854",
"0.5895894",
"0.5866143",
"0.5864519",
"0.58620954",
"0.58356297",
"0.5758476",
"0.57579523",
"0.5756885",
"0.5747019",
"0.57367694",
"0.5733668",
"0.5694192",
"0.56894606",
"0.5677922... | 0.55126107 | 28 |
Build a fake websocket stream coroutine for every symbol. | def mock_candle_producers(state: SharedState): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def open_websocket_server(sock, filter=None): # pylint: disable=W0622\n ws = await create_websocket_server(sock, filter=filter)\n try:\n yield ws\n finally:\n await ws.close()",
"async def setup_ws_stream_coros(app):\n\n app[\"ws_stream_coro\"] = set()",
"def websocket_serv... | [
"0.622791",
"0.5865622",
"0.58078146",
"0.56601346",
"0.5592847",
"0.5521169",
"0.5491376",
"0.54190344",
"0.54174733",
"0.53975993",
"0.5363104",
"0.5340883",
"0.5321347",
"0.5300425",
"0.52969384",
"0.5278497",
"0.5272565",
"0.52193433",
"0.5187779",
"0.51829916",
"0.516728... | 0.0 | -1 |
Build one coroutine that handles all messages and sends them to their corresponding pipelines. | def consumer(state: SharedState): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dispatch_messages(self):\n while True:\n select_obj = (yield)\n if select_obj == self._message_queue.selobj:\n msg = self._message_queue.get_nowait()\n if msg is not None:\n msg_type = msg.get('type', None)\n if m... | [
"0.6499672",
"0.5979923",
"0.5959593",
"0.5840355",
"0.5830399",
"0.5809362",
"0.57409644",
"0.57242227",
"0.56772774",
"0.5677117",
"0.56234056",
"0.5620072",
"0.55886537",
"0.55492806",
"0.5539985",
"0.5526545",
"0.5525597",
"0.550391",
"0.54963815",
"0.54895586",
"0.548119... | 0.0 | -1 |
Returns a list of selected coroutines. | def build() -> List[asyncio.Task]: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run_coroutines(self, coros):\n return self._loop.run_until_complete(asyncio.gather(*coros, loop=self._loop))",
"def select_clients(self, my_round, num_clients=20):\n samples_futures = []\n for cs in self.client_servers:\n samples_future = cs.select_clients.remote(my_round, nu... | [
"0.58138645",
"0.57921916",
"0.5500767",
"0.5427553",
"0.52810246",
"0.523673",
"0.5232737",
"0.51655847",
"0.50899875",
"0.5058168",
"0.5043694",
"0.5025866",
"0.49998668",
"0.4987699",
"0.49808943",
"0.4948969",
"0.4917828",
"0.48906115",
"0.48799387",
"0.48627067",
"0.4851... | 0.45013225 | 74 |
Returns length of longest increasing subsequence given an array of numbers. | def longestIncreasingSubsequence(nums):
if not nums:
return 0
dp = [None] * len(nums)
dp[0] = 1
maxans = 1
for i in range(1, len(dp)):
maxval = 0
for j in range(0, i):
if nums[i] > nums[j]:
maxval = max(maxval, dp[j])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_length_of_longest_sub_array(l):\n if len(l) < 1:\n return 0\n\n longest_seen_sequence = 0\n\n this_sequence_length = 1\n\n previous = l[0]\n\n for _, current in enumerate(l):\n\n if current > previous:\n this_sequence_length = this_seq... | [
"0.7756621",
"0.7332605",
"0.6925975",
"0.68926334",
"0.6865751",
"0.68350095",
"0.66415817",
"0.6594408",
"0.65523106",
"0.6539818",
"0.65185964",
"0.6484091",
"0.64561516",
"0.64262223",
"0.6355707",
"0.62699634",
"0.6269051",
"0.62369823",
"0.6226302",
"0.6150499",
"0.6116... | 0.7476641 | 1 |
Raise DuplicateAction exception if this intent is a duplicate Concrete actions can override this method and call self.raise_duplicate_action() if they find that this intent should be discarded as (near) duplicate of an already stored action | def check_duplicate(self, state):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testduplicate(self):\n self.assertTrue(AmuletAbility('Control Dragon').duplicate(\n AmuletAbility('Control Dragon')))\n self.assertFalse(AmuletAbility('Control Dragon').duplicate(\n AmuletAbility('Control NPC')))\n self.assertTrue(AmuletAbilit... | [
"0.5758249",
"0.5727997",
"0.5709236",
"0.5676586",
"0.55160147",
"0.5503697",
"0.5438317",
"0.5433323",
"0.53957826",
"0.5377086",
"0.5372131",
"0.53480536",
"0.52793163",
"0.5243134",
"0.5236685",
"0.5235135",
"0.523479",
"0.52295125",
"0.52072746",
"0.5196021",
"0.51959985... | 0.5613794 | 4 |
Create an Action from this intent, filling missing data from state | def at(self, state):
self.complete_data(state)
self.check_duplicate(state)
action = entities.Action(
action_id=new_id(state),
type=self.get_type_name(),
data=pmap(self.data),
time=state.context.time,
randomness=state.context.randomness,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _formulate_action(Action, **kwargs):\n\n return Action(**kwargs)",
"def action(self, action_id):\r\n return Action(self, action_id)",
"def action(self, action_id):\r\n return Action(self, action_id)",
"def from_of_action(cls, of_action):\n return cls()",
"def create_action(insta... | [
"0.63214076",
"0.6280206",
"0.6280206",
"0.6092075",
"0.60566056",
"0.5983633",
"0.5972293",
"0.59379184",
"0.58593243",
"0.58537024",
"0.5842147",
"0.5834748",
"0.5764666",
"0.5716841",
"0.5701877",
"0.5692661",
"0.5685065",
"0.56532115",
"0.5642375",
"0.56263447",
"0.561336... | 0.72059274 | 0 |
Match the calibSources and sources, and propagate Interesting Flags (e.g. PSF star) to the sources | def propagateCalibFlags(keysToCopy, calibSources, sources, matchRadius=1):
if calibSources is None or sources is None:
return
closest = False # return all matched objects
matched = afwTable.matchRaDec(calibSources, sources, matchRadius*afwGeom.arcseconds, closest)
#
# Becaus... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sources_extraction(image,sextractor_pars):\n\n cat_name, detect_minarea, detect_thresh, analysis_thresh, phot_aperture, satur_level, ZP, gain, pixelScale,seeing,back_type,back_value,back_size,backphoto_type,backphoto_thick,back_filterthresh,checkimage_type,checkimage_name= sextractor_pars\n sp.run('sex %s.... | [
"0.56265473",
"0.55381423",
"0.55253875",
"0.5407288",
"0.53591067",
"0.53485554",
"0.53367805",
"0.5311908",
"0.5266865",
"0.52260643",
"0.5216051",
"0.5157914",
"0.5119476",
"0.507221",
"0.5060244",
"0.50464916",
"0.5040846",
"0.50221545",
"0.50190264",
"0.5007729",
"0.5004... | 0.69685996 | 0 |
Parse the command line arguments. | def main():
parser = argparse.ArgumentParser()
parser.add_argument("host", type=str, nargs="+")
parser.add_argument("--user", type=str, default=getpass.getuser())
parser.add_argument("--path", type=str, required=True)
parser.add_argument("--keep", type=int, default=3)
parser.add_argument("--depl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n de... | [
"0.81931424",
"0.75572526",
"0.7554",
"0.7513019",
"0.751122",
"0.73971534",
"0.7371605",
"0.73673505",
"0.72861725",
"0.7245646",
"0.72365344",
"0.7233457",
"0.7223075",
"0.7216988",
"0.7214747",
"0.7208797",
"0.72051626",
"0.7194125",
"0.7173979",
"0.71704656",
"0.7168313",... | 0.0 | -1 |
Checks that the Drakecreated flavor of nlopt.cpp (via a patch file) is consistent with the upstreamgenerated flavor of same (via CMake). If this test fails during an NLopt version pin upgrade, you will need to update patches/gen_enums.patch with the reported differences. | def test_enum_cross_check(self):
# Load both input files.
# "actual" refers to the the Drake-created flavor (via a patch file).
# "expected" refers to the upstream-generated flavor (via CMake).
manifest = runfiles.Create()
actual_file = manifest.Rlocation(
"nlopt_inte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self, expected):\n versions = ['3.0', '4.0', '5.0', '6.0', '7.0', '8.0']\n modes = ['strict', 'normal', 'ignore']\n\n for version in versions:\n for mode in modes:\n assert self.get(app_version=version, compat_mode=mode) == (\n expected['-... | [
"0.56607723",
"0.5562484",
"0.54389495",
"0.5402845",
"0.53964126",
"0.5389693",
"0.53053814",
"0.5245198",
"0.523824",
"0.5220819",
"0.5130013",
"0.50907856",
"0.5084268",
"0.507624",
"0.50242937",
"0.5022775",
"0.5013908",
"0.5011498",
"0.50096434",
"0.49897176",
"0.4972365... | 0.6848094 | 0 |
Evaluate the given distribution function in the point(s) (r, ppar, pperp). Use the vector 'v' to specify the parameters of this distribution function. | def Eval(self, r, ppar, pperp, v, gamma=None, p2=None, p=None, xi=None):
while False:
yield None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _p_v_at_r(self, v, r):\n if hasattr(self, \"_logfQ_interp\"):\n return (\n numpy.exp(\n self._logfQ_interp(\n -_evaluatePotentials(self._pot, r, 0) - 0.5 * v**2.0\n )\n )\n * v**2.0\n ... | [
"0.66941005",
"0.6040724",
"0.5935693",
"0.5931339",
"0.5931324",
"0.5880862",
"0.5767878",
"0.5735554",
"0.56684875",
"0.5650999",
"0.5604907",
"0.5558572",
"0.5557449",
"0.5551832",
"0.55289036",
"0.55191976",
"0.5493359",
"0.54931647",
"0.54723114",
"0.5459315",
"0.5458212... | 0.6704118 | 0 |
Preprocess the input vector to give it a shape appropriate for generating the distribution | def PreprocessInputVector(self, v, n, nparams):
l = v.size
if l % nparams is not 0:
smutil.error("AvalancheDistributionFunction: Input vector has invalid format: length is not a multiple of "+str(nparams)+" (number of parameters in model).")
# Number of radial points in interface gr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalizeVector(v):\n normalizer = 1.0 / sum(v)\n\n normalized = [i * normalizer for i in v]\n return normalized",
"def normalize(vec):\n return vec / length(vec)",
"def get_normalized_vector(vector):\n # WARN: Zero length may cause problems!\n vector_lenght = get_vector_length(vector)\n ... | [
"0.630594",
"0.6298658",
"0.60276604",
"0.6004589",
"0.5926612",
"0.58883804",
"0.5880402",
"0.5858213",
"0.5854227",
"0.58155197",
"0.57243234",
"0.57066524",
"0.5685303",
"0.56719977",
"0.56702715",
"0.56669194",
"0.56142706",
"0.56082267",
"0.5602667",
"0.55900484",
"0.554... | 0.601182 | 3 |
Calculate phase cross correlation (pcc) between signal and wavelet foreach signal in seismic For this purpose wavelet is shifted in time and compared to corresponding portion in each signals | def xcorr(seismic_signal, wavelet, **kwargs):
# if seismic signal is a trace object, we pack it to a stream
if isinstance(seismic_signal, _tr.Trace):
sources = _st.Stream([seismic_signal])
else:
sources = seismic_signal
if not isinstance(sources, _st.Stream):
raise TypeError('s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PLV_Coh(X,Y,TW,fs):\n X = X.squeeze()\n ntaps = 2*TW - 1\n dpss = sp.signal.windows.dpss(X.size,TW,ntaps)\n N = int(2**np.ceil(np.log2(X.size)))\n f = np.arange(0,N)*fs/N\n PLV_taps = np.zeros([N,ntaps])\n Coh_taps = np.zeros([N,ntaps])\n Phase_taps = np.zeros([N,ntaps])\n for k in r... | [
"0.6411508",
"0.6399294",
"0.63741624",
"0.63008296",
"0.61233366",
"0.6064643",
"0.605886",
"0.6058215",
"0.6025654",
"0.60073525",
"0.59338397",
"0.59186095",
"0.5901491",
"0.58867425",
"0.5868824",
"0.57322395",
"0.56866455",
"0.566528",
"0.5639549",
"0.5631151",
"0.562609... | 0.0 | -1 |
Calculate phase autocorrelation for each signal in seismic_stream | def acorr(seismic_signal, **kwargs):
# if seismic signal is a trace object, we pack it to a stream
if isinstance(seismic_signal, _tr.Trace):
sources = _st.Stream([seismic_signal])
else:
sources = seismic_signal
if not isinstance(sources, _st.Stream):
raise TypeError('seismic_str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def step_autocorrelation(self):\n\n max_hops = max([len(x) for x in self.steps])\n\n self.acf = np.zeros([len(self.steps), max_hops])\n\n keep = [] # list to hold indices of trajectories with a non-zero amount of hops\n for i in range(len(self.steps)):\n hops = self.steps[i]... | [
"0.6106281",
"0.5915008",
"0.5743236",
"0.56838435",
"0.56832486",
"0.5655305",
"0.56056494",
"0.55680525",
"0.5545803",
"0.55240375",
"0.55095017",
"0.54883564",
"0.54883564",
"0.5412182",
"0.5382874",
"0.5338562",
"0.5338562",
"0.52966046",
"0.5273439",
"0.52382296",
"0.520... | 0.5928678 | 1 |
Calculate phase cross correlation (pcc) between signal1 and signal2 For this purpose signal2 is shifted in time and compared to corresponding portion in signal1 | def _xcorr_trace(signal1, signal2, **kwargs):
kwargs['mode'] = 'pcc'
kwargs['lags'] = __default_lags_if_not_set(signal1, signal2, **kwargs)
pcc_signal = phasecorr.xcorr(signal1.data, signal2.data, **kwargs)
trace = _tr.Trace(data=pcc_signal)
__writeheader(trace, signal1, **kwargs)
return tra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cphase(h1, h2):\n\n for h in (h1, h2):\n h.assert_ket_space()\n\n field = h1.base_field\n\n d = h1.dim()\n if h2.dim() != d:\n raise HilbertError('spaces must be of the same dimension')\n\n ret = (h1*h2).O.array()\n for (j, a) in enumerate(h1.index_iter()):\n for (k, b) i... | [
"0.66017336",
"0.6389433",
"0.61255634",
"0.6099715",
"0.6079657",
"0.6045117",
"0.59957165",
"0.5968298",
"0.5967114",
"0.59037614",
"0.5879406",
"0.5871049",
"0.5862538",
"0.585481",
"0.58367324",
"0.57887626",
"0.57637984",
"0.5761343",
"0.5755311",
"0.5738161",
"0.573262"... | 0.69613063 | 0 |
Calculate phase auto correlation (pac) of signal1 For this purpose a shifted copy in time of signal1 is compared to corresponding portion in signal1 | def _acorr_trace(signal1, **kwargs):
kwargs['mode'] = 'pac'
kwargs['lags'] = __default_lags_if_not_set(signal1, signal1, **kwargs)
pac_signal = phasecorr.acorr(signal1.data, **kwargs)
trace = _tr.Trace(data=pac_signal)
__writeheader(trace, signal1, **kwargs)
return trace | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def constract(phase, magnitude):\n new_spectrum = magnitude * np.exp(1j * phase)\n\n # reverse the shift and FFT\n f_ishift = np.fft.ifftshift(new_spectrum)\n img_back = np.fft.ifft2(f_ishift)\n \n return np.abs(img_back)",
"def test_lag1Cor_Estimation(self):\n P = PSignal.PSignal(np.arange(10... | [
"0.59478575",
"0.5942706",
"0.58623695",
"0.58456415",
"0.58392256",
"0.5771846",
"0.57513154",
"0.57069325",
"0.5691568",
"0.569096",
"0.5653918",
"0.5615717",
"0.55893755",
"0.55863965",
"0.55757755",
"0.5560512",
"0.55482876",
"0.55477715",
"0.55407035",
"0.55402577",
"0.5... | 0.6709351 | 0 |
get random proxy from proxypool | def get_random_proxy():
url=requests.get(proxypool_url).text.strip()
#logger.info("now url is",url)
return url | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_random(self):\n return random.choice(self.proxies)",
"def get_proxy_pool(self,proxy_pool,num):\n\n url='{url}/proxy/?num={num}'.format(url=config.SERVER_URL,num=num)\n\n try:\n res=request.urlopen(url,timeout=5).read()\n res=str(res,encoding='utf8')\n exc... | [
"0.7766926",
"0.7258919",
"0.72230166",
"0.70320004",
"0.6830322",
"0.67573696",
"0.6513024",
"0.64002264",
"0.63306606",
"0.6161731",
"0.60935825",
"0.6068532",
"0.59971714",
"0.5855311",
"0.584551",
"0.58218956",
"0.57690114",
"0.574567",
"0.5730094",
"0.5697484",
"0.569187... | 0.8399079 | 0 |
use proxy to crawl page | def crawl(url):
while True:
try:
proxy=get_random_proxy()
proxies = {'http': 'http://' + proxy}
logger.info(proxies)
resp = requests.get(url, proxies=proxies,timeout=3) # 设置代理，抓取每个公司的连接
resp.encoding = resp.apparent_encoding # 可以正确解码
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n if self.is_full():\n return\n for crawler in self.crawlers:\n logger.info(f'crawler {crawler} to get proxy')\n proxies = crawler.run()\n if proxies:\n for proxy in proxies:\n self.redis.add(proxy)\n ... | [
"0.6656336",
"0.6540788",
"0.6506942",
"0.65062267",
"0.6483475",
"0.6374295",
"0.6259475",
"0.6233891",
"0.6208135",
"0.61101043",
"0.609967",
"0.60954505",
"0.6091064",
"0.605424",
"0.6050282",
"0.60383075",
"0.6023799",
"0.59682155",
"0.5963611",
"0.59390926",
"0.59319854"... | 0.69973946 | 0 |
main method, entry point | def main():
proxy = get_random_proxy()
html = crawl(target_url)
company_all_url = html.xpath('//*[@id="quotesearch"]/ul/li/a/@href')
code=['none']*len(company_all_url)
for i in range(len(company_all_url)):
s = str(str(company_all_url[i]))
code[i]=s[(len(s) - 13):(len(s) - 5)]
sav... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main():",
"def main(... | [
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006",
"0.88615006"... | 0.0 | -1 |
Checks if given position is empty ("") in the board. | def _position_is_empty_in_board(position, board):
return board[position[0]][position[1]] == "-" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_empty_space(board, position1):\n return board[position1] == \" \"",
"def emptyAt(self, position):\n\n #check for any sprites at the position\n for key in self.sprites:\n s = self.sprites[key]\n if s.position == position and s.visible: #not visible means it isn't taking up t... | [
"0.79477996",
"0.788795",
"0.7743375",
"0.7719691",
"0.76447976",
"0.74391013",
"0.74310374",
"0.7350126",
"0.7295014",
"0.71880174",
"0.71601164",
"0.7151122",
"0.7118377",
"0.7117768",
"0.7107725",
"0.71016866",
"0.7068392",
"0.7039862",
"0.6971793",
"0.6948898",
"0.6942450... | 0.89006466 | 0 |
Checks if given position is a valid. To consider a position as valid, it must be a twoelements tuple, containing values from 0 to 2. | def _position_is_valid(position):
# Make sure that...
# position is a tuple
# position's length is 2
# every value in the tuple is an int
# every int in the tuple is either 0, 1 or 2
# if not, return False
if not isinstance(position, tuple) \
or len(position) != 2 \... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_valid_position_tuple(pos):\n try: chrom, start_pos, end_pos, strand = pos\n except (TypeError, ValueError): raise MutantError(\"Didn't get a correct position tuple! %s\"%pos)\n if strand not in SEQ_STRANDS: raise MutantError(\"Invalid strand %s!\"%strand)... | [
"0.76978976",
"0.7626505",
"0.7124657",
"0.70859355",
"0.6977404",
"0.69307876",
"0.685049",
"0.6840817",
"0.67205507",
"0.6672402",
"0.66398543",
"0.66194904",
"0.6600491",
"0.6599175",
"0.6573275",
"0.65055704",
"0.6466658",
"0.6444392",
"0.6436828",
"0.63908213",
"0.635216... | 0.84633476 | 0 |
Returns True if all positions in given board are occupied. | def _board_is_full(board):
# looks for "-" in every position in the board
# returns False if it finds one
for row in board:
if any(column for column in row if column == "-"):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_board_full(board):\n return not any(0 in val for val in board)",
"def _check_occupied(self, col, row):\n if self.board[row - 1][col - 1] == EMPTY:\n return False\n else:\n return True",
"def is_board_full(self):\n for position in self.positions:\n ... | [
"0.74002767",
"0.7333643",
"0.7305194",
"0.72547317",
"0.7221987",
"0.72074044",
"0.715917",
"0.71400607",
"0.7111857",
"0.7029353",
"0.70200616",
"0.6994772",
"0.6989892",
"0.698797",
"0.69771594",
"0.69702905",
"0.69275504",
"0.69254285",
"0.689183",
"0.68875754",
"0.687192... | 0.701698 | 11 |
Checks if all 3 positions in given combination are occupied by given player. | def _is_winning_combination(board, combination, player):
"""
### Code before refactoring into a comprehension list:
for a_tuple in combination:
# e.g. a_tuple = (0,0)
# if board[0][0] != "X"
if board[a_tuple[0]][a_tuple[1]] != player:
return False
"""
if any(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_winning_combinations(board, player):\n winning_combinations = (\n ((0, 0), (0, 1), (0, 2)),\n ((1, 0), (1, 1), (1, 2)),\n ((2, 0), (2, 1), (2, 2)),\n ((0, 0), (1, 0), (2, 0)),\n ((0, 1), (1, 1), (2, 1)),\n ((0, 2), (1, 2), (2, 2)),\n ((0, 0), (1, 1), (... | [
"0.7056445",
"0.6785087",
"0.6513575",
"0.6407896",
"0.63359",
"0.6332282",
"0.6314953",
"0.62546915",
"0.62414443",
"0.6239754",
"0.6238734",
"0.61814517",
"0.6174631",
"0.6169825",
"0.61628115",
"0.6144622",
"0.61050117",
"0.60615724",
"0.60549986",
"0.6050816",
"0.60260415... | 0.72803354 | 0 |
There are 8 posible combinations (3 horizontals, 3, verticals and 2 diagonals) to win the Tictactoe game. This helper loops through all these combinations and checks if any of them belongs to the given player. | def _check_winning_combinations(board, player):
winning_combinations = (
((0, 0), (0, 1), (0, 2)),
((1, 0), (1, 1), (1, 2)),
((2, 0), (2, 1), (2, 2)),
((0, 0), (1, 0), (2, 0)),
((0, 1), (1, 1), (2, 1)),
((0, 2), (1, 2), (2, 2)),
((0, 0), (1, 1), (2, 2)),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_winning_combination(board, combination, player):\n\n \"\"\"\n ### Code before refactoring into a comprehension list:\n\n for a_tuple in combination:\n\n # e.g. a_tuple = (0,0)\n # if board[0][0] != \"X\"\n if board[a_tuple[0]][a_tuple[1]] != player:\n\n return False... | [
"0.71583956",
"0.70575804",
"0.7002491",
"0.6714407",
"0.669649",
"0.66591203",
"0.66099006",
"0.6589296",
"0.6558027",
"0.6533149",
"0.6491051",
"0.6489824",
"0.644219",
"0.6395233",
"0.6353411",
"0.63451284",
"0.6342977",
"0.6325276",
"0.62973696",
"0.6287886",
"0.6280949",... | 0.76965 | 0 |
Creates and returns a new game configuration. | def start_new_game(player1, player2):
return {
'player1': "X",
'player2': "O",
'board': [
["-", "-", "-"],
["-", "-", "-"],
["-", "-", "-"],
],
'next_turn': "X",
'winner': None
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_new_game(game_config):\n _type = game_config[\"game_type\"]\n if _type == \"hex\":\n game = Hex(game_config[\"hex\"], verbose=game_config[\"verbose\"])\n else:\n raise ValueError(\"Game type is not supported\")\n return game",
"def create_config(self) -> None:\n pass",
... | [
"0.6866214",
"0.6441648",
"0.6441648",
"0.62015563",
"0.6154281",
"0.6075715",
"0.5959731",
"0.59504825",
"0.588382",
"0.58830607",
"0.58786094",
"0.58786094",
"0.58771557",
"0.586809",
"0.5866608",
"0.57652086",
"0.5752994",
"0.5737094",
"0.5673671",
"0.5668067",
"0.5663768"... | 0.0 | -1 |
Returns the winner player if any, or None otherwise. | def get_winner(game):
return game['winner'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def winner(self):\n # Credit to Dariusz Walczak for inspiration.\n # http://stackoverflow.com/questions/1720421/merge-two-lists-in-python\n moves = [p.possible_moves(p.pieces, self) for p in self.players]\n if False in [mv == [] for mv in moves]:\n return (\"None\")\n ... | [
"0.79259926",
"0.7767767",
"0.77578986",
"0.76471484",
"0.76094395",
"0.7577104",
"0.7522824",
"0.74686444",
"0.7463236",
"0.74358934",
"0.7395176",
"0.73575616",
"0.73575616",
"0.7349675",
"0.7327973",
"0.7324711",
"0.7274085",
"0.7265994",
"0.72104675",
"0.71895385",
"0.706... | 0.70658773 | 21 |
Performs a player movement in the game. Must ensure all the pre requisites checks before the actual movement is done. After registering the movement it must check if the game is over. | def move(game, player, position):
# Is the board full? Or do we already have a winner? Then game is over.
if _board_is_full(game['board']) or game['winner'] != None:
raise InvalidMovement('Game is over.')
# if the next player is not the one who should make the move
if not get_next_turn(game) =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def try_move_player(self):\n player = self.player\n if player.direction == 'U':\n next_position = (player.position[0], player.position[1] - 1)\n elif player.direction == 'D':\n next_position = (player.position[0], player.position[1] + 1)\n elif player.direction == ... | [
"0.69746006",
"0.6750943",
"0.6730142",
"0.66434145",
"0.6624069",
"0.66014683",
"0.6598992",
"0.65845567",
"0.6582338",
"0.6566751",
"0.65254796",
"0.6504708",
"0.6499943",
"0.6482451",
"0.6433244",
"0.64278674",
"0.6408127",
"0.64079386",
"0.639623",
"0.6323653",
"0.6275745... | 0.61105865 | 32 |
Returns a string representation of the game board in the current state. | def get_board_as_string(game):
str_board = "\n" # every board starts with a blank line
row = 0 # used to print the board
# creates a board of 5 lines. 3 rows, 2 dashed.
for line in range(1, 6):
# every odd line
if line % 2 != 0:
# add a row to the string str_board
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_board_state_pretty(self):\n\n board_state = ''\n for i in range(0, 3):\n board_state += ' | '.join([self.board['{}{}'.format(i, j)] for j in range(0, 3)])\n board_state += '\\n'\n return board_state",
"def board_string(self):\n s = \"\"\n for i, v ... | [
"0.8295647",
"0.82778364",
"0.82208264",
"0.8033392",
"0.79234034",
"0.791434",
"0.78864056",
"0.7875186",
"0.78537625",
"0.78222716",
"0.7806988",
"0.778111",
"0.7743911",
"0.7685247",
"0.7682562",
"0.7667545",
"0.76609117",
"0.7657479",
"0.7643367",
"0.7634906",
"0.7624794"... | 0.71689326 | 49 |
Returns the player who plays next, or None if the game is already over. | def get_next_turn(game):
return game['next_turn'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_player(self, player):\r\n return player * -1",
"def get_next_player(self, player):\r\n return player * -1",
"def get_next_player(current_player: Optional[str]) -> str:\n if current_player == c.X:\n return c.O\n else:\n return c.X",
"def next_player(board, prev_p... | [
"0.76222545",
"0.76222545",
"0.75664425",
"0.74821323",
"0.73752886",
"0.73482656",
"0.7283921",
"0.72544986",
"0.72476065",
"0.71792877",
"0.7154323",
"0.71080816",
"0.7093113",
"0.7084624",
"0.70579547",
"0.7050713",
"0.70100635",
"0.70100635",
"0.6991924",
"0.6985718",
"0.... | 0.0 | -1 |
Look in the current directory and then each parent until root. | def find_in_parent_dir(fname):
p = os.path.abspath(os.path.curdir)
while not os.path.exists(os.path.join(p, project_conf_name)):
oldp, p = p, os.path.dirname(p)
if p == oldp:
return None
return open(os.path.join(p, project_conf_name), 'r') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _walk_to_root(path):\n if not os.path.exists(path):\n raise IOError('Starting path not found')\n\n if os.path.isfile(path):\n path = os.path.dirname(path)\n\n last_dir = None\n current_dir = os.path.abspath(path)\n while last_dir != current_dir:\n yield current_dir\n ... | [
"0.7434952",
"0.71153444",
"0.69121534",
"0.6693403",
"0.65015477",
"0.64132035",
"0.63960505",
"0.6387505",
"0.623293",
"0.6227715",
"0.62218225",
"0.6208172",
"0.61608905",
"0.6140065",
"0.6102608",
"0.6067385",
"0.60380626",
"0.6005215",
"0.5958163",
"0.5939146",
"0.593403... | 0.5471526 | 69 |
Used to extract information about our dataset. It does iterate over all images and return a DataFrame with the data (age, gender and sex) of all files. | def parse_dataset(dataset_path, ext='jpg'):
def parse_info_from_file(path):
"""
Parse information from a single file
"""
try:
filename = os.path.split(path)[1]
filename = os.path.splitext(filename)[0]
age, gender, race, _ = filename.split('_')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_dataset() -> Tuple[pd.DataFrame, Dict]:\n\n data_dir = Path.cwd()/\"freiburg_grocery_images\"\n labels = [directory.name for directory in data_dir.iterdir()]\n label_map = {label: i for i, label in enumerate(labels)}\n\n all_items = [str(file) for label in labels for file in (data_dir/label... | [
"0.6953958",
"0.69098717",
"0.68971664",
"0.68201923",
"0.64545614",
"0.6400425",
"0.6322264",
"0.6270314",
"0.61469066",
"0.6143167",
"0.61304915",
"0.6126947",
"0.6060151",
"0.60446715",
"0.60239255",
"0.6021422",
"0.6001422",
"0.5997284",
"0.5975618",
"0.59695774",
"0.5934... | 0.592172 | 22 |
Parse information from a single file | def parse_info_from_file(path):
try:
filename = os.path.split(path)[1]
filename = os.path.splitext(filename)[0]
age, gender, race, _ = filename.split('_')
return int(age), dataset_dict['gender_id'][int(gender)], dataset_dict['race_id'][int(race)]
except E... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, infile):\r\n raise NotImplementedError()",
"def _parse(self, infile):\n raise NotImplementedError()",
"def _parse_file(cls, filepath):\n hdus = sunpy.io.read_file(filepath)\n return cls._parse_hdus(hdus)",
"def parse_data(fp):\n pass",
"def parse_file(self, file):... | [
"0.7360086",
"0.72870433",
"0.7046545",
"0.7038436",
"0.69900817",
"0.6958809",
"0.684544",
"0.6791917",
"0.67794955",
"0.6685041",
"0.66544765",
"0.661106",
"0.6580625",
"0.65276223",
"0.65232867",
"0.6515129",
"0.6504125",
"0.6483635",
"0.6483133",
"0.6455571",
"0.6450634",... | 0.68785435 | 6 |
Used to perform some minor preprocessing on the image before inputting into the network. | def preprocess_image(self, img_path):
im = Image.open(img_path)
im = im.resize((IM_WIDTH, IM_HEIGHT))
im = np.array(im) / 255.0
return im | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self, img):\n img_ = image.load_img(img, target_size=(299, 299))\n img_ = image.img_to_array(img_)\n img_ = np.expand_dims(img_, axis=0)\n img_ = preprocess_input(img_)\n return img_",
"def _preprocessing(self, input_image):\n if self.resize:\n ... | [
"0.76596355",
"0.7428046",
"0.7330726",
"0.73097295",
"0.7233228",
"0.72189915",
"0.72014105",
"0.7197177",
"0.7121413",
"0.71081626",
"0.70633936",
"0.70560926",
"0.7039367",
"0.7033568",
"0.7023033",
"0.70055234",
"0.698125",
"0.6977507",
"0.69203556",
"0.68990195",
"0.6893... | 0.6308844 | 100 |
Used to generate a batch with images when training/testing/validating our Keras model. | def generate_images(self, image_idx, is_training, batch_size=16):
# arrays to store our batched data
images, ages, races, genders = [], [], [], []
while True:
for idx in image_idx:
person = self.df.iloc[idx]
age = person['age'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_batch(model, batch_size, test_data=False):\n if model == 'cnn':\n as_image = True\n else:\n as_image = False\n\n image = _read_images(test_data=test_data, as_image=as_image)\n label = _read_labels(test_data=test_data)\n\n images_batch, labels_batch = tf.train.batch([image, label],\n ... | [
"0.75774246",
"0.74922997",
"0.74519485",
"0.73910856",
"0.7325273",
"0.71627367",
"0.71103084",
"0.7077549",
"0.7029831",
"0.70131713",
"0.70102745",
"0.6954216",
"0.6947352",
"0.6941008",
"0.69298536",
"0.69187367",
"0.69123995",
"0.6905738",
"0.6889662",
"0.6868008",
"0.68... | 0.72434276 | 5 |
Used to build the race branch of our face recognition network. This branch is composed of three Conv > BN > Pool > Dropout blocks, followed by the Dense output layer. | def build_race_branch(self, inputs, num_races):
x = self.make_default_hidden_layers(inputs)
x = Flatten()(x)
x = Dense(128)(x)
x = Activation("relu")(x)
x = BatchNormalization()(x)
x = Dropout(0.5)(x)
x = Dense(num_races)(x)
x = Activation("softmax", name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_bisenet(inputs, num_classes):\n\n ### The spatial path\n ### The number of feature maps for each convolution is not specified in the paper\n ### It was chosen here to be equal to the number of feature maps of a classification\n ### model at each corresponding stage\n # spatial_net = fl... | [
"0.69784904",
"0.6751553",
"0.673756",
"0.66934335",
"0.667088",
"0.6633901",
"0.6607632",
"0.65503025",
"0.65443754",
"0.65243477",
"0.65239656",
"0.65187544",
"0.6490053",
"0.6459417",
"0.6453328",
"0.6452226",
"0.643148",
"0.6430326",
"0.6419869",
"0.6396226",
"0.63870144"... | 0.612305 | 60 |
Used to build the gender branch of our face recognition network. This branch is composed of three Conv > BN > Pool > Dropout blocks, followed by the Dense output layer. | def build_gender_branch(self, inputs, num_genders=2):
x = Lambda(lambda c: tf.image.rgb_to_grayscale(c))(inputs)
x = self.make_default_hidden_layers(inputs)
x = Flatten()(x)
x = Dense(128)(x)
x = Activation("relu")(x)
x = BatchNormalization()(x)
x = Dropout(0.5)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_discriminator(self):\n img_shape = (self.img_size[0], self.img_size[1], self.channels)\n\n model = Sequential()\n ###############\n # Conv Stack 1:\n ###############\n model.add(\n Conv2D(128, kernel_size=5, strides=2, input_shape=img_shape, padding=\"... | [
"0.66957885",
"0.66077316",
"0.63622165",
"0.6342879",
"0.633063",
"0.6302211",
"0.6302211",
"0.62979877",
"0.6269781",
"0.62534744",
"0.623655",
"0.62052697",
"0.61675453",
"0.61575735",
"0.61488783",
"0.61291873",
"0.61201566",
"0.61011446",
"0.60958564",
"0.6083565",
"0.60... | 0.7864113 | 0 |
Used to build the age branch of our face recognition network. This branch is composed of three Conv > BN > Pool > Dropout blocks, followed by the Dense output layer. | def build_age_branch(self, inputs):
x = self.make_default_hidden_layers(inputs)
x = Flatten()(x)
x = Dense(128)(x)
x = Activation("relu")(x)
x = BatchNormalization()(x)
x = Dropout(0.5)(x)
x = Dense(1)(x)
x = Activation("linear", name="age_output")(x)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def discriminator_block(in_filters, out_filters):\n layers = [ nn.Conv2d(in_filters, out_filters, 4, stride=2, padding=1),\n nn.LeakyReLU(0.01)]\n return layers",
"def build_bisenet(inputs, num_classes):\n\n ### The spatial path\n ### The number of feature maps for each... | [
"0.6322069",
"0.62509495",
"0.6210222",
"0.6205929",
"0.61850744",
"0.6165662",
"0.61332285",
"0.6119399",
"0.6096222",
"0.60777825",
"0.6053835",
"0.60508585",
"0.60431457",
"0.6030179",
"0.60178214",
"0.6007941",
"0.5995195",
"0.5962688",
"0.59607214",
"0.59575105",
"0.5951... | 0.7157092 | 0 |
Used to assemble our multioutput model CNN. | def assemble_full_model(self, width, height, num_races):
input_shape = (height, width, 3)
inputs = Input(shape=input_shape)
age_branch = self.build_age_branch(inputs)
race_branch = self.build_race_branch(inputs, num_races)
gender_branch = self.build_gender_branch(inputs)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model(input_classes,output_classes):\n dimensions = 20\n inputs = []\n embedded_outputs = []\n for i in input_classes:\n input_layer = Input((1,))\n inputs.append(input_layer)\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=Un... | [
"0.67610925",
"0.6492056",
"0.6454665",
"0.644587",
"0.6413437",
"0.6320915",
"0.62863666",
"0.6275258",
"0.6252421",
"0.6248297",
"0.6241189",
"0.6237258",
"0.6234287",
"0.615311",
"0.6143814",
"0.61404675",
"0.6138519",
"0.61306256",
"0.6123763",
"0.6122863",
"0.61180544",
... | 0.0 | -1 |
Computer perimeter for the rectangle | def perimRect(length, width):
return 2 * (length + width) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perimeter(self):",
"def perimeter(self):\n\t\treturn 2 * (self.width + self.height)",
"def calculateperimeter(self):\r\n return (self.width * 2) + (self.height * 2)",
"def perimeter(self):\r\n return (2*self.width) + (2*self.height)",
"def perimeter(self):\n return 2 * (self.height... | [
"0.8430252",
"0.83806247",
"0.83072674",
"0.8281285",
"0.8204777",
"0.81401604",
"0.805963",
"0.7651174",
"0.74341273",
"0.7422448",
"0.73345184",
"0.72595495",
"0.721846",
"0.7185834",
"0.7158701",
"0.7130895",
"0.7089875",
"0.70687634",
"0.70687634",
"0.6887997",
"0.6867396... | 0.6235728 | 87 |
Compute area for the rectangle | def areaRect(length, width):
return length * width | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rect_area(rect):\n return rect[2] * rect[3]",
"def area_rect(w, h):\n return w * h",
"def _area(bounds):\n return (bounds[0, 1] - bounds[0, 0]) * (bounds[1, 1] - bounds[1, 0])",
"def area(self):\n num_rows = self.row_end - self.row_start\n num_cols = self.col_end - self.col_start\n... | [
"0.8253932",
"0.8153468",
"0.8056531",
"0.80223805",
"0.79693747",
"0.79442996",
"0.7873636",
"0.7872711",
"0.78698665",
"0.786057",
"0.784172",
"0.7819327",
"0.7814251",
"0.7764691",
"0.7752274",
"0.77518463",
"0.7743629",
"0.77320397",
"0.77025086",
"0.77025086",
"0.7702508... | 0.77284664 | 18 |
Global variables available in all templates | def global_variables(request):
data = {
'DEBUG': settings.DEBUG,
}
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def global_variables():\n item_catalog_app.jinja_env.globals[\"ALL_CATEGORIES\"] = act.all_categories()\n __logged_in_user__ = act.user(\n pointer=login_session.get(\"user_id\")\n )\n item_catalog_app.jinja_env.globals[\"USER\"] = __logged_in_user__\n g.USER = __logged_in_user__",
"def inje... | [
"0.73522717",
"0.70804507",
"0.6623835",
"0.6614453",
"0.6387393",
"0.6256472",
"0.61475796",
"0.61302704",
"0.6017198",
"0.5988722",
"0.5954301",
"0.5932908",
"0.5932745",
"0.5928411",
"0.59138465",
"0.58811116",
"0.58521664",
"0.58481276",
"0.5838821",
"0.5833165",
"0.57925... | 0.6709685 | 2 |
raise WinproxyError if result is 0 | def fail_on_zero(func_name, result, func, args):
if not result:
raise WinproxyError(func_name)
return args | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def winhttp_WinHttpFreeProxyResult(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"pProxyResult\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)",
"def winhttp_WinHttpGetProxyResult(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hResolver\", \"... | [
"0.68406665",
"0.63366336",
"0.6020998",
"0.6016139",
"0.58826256",
"0.5877293",
"0.5857276",
"0.582949",
"0.57794017",
"0.5773708",
"0.57534397",
"0.56958175",
"0.5652606",
"0.5602097",
"0.5585624",
"0.5577021",
"0.55100924",
"0.5496161",
"0.54908186",
"0.5478192",
"0.542409... | 0.721989 | 0 |
Function called when extension is loaded. | def setup(bot):
bot.logger.debug(
'Registering extension "Quiz"'
)
bot.add_cog(QuizCog(bot)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_load(self):\n pass",
"def on_load(self):\n pass",
"def init_extensions(self, package, module):\n\n pass",
"def on_load(self):",
"def on_startup(self) -> None:\n ...",
"def on_load(self):\n self.__init__()",
"def __init_on_load__(self):",
"def test_load(self):\n ... | [
"0.73872864",
"0.73872864",
"0.7158644",
"0.6950948",
"0.6821005",
"0.6776726",
"0.67198926",
"0.66803163",
"0.66501784",
"0.6643111",
"0.657011",
"0.6525896",
"0.6503312",
"0.6479751",
"0.6448623",
"0.64208615",
"0.6371902",
"0.6362281",
"0.63427466",
"0.63366205",
"0.632070... | 0.0 | -1 |
Function called when extension is unloaded. | def teardown(bot):
bot.logger.debug(
'Removing extension "Quiz"'
)
bot.get_cog('Quiz').save_traking_data()
bot.remove_cog(bot.get_cog('Quiz')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unloaded():\n pass",
"def on_unload(self):\n pass",
"def unload_plugin(self):\n pass",
"async def unload(self, ctx, *, extension: str):\r\n self.bot.unload_extension(extension)\r\n await ctx.send(f\":ok_hand: Unloaded module `{extension}`\")",
"async def unload(self) -> N... | [
"0.78926325",
"0.7739239",
"0.7379189",
"0.7115593",
"0.6993464",
"0.68589085",
"0.6789264",
"0.677395",
"0.6731156",
"0.66316205",
"0.6624827",
"0.66196173",
"0.6605904",
"0.6605904",
"0.6562715",
"0.6562715",
"0.6562715",
"0.656185",
"0.65453285",
"0.6543707",
"0.6531165",
... | 0.6474187 | 24 |
Setup local flowables database with flows that require special handling. Also loads the flowables file. When overriding this function, place the super() call between preload and postload activities. | def _configure_flowables(self, flowables):
if flowables is None:
flowables = DEFAULT_FLOWABLES
# FlowablesDict-- mainly to upsample CAS numbers for matching
self._fm = FlowablesDict()
self._fm.new_entry('carbon dioxide', '124-38-9')
self._fm.new_entry('Water', '7732... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(cls):\n super().setup()\n cls.db = DBCommunication()",
"def _pre_setup(self):\n apps.clear_cache()\n call_command('migrate', interactive=False, verbosity=0)\n call_command('loaddata', 'initial_data', verbosity=0)\n super(DatatableViewTestCase, self)._pre_setup(... | [
"0.6175916",
"0.6035001",
"0.5991969",
"0.5970857",
"0.58654773",
"0.58605886",
"0.5847241",
"0.5826606",
"0.5805958",
"0.57829595",
"0.5778072",
"0.575451",
"0.56998646",
"0.56855494",
"0.56470186",
"0.56340146",
"0.5630023",
"0.56250453",
"0.5624165",
"0.5621802",
"0.562054... | 0.5878006 | 4 |
LciaEngine.__getitem__ retrieves a canonical context by more intensively searching for matches from a given context. Adds foreign context's full name as synonym if one is affirmatively found. If one is not found, returns the NullContext. None is returned as None, to represent 'unspecified' (i.e. accept all) as opposed ... | def __getitem__(self, item):
if item is None:
return None
try:
return self._cm.__getitem__(item)
except KeyError:
if isinstance(item, Context):
return self._cm.find_matching_context(item)
elif isinstance(item, tuple) and len(item) >... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __dis_context__(self, context, word):\n senses = self.vs.get_senses(word, self.ignore_case)\n if self.verbose:\n print(\"Senses of a target word:\")\n print(senses)\n\n if len(senses) == 0: # means we don't know any sense for this word\n return None\n\n ... | [
"0.57803524",
"0.52267176",
"0.5220787",
"0.52120763",
"0.5174642",
"0.5164446",
"0.5149356",
"0.5041184",
"0.49859065",
"0.49716657",
"0.49243554",
"0.49187955",
"0.49112827",
"0.4855967",
"0.48273122",
"0.4817933",
"0.47763702",
"0.47615644",
"0.4757728",
"0.47567716",
"0.4... | 0.6447261 | 0 |
This function was created because we don't want TermManagers getting confused about things like misassigned CAS numbers, because they don't have the capacity to store multiple CFs. So we will save the full synonym list for the LciaEngine. | def _flow_terms(flow):
return flow.synonyms | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill_stempool(self):\n tokens = [apply_word_tokenize(x) for x in self.df['name']]\n\n flatten1 = itertools.chain.from_iterable\n flat = list(flatten1(tokens))\n\n stems = [self.stemmer.stem(x) for x in flat]\n\n return set(stems)",
"def nsrSynonyms():\r\n # Input file\r\... | [
"0.57324946",
"0.5650351",
"0.554946",
"0.5542705",
"0.5465308",
"0.54454356",
"0.5441436",
"0.53831476",
"0.5370351",
"0.5335252",
"0.5318396",
"0.5302473",
"0.5295376",
"0.5264259",
"0.52387655",
"0.5215229",
"0.5215099",
"0.5204873",
"0.5161386",
"0.51540685",
"0.513916",
... | 0.52873546 | 13 |
Harvest biogenic co2 synonyms (not worth correcting for other biogenic substances??) | def _add_to_existing_flowable(self, fb, new_terms):
biog = ('124-38-9' in fb)
for term in new_terms:
self._fm.add_synonym(fb, term)
if biog and bool(biogenic.search(term)):
self._bio_co2.add_term(term) # ensure that bio term is a biogenic synonym | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nsrSynonyms():\r\n # Input file\r\n synonymsFile = pd.read_csv(args.indir+\"/\"+args.infile2, header=2,\r\n sep=\"\\t\", encoding=\"utf8\")\r\n\r\n # Parse taxonomic names into their elementary components\r\n synonyms = synonymsFile.loc[synonymsFile['language'] == 'Sci... | [
"0.6278373",
"0.6064663",
"0.6054872",
"0.6007341",
"0.6002883",
"0.59069574",
"0.5802612",
"0.58015925",
"0.57863915",
"0.57196033",
"0.56676126",
"0.5618402",
"0.5598366",
"0.55523103",
"0.5539704",
"0.55314595",
"0.55285823",
"0.5485978",
"0.5470576",
"0.5457307",
"0.54489... | 0.0 | -1 |
Here we are not picky about having duplicate quantities | def add_quantity(self, quantity):
if quantity.entity_type != 'quantity':
raise TypeError('Must be quantity type')
if quantity.link not in self._qm:
self._qm.add_quantity(quantity)
assert quantity.link in self._qm
return self._canonical_q(quantity) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_items_quantity_not_duplicates(request):\n all_items_no_duplicates = []\n\n for loop_index, item in enumerate(all_shopping_items(request)):\n item_dict = {\n 'item': item.item,\n 'quantity': item.quantity,\n 'category': item.category.category,\n 'id':... | [
"0.5703828",
"0.57010126",
"0.5693255",
"0.55881643",
"0.5587493",
"0.5551469",
"0.5545252",
"0.55120176",
"0.54732245",
"0.54649097",
"0.5460169",
"0.5428315",
"0.5425589",
"0.5398626",
"0.53612894",
"0.5330958",
"0.5326141",
"0.5314214",
"0.5252058",
"0.52479565",
"0.523333... | 0.0 | -1 |
Absorb second into child of first. Currently does not support remapping entries, so import_cfs(second) needs to be run again. Old factors will be left in so _fq_map still works. | def merge_quantities(self, first, second):
dom = self.get_canonical(first)
add = self.get_canonical(second)
self._qm.merge(dom, add)
self.import_cfs(second) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map2(self, f, pt):\n logger.debug('[START] PID[%s] map2 skeleton', PID)\n assert self.__distribution == pt.distribution\n content = SList([None] * self.__content.length())\n for i in range(len(self.__global_index[self.__start_index: self.__start_index +\n ... | [
"0.49451524",
"0.48374847",
"0.4816826",
"0.47681516",
"0.47121134",
"0.46719477",
"0.46434382",
"0.4612929",
"0.45820156",
"0.45763972",
"0.4503654",
"0.45029733",
"0.44901878",
"0.44694677",
"0.44611233",
"0.44572702",
"0.4405865",
"0.4381707",
"0.43751577",
"0.43663976",
"... | 0.41888988 | 43 |
For LciaEngines, we use the default behavior of ContextManager which is to first try 'attach', then fallback to 'rename' | def _add_compartments(self, comps):
return self._cm.add_compartments(comps) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_context(name, ctx=None):\n if ctx is None:\n ctx = builtins.__xonsh__.ctx\n modctx = xontrib_context(name)\n if modctx is None:\n if not hasattr(update_context, \"bad_imports\"):\n update_context.bad_imports = []\n update_context.bad_imports.append(name)\n ... | [
"0.5382174",
"0.52348757",
"0.5089552",
"0.4976699",
"0.4921123",
"0.4909736",
"0.4871767",
"0.48032677",
"0.47282645",
"0.47134584",
"0.46923074",
"0.46920326",
"0.46766403",
"0.46594715",
"0.4586809",
"0.45746368",
"0.456511",
"0.45414543",
"0.45359203",
"0.45268455",
"0.45... | 0.0 | -1 |
Given a quantity, import its CFs into the local database. Unfortunately this is still going to be slow because every part of the CF still needs to be canonicalized. The only thing that's saved is creating a new Characterization instance. | def import_cfs(self, quantity):
try:
qq = self._canonical_q(quantity)
except KeyError:
qq = self.add_quantity(quantity)
count = 0
for cf in quantity.factors():
count += 1
# print(cf)
try:
fb = self._fm[cf.flowab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_counties():\n\n query = 'INSERT INTO texas_counties(county, region) VALUES(%s,%s)'\n with persistence() as db:\n # create new cursor instance\n cursor = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\n\n for council, counties in COUNCIL_DATA.items():\n for... | [
"0.54053676",
"0.5345252",
"0.5009659",
"0.49099687",
"0.47605696",
"0.4740605",
"0.4696015",
"0.46920276",
"0.46907184",
"0.46507764",
"0.46204922",
"0.46030006",
"0.45985758",
"0.45907193",
"0.45657995",
"0.4537645",
"0.45328835",
"0.45299235",
"0.45244938",
"0.45229474",
"... | 0.7534431 | 0 |
Assigns the cf to the mapping; does subclassspecific collision checking | def _store_cf(cl, context, new_cf):
try:
cl.add(new_cf, key=context)
except TypeError:
print(type(cl))
raise | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collision(self):\n raise NotImplementedError",
"def applyMapping(self):\n pass",
"def setupCollisions(self):\n\t\tbase.cTrav = CollisionTraverser()\n\t\tself.cHandler = CollisionHandlerEvent()\n\t\t#self.cHandler.setInPattern('%fn-sped-up')\n\t\t\n\t\tcQuad = CollisionPolygon(Point3(0, 0, 0),... | [
"0.5515978",
"0.53430635",
"0.52271914",
"0.522315",
"0.5207508",
"0.519834",
"0.5172758",
"0.5147812",
"0.5145852",
"0.51225555",
"0.5114735",
"0.50724304",
"0.50228596",
"0.50203246",
"0.49639764",
"0.49526194",
"0.4949708",
"0.4940785",
"0.49291757",
"0.49172798",
"0.49058... | 0.46996704 | 46 |
Adds ability to filter by origin note this is exclusive to the ability to filter by quantity | def flowables(self, search=None, origin=None, new=False, **kwargs):
if origin is None:
_iter = super(LciaEngine, self).flowables(search=search, **kwargs)
else:
if search is None:
_iter = self._fb_by_origin[origin]
else:
_iter = (str(x) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_restriction_filters(self):\n self.restriction_filters[\"pk__exact\"] = self.request.user.pk",
"def filter(self, *args, **kwargs):",
"def _custom_filter(self, query):\r\n return query",
"def filter_disputes_notes_grid(self, column_name, filter_item):\n self.grid_filter_with_textbo... | [
"0.59470046",
"0.56179065",
"0.5568572",
"0.55291736",
"0.55232686",
"0.550949",
"0.5477399",
"0.5416927",
"0.53570306",
"0.5337462",
"0.5325544",
"0.524886",
"0.52306837",
"0.52302957",
"0.5215678",
"0.52031213",
"0.5201506",
"0.51735073",
"0.51728815",
"0.51467144",
"0.5142... | 0.0 | -1 |
We assume that all biogenic CO2 flows will be detected via add_flow, and will have their names set to something | def _quell_co2(self, flowable, context):
if self._quell_biogenic is False:
return False
if flowable in self._bio_co2:
if context.is_subcompartment(self._cm['from air']):
return True
if context.is_subcompartment(self._cm['Emissions']):
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dup_pipeline_name_cfg(self):",
"def _configure_flowables(self, flowables):\n if flowables is None:\n flowables = DEFAULT_FLOWABLES\n\n # FlowablesDict-- mainly to upsample CAS numbers for matching\n self._fm = FlowablesDict()\n\n self._fm.new_entry('carbon dioxide', '1... | [
"0.58474296",
"0.569925",
"0.56435513",
"0.53014785",
"0.52610934",
"0.5227977",
"0.5182955",
"0.5182175",
"0.5170833",
"0.5162001",
"0.5134495",
"0.51231927",
"0.5099633",
"0.50600487",
"0.50040334",
"0.5002867",
"0.49885595",
"0.4968262",
"0.49279296",
"0.49234572",
"0.4919... | 0.0 | -1 |
detach lookup for cleanness. canonical everything | def _factors_for_flowable(self, fb, qq, cx, **kwargs):
self._check_factors(qq)
try:
cl = self._qlookup(qq, fb)
except NoFQEntry:
return
if cx is None:
for v in cl.cfs():
yield v
else:
for v in cl.find(cx, **kwargs):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def applyDemapping(self):\n pass",
"def cleanup():",
"def revise():",
"def cleanup(self):",
"def cleanup(self):",
"def cleanup(self):",
"def clean(_context):",
"def clean(c):",
"def horde_cleanup(self):",
"def _clean_up(self):",
"def cleanup(self):\n for residue in self.debumper.b... | [
"0.6569446",
"0.58934015",
"0.5845248",
"0.57096654",
"0.57096654",
"0.57096654",
"0.56681806",
"0.5656693",
"0.565422",
"0.56260526",
"0.5572836",
"0.5460176",
"0.54530233",
"0.54232705",
"0.5409617",
"0.540709",
"0.5392803",
"0.5388027",
"0.53739077",
"0.5367186",
"0.536718... | 0.0 | -1 |
Here we deal with water contexts specified as flowables by creating children this is generalizeable (vs for CO2) | def factors_for_flowable(self, flowable, quantity=None, context=None, **kwargs):
try:
fb = self._fm[flowable]
except KeyError:
return
''' # this does not do anything helpful
if fb == self._fm['Water']:
try:
context = self._cm['flow-%s'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def child_case():\n result = ObjectContainer()\n\n flow1 = Flow(\"flow1\")\n result.flow1 = flow1\n\n with flow1.add_container(\"container1\") as container1:\n result.container1 = container1\n with container1.add_task(\"task1\") as task1:\n result.task1 = task1\n with co... | [
"0.605448",
"0.5835285",
"0.57355165",
"0.57282794",
"0.56974614",
"0.5680976",
"0.56371605",
"0.5522915",
"0.54681087",
"0.5428466",
"0.54168093",
"0.5416636",
"0.5369338",
"0.5354371",
"0.53340364",
"0.5281433",
"0.5277179",
"0.52718735",
"0.52553463",
"0.5245438",
"0.52121... | 0.5138674 | 27 |
This function can sum any objects which have __add___ | def custom_sum(*args):
return functools.reduce(lambda x, y: x + y, args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __add__(self, other):\r\n return self.add(other)",
"def __add__(self, other):\n pass",
"def __add__(self, other):\n pass",
"def __add__(self, other):\n return self.add(other)",
"def add(obj):",
"def __add__(self, other):\n \"*** YOUR CODE HERE ***\"",
"def __add__... | [
"0.7702068",
"0.75945014",
"0.75945014",
"0.7573851",
"0.75017023",
"0.7357567",
"0.72784346",
"0.72784346",
"0.7203079",
"0.7149354",
"0.7149354",
"0.7116317",
"0.7116317",
"0.7116317",
"0.7116317",
"0.7116317",
"0.7116317",
"0.7116317",
"0.70699376",
"0.7068136",
"0.7054115... | 0.65717214 | 84 |
Test a model on an example | def infer(self, example, model):
asp_input = model + '\n\n' + example + '\n\n' + inference_program_ec
ctl = clingo.Control()
ctl.add("base", [], asp_input)
ctl.ground([("base", [])], context=self)
ctl.solve(on_model=self.show_model) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_model():\n pass",
"def test_example(self):\n self.assertEqual(self.example.get_example(), True)",
"def testModel( self, classTest, classPred):",
"def test_model_found(arguments):\n ...",
"def testGetReigsteredModel(self):\n from soc.models.student import Student\n model = mo... | [
"0.77361155",
"0.74117136",
"0.7402094",
"0.7367298",
"0.6964708",
"0.6916549",
"0.68771887",
"0.68725353",
"0.6861734",
"0.6753478",
"0.6733257",
"0.6683285",
"0.66675687",
"0.66135466",
"0.6555324",
"0.65510744",
"0.6531237",
"0.6518147",
"0.6501927",
"0.65007454",
"0.64869... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.