1 else h\n\n for i in range(2):\n h = Dense(128, W_constraint=WeightClip(), bias_constraint=WeightClip())(h)\n h = LeakyReLU()(h)\n\n # final output - single score value\n h = Dense(1, W_constraint=WeightClip(), bias_constraint=WeightClip())(h)\n\n self.model = Model(inputs=ip, outputs=h)\n return self","def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\n super().__init__(input_nodes, hidden_nodes, hidden_layers, output_nodes)","def buildNet(inputShape, numUniqueClasses):\n layers = InputLayer((None,) + inputShape[1:4])\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1))\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1), stride= (5,1))\n layers = ResidualLayer(layers, 8, \n filter_size = (3,1))\n layers = ResidualLayer(layers, 1, \n filter_size = (3,1), stride= (3,1))\n layers = NonlinearityLayer(layers, nonlinearity = nonlinearity)\n layers = DropoutLayer(layers,p=.3) \n layers = batch_norm(NNHelpers.LocallyConnected2DLayer(layers,1,(5,1),\n W=He('relu'),\n nonlinearity=nonlinearity)) \n layers = DenseLayer(layers,num_units=numUniqueClasses,\n nonlinearity=linear) \n layers = NonlinearityLayer(layers, nonlinearity=softmax) \n return layers","def __init__(self, session, input_size, seq_size, output_size, learning_rate, model_name, net_name):\n self.session = session\n self.input_size = input_size\n self.seq_size = seq_size\n self.output_size = output_size\n\n self.learning_rate = learning_rate\n self.net_name = net_name\n self.x = None\n self.model_name = model_name\n\n self._build_network()","def __init__(self, D_in, D_out, H, learning_rate):\n self.model = th.nn.Sequential(\n th.nn.Linear(D_in, H),\n th.nn.Tanh(),\n th.nn.Linear(H, D_out),\n ).double()\n\n for x in self.model.modules():\n if isinstance(x, th.nn.Linear):\n x.weight.data = th.normal(means=th.zeros(x.weight.size())).type(dtype)\n x.bias.data = th.zeros(x.bias.size()).type(dtype)\n\n self.H = H\n self.lr = learning_rate\n self.loss_fn = th.nn.MSELoss(size_average=False)","def create_model(self): # noqa: D103\n # reference for creation of the model https://yilundu.github.io/2016/12/24/Deep-Q-Learning-on-Space-Invaders.html\n model=Sequential()\n model.add(Flatten( input_shape=(84,84,4)))\n model.add(Dense(self.num_actions)) \n\n return model","def _generate_network_initialization(self, graph, memory_manager):\n\n # TODO: To be changed if we want to support multiple outputs\n output_buffer_name = graph.outputs[0].name\n\n ops_to_ignore = ['Reshape', 'Mul']\n\n buffers_allocated = []\n\n buffer_declaration = \"\"\n buffer_declaration += \" pico_cnn::naive::Tensor **kernels;\\n\"\n buffer_declaration += \" pico_cnn::naive::Tensor **biases;\\n\"\n\n constructor_code = \"\"\n #constructor_code += \"Network::Network() {\\n\\n\"\n\n num_layers = 0\n num_kernels = 0\n num_biases = 0\n\n for node in graph.nodes:\n \"\"\"Do not count the reshape layers as the input tensor will only define the dimensions\"\"\"\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n num_layers += 1\n for num, input in enumerate(node.input_tensors):\n if input in buffers_allocated:\n continue\n else:\n tensor = node.input_tensors[input]\n buffers_allocated.append(input)\n if len(tensor.shape) == 1:\n num_biases += 1\n else:\n num_kernels += 1\n\n \"\"\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\"\"\"\n constructor_code += \" kernels = new pico_cnn::naive::Tensor*[{}]();\\n\".format(num_kernels)\n constructor_code += \" biases = new pico_cnn::naive::Tensor*[{}]();\\n\\n\".format(num_biases)\n\n pos = -1\n pos_kernel = -1\n pos_bias = -1\n\n buffers_allocated.clear()\n\n \"\"\"Iterate over all nodes in the graph and generate the corresponding allocation code.\"\"\"\n for node_id, node in enumerate(graph.nodes):\n\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\n pos += 1\n\n buffer_declaration += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n constructor_code += \" // Layer: \" + node.name + \", Operation: \" + node.op_type + \"\\n\"\n\n # Allocate memory for kernels and biases\n buffer_declaration += \" // Inputs\\n\"\n constructor_code += \" // Inputs\\n\"\n for num, input in enumerate(node.input_tensors):\n\n if node.op_type in ops_to_ignore:\n continue\n\n if input in buffers_allocated:\n continue\n else:\n buffers_allocated.append(input)\n\n tensor = node.input_tensors[input]\n if len(tensor.shape) == 1:\n pos_bias += 1\n else:\n pos_kernel += 1\n\n buffer = memory_manager.get_buffer(graph, input)\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"KernelAllocation\")\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \" // Outputs\\n\"\n constructor_code += \" // Outputs\\n\"\n for num, output in enumerate(node.outputs):\n\n buffer = memory_manager.get_buffer(graph, output)\n\n if output == output_buffer_name:\n buffer_declaration += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n constructor_code += \" // Output tensor {} with shape {} of network provided as argument of Network::run()\".format(buffer.name, str(buffer.shape))\n continue\n\n buffer_declaration += \" // \" + str(buffer.shape) + \"\\n\"\n\n pico_cnn_tensor = \" pico_cnn::naive::Tensor *\"\n\n buffer_declaration += pico_cnn_tensor + buffer.name + \";\\n\"\n\n constructor_code += \" // \" + str(buffer.shape) + \"\" # TODO maybe we sometimes need \\n\n\n functionality = CodeRegistry.get_funct(\"OutputAllocation\")\n impl = functionality[0].create(buffer)\n\n if impl:\n constructor_code += impl.generate_code()\n constructor_code += \"\\n\"\n\n buffer_declaration += \"\\n\\n\"\n constructor_code += \"\\n\\n\"\n\n #constructor_code += \"}\\n\"\n\n self.buffer_declaration = buffer_declaration\n self.constructor_code = constructor_code","def __init__(self, state_dim, action_dim, learning_rate, weight_decay):\n self.dynamics_net = ForwardModel(state_dim, action_dim)\n self.rewards_net = RewardModel(state_dim, action_dim)\n self.done_net = RewardModel(state_dim, action_dim)\n\n self.dyn_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)\n self.reward_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)\n self.done_optimizer = tfa_optimizers.AdamW(\n learning_rate=learning_rate, weight_decay=weight_decay)","def initialise_network(self):\n raise NotImplementedError","def _build_model(self):\n if self.weight_function is None:\n self.weight_function = default_weight_function\n\n tf.reset_default_graph()\n\n # Placeholders for the inputs\n self.x0 = tf.placeholder(\n shape=[None, self.num_features],\n dtype=self.dtype,\n name=\"x0\"\n )\n self.x1 = tf.placeholder(\n shape=[None, self.num_features],\n dtype=self.dtype,\n name=\"x1\"\n )\n # Placeholder for the real classes\n self.y0 = tf.placeholder(\n shape=[None, 1],\n dtype=self.dtype,\n name=\"y0\"\n )\n # Placeholder for the weights\n self.w0 = tf.placeholder(\n shape=[None, ],\n dtype=self.dtype,\n name=\"w0\"\n )\n\n # Drop placeholder\n self.should_drop = tf.placeholder(tf.bool, name=\"drop\")\n\n # Regularization\n regularizer = tf.keras.regularizers.l2(self.weight_regularization)\n\n # Input_Dropout\n in0 = tf.layers.dropout(inputs=self.x0,\n rate=self.input_dropout,\n training=self.should_drop\n )\n\n in1 = tf.layers.dropout(inputs=self.x1,\n rate=self.input_dropout,\n training=self.should_drop\n )\n\n # Constructing the feature creation part of the net\n nn0 = tf.layers.dense(\n inputs=in0,\n units=self.hidden_layers[0],\n activation=self.feature_activation,\n use_bias=self.feature_bias,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_hidden_0\"\n )\n\n # By giving nn1 the same name as nn0 and using the flag reuse=True,\n # the weights and biases of all neurons in each branch are identical\n nn1 = tf.layers.dense(\n inputs=in1,\n units=self.hidden_layers[0],\n activation=self.feature_activation,\n use_bias=self.feature_bias,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_hidden_0\",\n reuse=True\n )\n\n # Layer Dropout\n nn0 = tf.layers.dropout(inputs=nn0,\n rate=self.dropout,\n training=self.should_drop\n )\n nn1 = tf.layers.dropout(inputs=nn1,\n rate=self.dropout,\n training=self.should_drop\n )\n\n for i in range(1, len(self.hidden_layers)):\n nn0 = tf.layers.dense(\n inputs=nn0,\n units=self.hidden_layers[i],\n activation=self.feature_activation,\n use_bias=self.feature_bias,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_hidden_\" + str(i)\n )\n nn1 = tf.layers.dense(\n inputs=nn1,\n units=self.hidden_layers[i],\n activation=self.feature_activation,\n use_bias=self.feature_bias,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_hidden_\" + str(i),\n reuse=True\n )\n\n # Layer Dropout\n nn0 = tf.layers.dropout(inputs=nn0,\n rate=self.dropout,\n training=self.should_drop\n )\n nn1 = tf.layers.dropout(inputs=nn1,\n rate=self.dropout,\n training=self.should_drop\n )\n\n # Creating antisymmetric features for the ranking\n self.nn = (nn0 - nn1) / 2.\n\n self.nn = tf.layers.dense(\n inputs=self.nn,\n units=1,\n activation=self.ranking_activation,\n use_bias=False,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_rank\"\n )\n\n self.nn_cls = tf.layers.dense(\n inputs=nn0 / 2.,\n units=1,\n activation=self.ranking_activation,\n use_bias=False,\n kernel_initializer=self.kernel_initializer,\n kernel_regularizer=regularizer,\n name=\"nn_rank\",\n reuse=True\n )\n\n nn_out = tf.identity(\n input=self.nn,\n name=\"nn\"\n )","def __build_nn_architecture(self, dim_Y, hidden_dimensions):\n Y = tf.placeholder(tf.float32, shape=[None, dim_Y])\n config = tf.placeholder(tf.float32, shape=[None, len(self.knob_cols)])\n placeholders = [config, Y]\n weights, biases, outputs = self.__make_fc_layers(\n Y, dim_Y, hidden_dimensions, self.activations, trainable=[True] *\n (len(hidden_dimensions) + 1))\n architecture = [placeholders, weights, biases, outputs]\n return architecture","def __init__(self, N_neurons, opt_kwargs): \n # Define global step for checkpointing.\n self.global_step=tf.Variable(0, dtype=tf.int32, trainable=False, name=\"global_step\")\n\n self.L=40 # system linear size\n self.n_feats=self.L**2 # 40x40 square lattice\n self.n_categories=2 # 2 Ising phases: ordered and disordered\n\n # Create placeholders for input X and label Y.\n self.create_placeholders()\n # Create weight and bias, initialized to 0 and construct DNN to predict Y from X.\n self.deep_layer_neurons=N_neurons\n self.create_DNN()\n # Define loss function.\n self.create_loss()\n # Use gradient descent to minimize loss.\n self.create_optimiser(opt_kwargs)\n # Create accuracy.\n self.create_accuracy()","def init_dense(self, layer):\n pass","def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\n # set number of nodes in each input, hidden, output layer\n self.inodes = inputnodes\n self.hnodes = hiddennodes\n self.onodes = outputnodes\n\n #learning rate\n self.lr = learningrate","def __init__(self, incoming, n_units, flatten_input=False, W=tf.zeros, b=tf.zeros, a=tf.sigmoid, name='DenseLayer'):\n super(DenseLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n \n if (len(self.incoming_shape) > 2) and flatten_input:\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\n elif len(self.incoming_shape) == 4:\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\n elif len(self.incoming_shape) >= 5:\n incoming_shape = [self.incoming_shape[0], self.incoming_shape[1], np.prod(self.incoming_shape[2:])]\n else:\n incoming_shape = self.incoming_shape\n \n # Set init for W\n W = tofov(W, shape=[incoming_shape[-1], n_units], var_params=dict(name='W_dense'))\n \n # Set init for b\n if b is not None:\n b = tofov(b, [n_units], var_params=dict(name='b_dense'))\n \n self.a = a\n self.b = b\n self.W = W\n \n self.n_units = n_units\n self.flatten_input = flatten_input\n self.incoming_shape = incoming_shape\n \n self.out = tf.zeros(self.get_output_shape())\n self.name = name","def build_densenet(l_in, input_var=None, first_output=64, growth_rate=32, num_blocks=4, dropout=0):\n \n\n nb_layers = [6, 12, 32, 32] # For DenseNet-169\n nb_layers = [6, 12, 24, 16] # For DenseNet-121\n # initial convolution\n network = Conv2DLayer(l_in, first_output, filter_size=7, stride=2, pad='same',\n W=lasagne.init.HeNormal(gain='relu'),\n b=None, nonlinearity=None, name='pre_conv')\n network = BatchNormLayer(network, name='pre_bn', beta=None, gamma=None)\n network = ScaleLayer(network, name='pre_scale')\n network = BiasLayer(network, name='pre_shift')\n network = dnn.MaxPool2DDNNLayer(network, pool_size=3, stride=2) \n # note: The authors' implementation does *not* have a dropout after the\n # initial convolution. This was missing in the paper, but important.\n # if dropout:\n # network = DropoutLayer(network, dropout)\n # dense blocks with transitions in between\n\n for b in range(num_blocks):\n network = dense_block(network, nb_layers[b], growth_rate, dropout,\n name_prefix='block%d' % (b + 1))\n if b < num_blocks - 1:\n network = transition(network, dropout,\n name_prefix='block%d_trs' % (b + 1))\n # post processing until prediction\n network = ScaleLayer(network, name='post_scale')\n network = BiasLayer(network, name='post_shift')\n network = NonlinearityLayer(network, nonlinearity=rectify, name='post_relu')\n\n return network","def LeNet5_architecture(self, input_shape):\r\n\r\n # Convolution layer (C1) hyperparameters\r\n s1 = self.hparameters[\"s1\"]\r\n f1 = self.hparameters[\"f1\"]\r\n n1 = self.hparameters[\"n1\"]\r\n\r\n # Average pooling layer(S2) hyperparameters\r\n s2 = self.hparameters[\"s2\"]\r\n f2 = self.hparameters[\"f2\"]\r\n\r\n # Convolutional layer (C3) hyperparameters\r\n s3 = self.hparameters[\"s3\"]\r\n f3 = self.hparameters[\"f3\"]\r\n n3 = self.hparameters[\"n3\"]\r\n\r\n # Average pooling layers (S4) hyperparameters\r\n s4 = self.hparameters[\"s4\"]\r\n f4 = self.hparameters[\"f4\"]\r\n\r\n # Convolutional layer (C5) hyperparameters\r\n s5 = self.hparameters[\"s5\"]\r\n f5 = self.hparameters[\"f5\"]\r\n n5 = self.hparameters[\"n5\"]\r\n\r\n # Number of outputs\r\n num_classes = self.num_classes\r\n\r\n X_input = Input(input_shape)\r\n X = X_input\r\n\r\n # Convolution layer 1\r\n X = Conv2D(n1, (f1,f1), strides = (s1, s1), padding = 'valid', name = 'C1', kernel_initializer = glorot_uniform(seed = 0))(X)\r\n # Average pooling\r\n X = AveragePooling2D(pool_size= (f2,f2), strides = (s2,s2), padding = 'valid', name = 'S2')(X)\r\n # Activation\r\n X = Activation('tanh')(X)\r\n # Convolution layer 2\r\n X = Conv2D(n3, (f3,f3), strides = (s3, s3), padding = 'valid', name = 'C3', kernel_initializer = glorot_uniform(seed = 0))(X)\r\n #Average pooling\r\n X = AveragePooling2D(pool_size= (f4,f4), strides = (s4,s4), padding = 'valid', name = 'S4')(X)\r\n # Activation\r\n X = Activation('tanh')(X)\r\n # Convolutional layer 3\r\n X = Conv2D(n5, (f5,f5), strides = (s5, s5), padding = 'valid', name = 'C5', kernel_initializer = glorot_uniform(seed = 0))(X)\r\n # Activation\r\n X = Activation('tanh')(X)\r\n # Flatten\r\n X = Flatten()(X)\r\n # Fully Connected layer\r\n X = Dense(num_classes, activation = 'softmax', name = 'FC', kernel_initializer = glorot_uniform(seed = 0))(X)\r\n\r\n #create model\r\n model = Model(inputs = X_input, outputs = X, name = 'LeNet5')\r\n\r\n return model","def __init__(self, *args, **kwargs):\n self.params = kwargs\n self.output_len = kwargs['num_neurons']\n self.input_len = kwargs['input_len']\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\n self.input_activations = None\n self.output_activations = Vector()","def _init_networks(self, state_dict: OrderedDict):\n self.dqn = Brain(self.backbone_cfg, self.head_cfg).to(self.device)\n self.dqn.load_state_dict(state_dict)\n self.dqn.eval()","def __init__(self, dropout, nonlinearity):\n super(LeNet300, self).__init__()\n\n layers = [(784, 300), (300, 100), (100, 10)]\n\n cfg = [('reshape', LambdaLayer(lambda x: x.view(x.size(0),-1)))]\n for i, l in enumerate(layers):\n cfg.append(('compressible_' + str(i), nn.Linear(*l)))\n if i != len(layers)-1:\n # only non terminal layers have nonlinearity and (possible) dropouts\n cfg.append(('nonlinearity_' + str(i), nonlinearity()))\n if dropout:\n cfg.append(('drop_'+str(i), nn.Dropout()))\n\n self.output = nn.Sequential(OrderedDict(cfg))\n self.loss = nn.CrossEntropyLoss()\n self.apply(_weights_init)","def __init__(\n self, state_dim, action_dim, sizes, activations, use_batch_norm: bool = False\n ) -> None:\n super().__init__()\n assert state_dim > 0, \"state_dim must be > 0, got {}\".format(state_dim)\n assert action_dim > 0, \"action_dim must be > 0, got {}\".format(action_dim)\n self.state_dim = state_dim\n self.action_dim = action_dim\n assert len(sizes) == len(\n activations\n ), \"The numbers of sizes and activations must match; got {} vs {}\".format(\n len(sizes), len(activations)\n )\n\n # The last layer gives the concentration of the distribution.\n self.fc = FullyConnectedNetwork(\n [state_dim] + sizes + [action_dim],\n activations + [\"linear\"],\n use_batch_norm=use_batch_norm,\n )"],"string":"[\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 __init__(self,layers,activations):\\n model = utils.buildMLP(layers, activations)\\n super().__init__(torch.nn.Sequential(model), nnType='dnn')\",\n \"def construct(self):\\n self.input_size = self.numplanes * self.boardsize**2\\n \\n if self.hidden:\\n layers = [\\n torch.nn.Linear(self.input_size, self.hidden), \\n torch.nn.ReLU(),\\n torch.nn.Linear(self.hidden, self.boardsize**2)\\n ]\\n else:\\n layers = [torch.nn.Linear(self.input_size, self.boardsize**2)]\\n\\n self.layers = torch.nn.ModuleList(layers)\\n self.optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)\\n logging.info(\\\"Model initialized: %s\\\", self)\",\n \"def setupNetwork(self):\\n\\t\\tin_layer = Input(shape=(28, ))\\n\\t\\td1 = Dense(40, activation='relu')(in_layer)\\n\\t\\td2 = Dense(10, activation='relu')(d1)\\n\\t\\tout = Dense(1, activation='sigmoid')(d2)\\n\\n\\t\\tself.model = tf.keras.Model(inputs=in_layer, outputs=out)\",\n \"def __init__(self, **kwargs):\\n #super(Net, self).__init__()\\n nn.Module.__init__(self)\\n # Build CNN\\n module, shapes, optim = build_neuron_network(**kwargs)\\n self._configuration = kwargs\\n self.add_module('cnn', module)\\n self.shapes = shapes\\n # Loss and optimization\\n self.criterion = nn.MSELoss(reduction='mean')\\n self.optimizer = optim\\n self._kwargs = kwargs\",\n \"def init_model(self, input_size, hidden_size, **kwargs):\\n # the size of input layer\\n self.input_size = input_size\\n # the node number of hidden layer\\n self.hidden_size = hidden_size\\n # if use bias term in activation function in hidden layer\\n self.en_bias = kwargs.get('EN_BIAS') or False\\n # activation function in hidden layer\\n self.acfun = AcFun(kwargs.get('AC_FUN') or 'tanh')\\n # parameters for nodes in hidden layer\\n self.nodes = Nodes(self.input_size, self.hidden_size, self.en_bias)\",\n \"def initModel(self):\\n input_shape = (self.params[\\\"nb_features\\\"],)\\n x = input_tensor = Input(input_shape)\\n x = Dense(self.params[\\\"nb_neurons\\\"], activation=\\\"relu\\\")(x)\\n for i in range(2, self.params[\\\"nb_layers\\\"] + 1):\\n x = Dense(self.params[\\\"nb_neurons\\\"], activation=\\\"relu\\\")(x)\\n if self.params[\\\"dropout\\\"]:\\n x = Dropout(self.params[\\\"dropout\\\"])(x)\\n x = output_tensor = Dense(4)(x)\\n model = Model(input_tensor, output_tensor)\\n return model\",\n \"def __init__(self):\\n \\n self.model = Net()\\n\\n if torch.cuda.is_available():\\n map_location=torch.device('cuda')\\n else:\\n map_location=torch.device('cpu')\\n\\n # load parameters\\n self.model.load_state_dict(torch.load('model.pt',\\n map_location=map_location)) \\n \\n if torch.cuda.is_available():\\n self.model.cuda()\\n else:\\n self.model.cpu()\\n \\n self.model.eval()\",\n \"def __init__(self):\\n super(Model, self).__init__()\\n\\n self.batch_size = 200\\n self.hidden_size = 264\\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\\n\\n self.dense_1 = tf.keras.layers.Dense(self.hidden_size, activation='relu')\\n self.dense_2 = tf.keras.layers.Dense(self.hidden_size, activation='relu')\",\n \"def new(self):\\n self.define_layers()\\n self.model = nn.Sequential(*self.layers)\\n self.model.cuda()\\n self.model = orthogonal_init(self.model)\\n\\n # Re-count N\\n self.count_params()\",\n \"def create_network(layers):\\r\\n return NeuronNetwork(layers)\",\n \"def init():\\n global neural_network\\n global labels\\n\\n # load objects required by run() for inferencing\\n model_dir = Model.get_model_path(\\\"mnist-fashion\\\")\\n # neural model\\n neural_network = keras.models.load_model(f\\\"{model_dir}/neural-network.h5\\\")\\n # labels\\n with open(f\\\"{model_dir}/labels.jsonpickle\\\", \\\"r\\\") as labels_file:\\n labels = jsonpickle.decode(labels_file.read())\",\n \"def __init__(self, input_dim: int, output_dim: int):\\n\\n super().__init__()\\n\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n\\n self.batchNorm1 = layers.BatchNormalization()\\n self.dense1 = layers.Dense(\\n 64, input_shape=(input_dim+output_dim,),\\n kernel_initializer=random_uniform(-np.sqrt(1/input_dim), np.sqrt(1/input_dim))\\n )\\n self.relu1 = layers.Activation('relu')\\n self.dense2 = layers.Dense(32, kernel_initializer=random_uniform(-np.sqrt(1/64), np.sqrt(1/64)))\\n self.relu2 = layers.Activation('relu')\\n self.dense3 = layers.Dense(output_dim, kernel_initializer=random_uniform(-np.sqrt(1/32), np.sqrt(1/32)))\",\n \"def _make_network(self):\\n inp = Input(shape = (self.input_dim,))\\n x = Dense(256, activation='relu')(inp)\\n x = GaussianNoise(1.0)(x)\\n #x = Flatten()(x) # I assume this is if the input is a convolutional neural net?\\n x = Dense(128, activation='relu')(x)\\n x = GaussianNoise(1.0)(x)\\n out = Dense(self.output_dim, activation='tanh', kernel_initializer=RandomUniform())(x)\\n out = Lambda(lambda i: i * self.act_range)(out)\\n return Model(inp, out)\",\n \"def __init__(self, netSize):\\n\\t\\t\\n\\t\\t# TRY THIS FOR RANDOM!\\n\\t\\t#\\n\\t\\t#\\n\\t\\t#\\n\\t\\t\\n\\t\\tself.biases = [self.randomArray(i, 1) for i in netSize[1:]] # Biases do not exist for the first layer ! Those are inputs.\\n\\t\\tself.netSize = netSize\\n\\t\\t#Initialize Weights\\n\\t\\t#This initializes the weights for each layer based on the size. The number of rows should be\\n\\t\\t#the number of neurons for the current, and the number of columns should be the same as the number of neurons\\n\\t\\t#in the next layer. There are no weights for the last layer. That's the output layer.\\n\\t\\tself.weights \\t\\t = [self.randomArray(i, j) for i, j in zip(netSize[:-1], netSize[1:]) ]\",\n \"def init_efficientnet(num_classes: int) -> nn.Module:\\n\\n return EfficientNet.from_pretrained('efficientnet-b1', num_classes=num_classes)\",\n \"def __init__(self, nInputs, nOutputs, hiddenLayersDims, outputActivationFunctions = None, outputActivationDerivatives = None, hiddenActivationFunctions = None,\\\\\\n\\t\\t\\t\\t hiddenActivationDerivatives = None): \\n\\n\\t\\tself._nInputs = nInputs\\n\\t\\tself._nOutputs = nOutputs\\n\\n\\t\\tself._nHiddenLayers, self._nUnitsPerLayer = hiddenLayersDims\\n\\n\\t\\tself._outputActivationFunctions = outputActivationFunctions\\n\\t\\tself._outputActivationDerivatives = outputActivationDerivatives\\n\\n\\t\\tself._hiddenActivationFunctions = hiddenActivationFunctions\\n\\t\\tself._hiddenActivationDerivatives = hiddenActivationDerivatives\\n\\n\\t\\tself.initialiseActivationFunctions()\\n\\n\\t\\tself.initialiseNetwork()\\n\\n\\t\\tself._nBranches = len(self.collectAllBranches())\",\n \"def create_nn(self):\\n\\n\\t\\tmodel = Sequential()\\n\\t\\tmodel.add(Dense(32, input_dim=self.state_size, activation='relu'))\\n\\t\\tmodel.add(Dense(32, activation='relu'))\\n\\t\\tmodel.add(Dense(64, activation='relu'))\\n\\t\\tmodel.add(Dense(self.action_size, activation='linear'))\\n\\t\\tmodel.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))\\n\\t\\treturn model\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.input_layer = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.relu = ReLULayer()\\n self.output_layer = FullyConnectedLayer(hidden_layer_size, n_output)\\n self.W_in = None\\n self.W_out = None\\n self.B_in = None\\n self.B_out = None\\n # TODO Create necessary layers\",\n \"def create_network():\\n net = ln.models.TinyYolo(CLASSES, CONF_THRESH, NMS_THRESH)\\n\\n net.load(args.weight)\\n net.eval()\\n net.postprocess.append(ln.data.transform.TensorToBrambox(NETWORK_SIZE, LABELS))\\n net = net.to(device)\\n return net\",\n \"def setup(input_shape=None, depth=40, nb_dense_block=3, growth_rate=12,\\n nb_filter=-1, nb_layers_per_block=-1, bottleneck=False,\\n reduction=0.0, dropout_rate=0.0, weight_decay=1e-4,\\n subsample_initial_block=False, include_top=True, weights=None,\\n input_tensor=None, classes=10, activation='softmax'):\\n\\n if weights not in {'imagenet', None}:\\n raise ValueError('The `weights` argument should be either '\\n '`None` (random initialization) or `cifar10` '\\n '(pre-training on CIFAR-10).')\\n\\n if weights == 'imagenet' and include_top and classes != 1000:\\n raise ValueError('If using `weights` as ImageNet with '\\n '`include_top` as true, `classes` should be 1000')\\n\\n if activation not in ['softmax', 'sigmoid', 'linear']:\\n raise ValueError('activation must be one of \\\"softmax\\\", \\\"sigmoid\\\", '\\n 'or \\\"linear\\\"')\\n\\n if activation == 'sigmoid' and classes != 1:\\n raise ValueError('sigmoid activation can only be used when '\\n 'classes = 1')\\n\\n # Determine proper input shape\\n input_shape = _obtain_input_shape(input_shape,\\n default_size=32,\\n min_size=8,\\n data_format=K.image_data_format(),\\n require_flatten=include_top)\\n\\n if input_tensor is None:\\n img_input = Input(shape=input_shape)\\n else:\\n if not K.is_keras_tensor(input_tensor):\\n img_input = Input(tensor=input_tensor, shape=input_shape)\\n else:\\n img_input = input_tensor\\n\\n x = __create_dense_net(\\n classes, img_input, include_top, depth, nb_dense_block,\\n growth_rate, nb_filter, nb_layers_per_block, bottleneck, reduction,\\n dropout_rate, weight_decay, subsample_initial_block, activation\\n )\\n\\n # Ensure that the model takes into account any potential predecessors\\n # of `input_tensor`.\\n if input_tensor is not None:\\n inputs = get_source_inputs(input_tensor)\\n else:\\n inputs = img_input\\n # Create model.\\n model = Model(inputs, x, name='densenet')\\n return model\",\n \"def initialize_model(self):\\n\\n input_layer = Input(\\n shape=(self.input_length,), \\n dtype='int32', \\n name='input'\\n )\\n\\n if self.embedding_matrix is None:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1, # for mask\\n input_length=self.input_length,\\n mask_zero=True,\\n name='embedding'\\n )(input_layer)\\n else:\\n embedding = Embedding(\\n output_dim=self.embedding_size,\\n input_dim=self.vocabulary_size + 1,\\n input_length=self.input_length,\\n mask_zero=True,\\n weights=[np.vstack((np.zeros((1, self.embedding_size)),\\n self.embedding_matrix))],\\n name='embedding'\\n )(input_layer)\\n\\n encoder = self.recurrent_cell(\\n self.latent_dim,\\n dropout=self.dropout,\\n recurrent_dropout=self.dropout,\\n name='encoder',\\n recurrent_regularizer=l1_l2(*self.regularization)\\n )\\n\\n if self.use_bidirection:\\n encoder = Bidirectional(\\n encoder,\\n merge_mode='concat'\\n )\\n\\n encoder = encoder(embedding)\\n\\n dense_1 = Dense(\\n 1024,\\n activation='tanh',\\n name='dense_1',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(encoder)\\n\\n dense_2 = Dense(\\n 512,\\n activation='tanh',\\n name='dense_2',\\n kernel_regularizer=l1_l2(*self.regularization)\\n )(dense_1)\\n\\n dropout = Dropout(self.dropout)(\\n dense_2\\n )\\n\\n prediction = Dense(\\n 1,\\n activation='sigmoid',\\n name='prediction'\\n )(dropout)\\n\\n model = Model(inputs=input_layer, outputs=prediction)\\n\\n # sparse_categorical_crossentropy\\n model.compile(optimizer=Adam(lr=self.learning_rate),\\n loss='binary_crossentropy',\\n metrics=['acc'])\\n\\n self.model = model\\n\\n if self.verbose > 0:\\n model.summary()\\n\\n return [model]\",\n \"def network(self):\\n inp = Input((self.env_dim))\\n # #\\n # x = Dense(256, activation='relu')(inp)\\n # x = GaussianNoise(1.0)(x)\\n # #\\n # x = Flatten()(x)\\n # x = Dense(128, activation='relu')(x)\\n # x = GaussianNoise(1.0)(x)\\n # #\\n # out = Dense(self.act_dim, activation='tanh', kernel_initializer=RandomUniform())(x)\\n # out = Lambda(lambda i: i * self.act_range)(out)\\n # #\\n\\n x = conv_block(inp, 32, (2, 2), 8)\\n x = conv_block(x, 64, (2, 2), 4)\\n x = conv_block(x, 64, (2, 2), 3)\\n x = Flatten()(x)\\n x = Dense(256, activation='relu')(x)\\n\\n x = Dense(self.act_dim, activation='tanh', kernel_initializer=RandomUniform())(x)\\n out = Lambda(lambda i: i * self.act_range)(x)\\n\\n return Model(inp, out)\",\n \"def __init__(self, emb_dim, vocab_size, layers, suppress_output=False, lstm=False, irnn=False, active=F.relu, eos_id=0):\\n assert not (lstm and irnn)\\n\\n self.emb_dim = emb_dim\\n self.vocab_size = vocab_size\\n self.layers = layers\\n self.suppress_output = suppress_output\\n self.lstm = lstm\\n self.irnn = irnn\\n self.active = active\\n self.eos_id = eos_id\\n\\n # set up NN architecture\\n model = chainer.FunctionSet(\\n emb=F.EmbedID(vocab_size, emb_dim),\\n )\\n # add hidden layers\\n layer_dims = [emb_dim] + layers\\n for i in range(len(layers)):\\n in_dim = layer_dims[i]\\n out_dim = layer_dims[i+1]\\n if lstm:\\n linear = F.Linear(in_dim, out_dim*4)\\n hidden = F.Linear(out_dim, out_dim*4)\\n else:\\n linear = F.Linear(in_dim, out_dim)\\n hidden = F.Linear(out_dim, out_dim)\\n if irnn:\\n # initialize hidden connection with identity matrix\\n hidden.W = np.eye(out_dim)\\n setattr(model, 'l{}_x'.format(i+1), linear)\\n setattr(model, 'l{}_h'.format(i+1), hidden)\\n if not suppress_output:\\n # add output layer\\n setattr(model, 'l_y', F.Linear(layer_dims[-1], vocab_size))\\n self.model = model\",\n \"def __init__(self, N_sym, n_nodes, activations, N_element, bias = True, scaling = None):\\n super(MultiLayerNet, self).__init__()\\n N_layers = len(n_nodes)\\n if N_layers == 0:\\n self.net = torch.nn.Linear(N_sym, N_element, bias = bias)\\n else:\\n layers = []\\n for n in range(N_layers):\\n if n == 0:\\n layers += [torch.nn.Linear(N_sym, n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n else:\\n layers += [torch.nn.Linear(n_nodes[n-1], n_nodes[n], bias = bias)]\\n layers += [activations[n]]\\n layers += [torch.nn.Linear(n_nodes[-1], N_element, bias = bias)]\\n self.net = torch.nn.Sequential(*layers)\\n \\n self.scaling = scaling\",\n \"def __init__(self, net, batch=False):\\n\\n super().__init__()\\n self.batch = batch\\n self.net = net\\n self.input = Input(self.net.layers()[0],\\n self.net.layers()[1].inputSize(), batch)\\n self.hiddens = []\\n for i in range(1, len(net.layers())-1):\\n nextLen = net.layers()[i+1].inputSize()\\n self.hiddens.append(Hidden(net.layers()[i], nextLen, batch))\\n self.output = Output(self.net.layers()[-1])\",\n \"def init_net(self):\\r\\n # initialize the generator network\\r\\n g_net = Net(\\r\\n self.architecture['generator'], net_name='gen',\\r\\n data_format=FLAGS.IMAGE_FORMAT, num_class=self.num_class)\\r\\n # define layer connections in generator\\r\\n self.Gen = Routine(g_net)\\r\\n self.Gen.add_input_layers([64, self.code_size], [0])\\r\\n self.Gen.seq_links(list(range(g_net.num_layers)))\\r\\n self.Gen.add_output_layers([g_net.num_layers - 1])\\r\\n\\r\\n # initialize the generator network\\r\\n d_net = Net(\\r\\n self.architecture['discriminator'], net_name='dis',\\r\\n data_format=FLAGS.IMAGE_FORMAT, num_class=self.num_class)\\r\\n # define layer connections in generator\\r\\n self.Dis = Routine(d_net)\\r\\n self.Dis.add_input_layers([64] + list(self.architecture['input'][0]), [0])\\r\\n self.Dis.seq_links(list(range(d_net.num_layers)))\\r\\n self.Dis.add_output_layers([d_net.num_layers - 1])\",\n \"def __init__(self, layer_list_info):\\n super(DynaNet, self).__init__()\\n self.layer_list_info = layer_list_info\\n self.task_modules = nn.ModuleDict()\\n self.classification_layers = nn.ModuleDict()\\n self.module_generator = ModuleFactory(layer_list_info)\\n self.task_module_name_path = {}\\n self.nr_levels = len(layer_list_info)\\n self.task_idx = None\",\n \"def __setup_model(self, **kwargs):\\n self.model_architecture = kwargs['model_architecture'].upper()\\n self.model = Classifier.IMAGENET_MODELS[self.model_architecture](\\n pretrained=True\\n )\\n\\n if 'input_size' in kwargs: # Loading from a checkpoint\\n self.input_size = kwargs['input_size']\\n self.model.current_epoch = kwargs['current_epoch']\\n\\n else: # No checkpoint, will be creating a new classifier for the model\\n # The number of features coming from the feature detector CNN\\n if 'ALEXNET' in self.model_architecture:\\n self.input_size = self.model.classifier[1].in_features\\n elif 'VGG' in self.model_architecture:\\n self.input_size = self.model.classifier[0].in_features\\n elif 'DENSENET' in self.model_architecture:\\n self.input_size = self.model.classifier.in_features\\n\\n # Freeze the feature detector parameters to prevent backpropagating\\n # through them.\\n for param in self.model.parameters():\\n param.requires_grad = False\\n\\n self.model.current_epoch = 1\\n\\n self.output_size = kwargs['output_size']\\n self.hidden_layers = kwargs['hidden_layers']\\n self.learn_rate = kwargs['learn_rate']\\n self.drop_p = kwargs['drop_p']\\n\\n self.model.class_to_idx = kwargs['class_to_idx']\\n self.model.classifier = Network(self.input_size,\\n self.output_size,\\n self.hidden_layers,\\n self.drop_p)\\n\\n if 'model_state_dict' in kwargs: # load the state from checkpoint\\n self.model.load_state_dict(kwargs['model_state_dict'])\\n\\n self.criterion = nn.NLLLoss()\\n self.optimizer = optim.Adam(self.model.classifier.parameters(),\\n lr=self.learn_rate)\\n\\n if 'optimizer_state_dict' in kwargs: # load the state from checkpoint\\n self.optimizer.load_state_dict(kwargs['optimizer_state_dict'])\",\n \"def __init__(self):\\n super(FcNet, self).__init__()\\n\\n # get size of some layers\\n start_num = 48\\n max_num = 200\\n mid_num = 50\\n end_num = 8\\n \\n # define regressor\\n self.regress = nn.Sequential(\\n nn.Linear(start_num,max_num,bias=True),\\n nn.Sigmoid(),\\n nn.Linear(max_num,mid_num,bias = True),\\n nn.Sigmoid(),\\n nn.Linear(mid_num,end_num, bias = True),\\n nn.Sigmoid()\\n )\",\n \"def __init__(self,\\n image_shape,\\n z_dim,\\n num_blocks,\\n action_space,\\n hiddens=[],\\n dropout=False,\\n subsampling=True):\\n super().__init__()\\n self.layers = nn.ModuleList()\\n self.layers.append(\\n ImageInputNetwork(image_shape, z_dim, num_blocks, dropout,\\n subsampling))\\n self.layers.append(ActorNet(action_space, z_dim, hiddens))\",\n \"def trainNet():\",\n \"def initialize_network(self):\\n self.sess = tf.InteractiveSession()\\n sys.stderr.write(\\\"------\\\\n\\\")\\n self.model.create_model()\\n self._initialize_trainer()\\n self.sess.run(tf.initialize_all_variables())\\n self.saver = tf.train.Saver()\",\n \"def __init__(self, nx, nodes):\\n if type(nx) is not int:\\n raise TypeError(\\\"nx must be an integer\\\")\\n if nx < 1:\\n raise ValueError(\\\"nx must be a positive integer\\\")\\n if type(nodes) is not int:\\n raise TypeError(\\\"nodes must be an integer\\\")\\n if nodes < 1:\\n raise ValueError(\\\"nodes must be a positive integer\\\")\\n # weights vector for the hidden layer\\n # default mean is 0\\n # default stddev is 1\\n self.__W1 = np.random.normal(size=(nodes, nx))\\n # The bias for the hidden layer. Upon instantiation,\\n # it should be initialized with 0’s.\\n self.__b1 = np.zeros((nodes, 1))\\n # The activated output for the hidden layer. Upon instantiation,\\n # it should be initialized to 0\\n self.__A1 = 0\\n # weights vector for the output neuron\\n # default mean is 0\\n # default stddev is 1\\n self.__W2 = np.random.normal(size=(1, nodes))\\n # bias for the output neuron\\n self.__b2 = 0\\n # activated output for the output neuron (prediction)\\n self.__A2 = 0\",\n \"def __init__(self, n_lm, n_ang):\\n super(MVCNet, self).__init__()\\n self.convM1_sag = conv_bn_prelu_dropout(1, 64, 4, 2, 1, 64, 64, 0.25)\\n self.convM1_cor = conv_bn_prelu_dropout(1, 64, 4, 2, 1, 64, 64, 0.25)\\n self.xModule1 = xModule([64, 128, 64], 64, 4, 2, 1, 128, 128, 0.25)\\n self.xModule2 = xModule([128, 64, 32], 128, 4, 2, 1, 256, 256, 0.25)\\n self.xModule3 = xModule([256, 32, 16], 256, 4, 2, 1, 512, 512, 0.25)\\n self.SLE_sag = SLE([512, 16, 8], 512, n_lm)\\n self.SLE_cor = SLE([512, 16, 8], 512, n_lm)\\n self.CAE_sag = CAE(512, n_lm, n_ang)\\n self.CAE_cor = CAE(512, n_lm, n_ang)\",\n \"def __init__(self, params):\\n super(Net, self).__init__()\\n\\n # the embedding takes as input the vocab_size and the embedding_dim\\n self.embedding = nn.Embedding(params.vocab_size, params.embedding_dim)\\n\\n # the LSTM takes as input the size of its input (embedding_dim), its hidden size\\n # for more details on how to use it, check out the documentation\\n self.lstm = nn.LSTM(params.embedding_dim,\\n params.lstm_hidden_dim, batch_first=True)\\n\\n # the fully connected layer transforms the output to give the final output layer\\n self.fc = nn.Linear(params.lstm_hidden_dim, params.number_of_tags)\\n self.fc2 = nn.Linear(params.number_of_tags, params.number_of_tags)\",\n \"def __init__(self, input_size, output_size, hidden_sizes=[],\\r\\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\\r\\n random_seed=None):\\r\\n if random_seed is not None:\\r\\n seed(random_seed)\\r\\n\\r\\n weight_func = partial(normal, 0, weight_scale)\\r\\n self.converge = converge\\r\\n self.layers = []\\r\\n self.layers.append([InputNode(\\\"in_\\\" + str(i)) for i in range(input_size)])\\r\\n for i,layer_size in enumerate(hidden_sizes):\\r\\n self.layers.append([SigmoidNode(\\\"hidden_\\\"+str(i)+\\\"-\\\"+str(j),\\r\\n learning_rate) for j in range(layer_size)])\\r\\n self.layers.append([SigmoidNode(\\\"out_\\\"+str(i), learning_rate) for i\\r\\n in range(output_size)])\\r\\n\\r\\n # densely connect consecutive layers\\r\\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\\r\\n for source, dest in product(source_layer, dest_layer):\\r\\n edge = Edge(source, dest, weight_func)\\r\\n source.out_edges.append(edge)\\r\\n dest.in_edges.append(edge)\\r\\n\\r\\n # connect each node to bias\\r\\n self.bias = BiasNode()\\r\\n for layer in self.layers[1:]:\\r\\n for node in layer:\\r\\n e = Edge(self.bias, node, weight_func)\\r\\n node.in_edges.append(e)\\r\\n self.bias.out_edges.append(e)\",\n \"def __init__(self, hparams):\\n super(ImagenetTransferLearning, self).__init__()\\n self.hparams = hparams\\n self.feature_extractor = models.mobilenet_v2(pretrained=True)\\n self.feature_extractor.eval()\\n\\n # Establish classifier\\n # self.layer_1 = torch.nn.Linear(hparams[\\\"input_size\\\"], 128)\\n self.layer_1 = torch.nn.Linear(1000, 128)\\n self.layer_2 = torch.nn.Linear(128, 256)\\n self.layer_3 = torch.nn.Linear(256, hparams[\\\"targets\\\"])\",\n \"def __init__(self, input_dim: int, output_dim: int):\\n\\n super().__init__()\\n\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n\\n self.batchNorm1 = nn.BatchNorm1d(input_dim)\\n self.dense1 = nn.Linear(input_dim+output_dim, 64)\\n self.relu1 = nn.ReLU()\\n self.dense2 = nn.Linear(64, 32)\\n self.relu2 = nn.ReLU()\\n self.dense3 = nn.Linear(32, output_dim)\",\n \"def __init__(self, attribute_size, output_size, n_hidden_layers=2, n_hidden_neurons=30):\\n self.n_hidden_layers = n_hidden_layers\\n self.n_hidden_neurons = n_hidden_neurons\\n self.attribute_size = attribute_size\\n self.output_size = output_size\\n\\n X = T.fmatrix()\\n Y = T.fmatrix()\\n\\n self.w_h = nnet.init_weights((self.attribute_size, self.n_hidden_neurons))\\n self.w_h2 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n self.w_o = nnet.init_weights((self.n_hidden_neurons, self.output_size))\\n\\n if self.n_hidden_layers == 2:\\n\\n noise_py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\\n\\n elif self.n_hidden_layers == 3:\\n\\n self.w_h3 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n\\n noise_py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_h3, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\",\n \"def __init__(self, num_inputs=3, hidden_layers=[3, 3], num_outputs=2):\\n\\n self.num_inputs = num_inputs\\n self.hidden_layers = hidden_layers\\n self.num_outputs = num_outputs\\n\\n # create a generic representation of the layers\\n layers = [num_inputs] + hidden_layers + [num_outputs]\\n\\n # create random connection weights for the layers\\n weights = []\\n for i in range(len(layers) - 1):\\n w = np.random.rand(layers[i], layers[i + 1])\\n weights.append(w)\\n self.weights = weights\\n\\n activations = []\\n\\n for i in range(len(layers)):\\n a = np.zeros(layers[i])\\n activations.append(a)\\n self.activations = activations\\n\\n derivatives = []\\n\\n for i in range(len(layers) - 1):\\n d = np.zeros(layers[i])\\n derivatives.append(d)\\n self.derivatives = derivatives\",\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 __init__(self, nhidden, nunits, state_space_dim, action_space_dim):\\n\\n super(Estimator, self).__init__()\\n self.state_space_dim = state_space_dim\\n self.action_space_dim = action_space_dim\\n\\n assert nhidden > 0, 'Number of hidden layers must be > 0'\\n\\n init_layer = nn.Linear(state_space_dim, nunits)\\n self.final_layer = nn.Linear(nunits, action_space_dim)\\n\\n layers = [init_layer]\\n for n in range(nhidden - 1):\\n layers.append(nn.Linear(nunits, nunits))\\n\\n self.module_list = nn.ModuleList(layers)\\n\\n self.relu = nn.ReLU()\",\n \"def __init__(self, num_models: int, num_classes: int):\\n self.nun_models = num_models\\n self.num_classes = num_classes\\n self.model: keras.Model = self.init_model()\",\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 build_network(self, dimList, actType=\\\"Tanh\\\", verbose=True):\\n self.Q_network = Model(dimList, actType, verbose=verbose)\\n self.target_network = Model(dimList, actType)\\n\\n if self.device == torch.device(\\\"cuda\\\"):\\n self.Q_network.cuda()\\n self.target_network.cuda()\\n\\n self.build_optimizer()\",\n \"def __init__(\\n self,\\n units,\\n activation=None,\\n use_bias=True,\\n kernel_initializer='glorot_uniform',\\n bias_initializer='zeros',\\n kernel_regularizer=None,\\n bias_regularizer=None,\\n **kwargs\\n ):\\n super(Dense, self).__init__(**kwargs)\\n self.input_dim = kwargs.get('input_dim', None)\\n self.units = int(units)\\n self.activation = activations.get(activation)\\n self.use_bias = use_bias\\n self.kernel_initializer = initializers.get(kernel_initializer)\\n self.bias_initializer = initializers.get(bias_initializer)\\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\\n self.bias_regularizer = regularizers.get(bias_regularizer)\\n self.input_spec = InputSpec(min_ndim=2)\\n self.kernel = None\\n self.bias = None\",\n \"def _build_network(self, h_size=16, l_rate=0.001):\\n with tf.variable_scope(self.net_name):\\n self._X = tf.placeholder(tf.float32, [None, self.input_size], name=\\\"input_x\\\")\\n net = self._X\\n\\n net = tf.layers.dense(net, h_size, activation=tf.nn.relu)\\n net = tf.layers.dense(net, self.output_size)\\n self._Qpred = net\\n\\n self._Y = tf.placeholder(tf.float32, shape=[None, self.output_size])\\n self._loss = tf.losses.mean_squared_error(self._Y, self._Qpred)\\n\\n optimizer = tf.train.AdamOptimizer(learning_rate=l_rate)\\n self._train = optimizer.minimize(self._loss)\",\n \"def __init__(self,\\n image_shape,\\n z_dim,\\n num_blocks,\\n action_space,\\n hiddens=[],\\n dropout=False,\\n subsampling=True):\\n super().__init__()\\n self.image_shape = image_shape\\n self.layers = nn.ModuleList()\\n self.layers.append(\\n ImageInputNetwork(image_shape, z_dim, num_blocks, dropout,\\n subsampling))\\n self.layers.append(nn.Sequential(\\n nn.Linear(128, z_dim),\\n nn.ReLU()\\n ))\\n self.layers.append(nn.Sequential(nn.Linear(z_dim, action_space.n),\\n nn.Softmax(1)))\\n self.layers.append(nn.Linear(z_dim, 1))\",\n \"def __init__(self, n_classes, num_nodes=None, dropouts=None, activation=\\\"relu\\\"):\\n # parameters initialization\\n self.n_classes = n_classes\\n if self.n_classes == 1:\\n self.output_act = \\\"sigmoid\\\"\\n else:\\n self.output_act = \\\"softmax\\\"\\n self.num_nodes = num_nodes if num_nodes != None else [1024, 512]\\n self.dropouts = dropouts if dropouts != None else [0.5, 0.5]\\n self.activation = activation\\n\\n # Check if number of layers and number of dropouts have same dimension\\n if not len(self.num_nodes) == len(self.dropouts):\\n raise AssertionError()\",\n \"def __init__(self, input_size, hidden_size, output_size):\\n super(Net, self).__init__()\\n self.hidden_size = hidden_size\\n\\n self.i2h = nn.Linear(input_size + hidden_size, hidden_size)\\n self.i2o = nn.Linear(input_size + hidden_size, output_size)\\n self.softmax = nn.LogSoftmax(dim=1)\",\n \"def __init__(\\n self,\\n latentspace,\\n num_blocks=16,\\n neurons_per_layer=16,\\n hidden_activation=\\\"relu\\\",\\n output_activation=\\\"sigmoid\\\",\\n add_noise=True,\\n **kwargs\\n ):\\n h_Activation = lambda activation: LeakyReLU(0.02) if activation == \\\"leaky_relu\\\" else Activation(activation)\\n\\n inp = Input((latentspace,))\\n x = inp\\n if add_noise:\\n x = GaussianNoise(0.01)(x)\\n\\n for _ in range(num_blocks):\\n x = dense_block(\\n x,\\n neurons_per_layer, # Dense layer\\n add_noise, # GaussianNoise with 0.005\\n # Layer normalization\\n h_Activation(hidden_activation)\\n ) # returns Concat [X_input, X]\\n\\n x = Dense(128)(x)\\n x = h_Activation(hidden_activation)(x)\\n x = Dense(1)(x)\\n out = h_Activation(output_activation)(x)\\n\\n # Construct the functional model by calling the constructor of the Model super class.\\n super(DiscriminatorLatent, self).__init__(inp, out, **kwargs)\",\n \"def _mnasnet(arch, block, layers, expansions, kernel_sizes, SE, dropout=0,\\n pretrained=False, progress=False, **kwargs):\\n model = MnasNet(block, layers=layers, expansions=expansions, kernel_sizes=kernel_sizes,\\n SE=SE, dropout=dropout, **kwargs)\\n if pretrained:\\n if arch in model_urls.keys():\\n state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)\\n model.load_state_dict(state_dict)\\n return model\",\n \"def create_network(self):\\n\\n print ('Creating network, changing data will have no effect beyond this point.')\\n n = IMNN.IMNN(parameters=self.parameters)\\n\\n if self.load_network:\\n n.restore_network()\\n else:\\n n.setup(network = self.network, load_data = self.data)\\n\\n return n\",\n \"def __init__(self, layerNeurons, initialWeights = None, layerTypes=None, **kwargs):\\r\\n \\r\\n # Ensure that there is at-least one input and one output layer in the network\\r\\n assert len(layerNeurons)>1, \\\"At least one input layer and one output layer is needed\\\"\\r\\n \\r\\n # Get the total number of weights needed in the network\\r\\n totalWeightCount = NeuralNetwork.getSizeOfWeightVector(layerNeurons)\\r\\n \\r\\n # Initialise the weights with the initializer or random values\\r\\n if initialWeights is None:\\r\\n self.weights = np.random.uniform(-1/np.sqrt(layerNeurons[0]), 1/np.sqrt(layerNeurons[0]), totalWeightCount)\\r\\n else:\\r\\n assert len(initialWeights) == totalWeightCount, (\\\"Length of initial weight matrix incorrect. You need \\\"+str(totalWeightCount)+\\\" weights\\\")\\r\\n self.weights = np.array(initialWeights, dtype = np.float64) \\r\\n \\r\\n # create an empty array of layers\\r\\n self.layers = []\\r\\n layerBlockStart = 0\\r\\n \\r\\n if layerTypes is None or len(layerTypes)<(len(layerNeurons)-1):\\r\\n layerTypes=[NetworkLayer]*(len(layerNeurons)-1)\\r\\n \\r\\n for layerInputDimention, layerOutputDimention, layerType in zip(layerNeurons, layerNeurons[1:], layerTypes):\\r\\n # initialise each layer with its input and output dimentions and bi-directional pointers to the relivant weights\\r\\n layerBlockEnd = layerBlockStart+(layerInputDimention*layerOutputDimention)\\r\\n layerBiasEnd = layerBlockEnd+layerOutputDimention\\r\\n newLayer = layerType(layerInputDimention, layerOutputDimention, \\r\\n self.weights[..., layerBlockStart:layerBlockEnd], \\r\\n self.weights[..., layerBlockEnd:layerBiasEnd], **kwargs)\\r\\n self.layers.append(newLayer)\\r\\n \\r\\n layerBlockStart = layerBiasEnd\\r\\n \\r\\n # Tell the output later to use a different function to calculate the delta \\r\\n newLayer.calcDelta = newLayer.calcDeltaOutputLayer\",\n \"def __init__(self, input_size, hidden_sizes, output_size=1,\\n batchnorm_bool=False,\\n dropout_bool=False):\\n super(NeuralNet, self).__init__()\\n self.input_size = input_size\\n sizes = [input_size] + hidden_sizes + [output_size]\\n self.layers = nn.ModuleList(\\n [nn.Linear(in_f, out_f) for in_f, out_f in zip(sizes, sizes[1:])])\\n self.bns = nn.ModuleList(\\n [nn.BatchNorm1d(out_f) for in_f, out_f in zip(sizes, sizes[1:])])\\n self.dps = nn.ModuleList(\\n [nn.Dropout(p=0.5) for _ in range(len(self.layers))])\\n self.relus = nn.ModuleList(\\n [nn.ReLU() for _ in range(len(self.layers))])\\n self.sigmoid = nn.Sigmoid()\\n\\n self.batchnorm_bool = batchnorm_bool\\n self.dropout_bool = dropout_bool\",\n \"def __init__(\\n self,\\n numpy_rng,\\n train_set_x,\\n train_set_y,\\n hidden_layers_sizes,\\n n_ins=784,\\n n_outs=10\\n ):\\n\\n self.sigmoid_layers = []\\n self.AE_layers = []\\n self.params = []\\n self.n_layers = len(hidden_layers_sizes)\\n self.train_set_x = train_set_x\\n self.train_set_y = train_set_y\\n\\n assert self.n_layers > 0\\n\\n self.x = T.matrix('x') # the data is presented as rasterized images\\n self.y = T.ivector('y') # the labels are presented as 1D vector of\\n\\n for i in xrange(self.n_layers): # used to be n layers\\n\\n # construct the sigmoid layer = encoder stack\\n if i == 0:\\n layer_input = self.x\\n else:\\n layer_input = self.sigmoid_layers[-1].output\\n\\n sigmoid_layer = HiddenLayer(rng=numpy_rng,\\n input=layer_input,\\n n_in=(n_ins if i == 0 else\\n hidden_layers_sizes[i-1]),\\n n_out=hidden_layers_sizes[i],\\n activation=T.nnet.sigmoid)\\n\\n # add the layer to our list of layers\\n self.sigmoid_layers.append(sigmoid_layer)\\n self.params.extend(sigmoid_layer.params)\\n\\n # init the DA_layer, takes weights from sigmoid layer\\n AE_layer = AutoEncoder(\\n numpy_rng=numpy_rng,\\n input=layer_input,\\n n_visible=(n_ins if i == 0 else hidden_layers_sizes[i-1]),\\n n_hidden=hidden_layers_sizes[i],\\n W=sigmoid_layer.W,\\n bhid=sigmoid_layer.b)\\n\\n self.AE_layers.append(AE_layer)\\n\\n # on top of the layers\\n # log layer for fine-tuning\\n self.logLayer = LogisticRegression(\\n input=self.sigmoid_layers[-1].output,\\n n_in=hidden_layers_sizes[-1],\\n n_out=n_outs\\n )\\n self.params.extend(self.logLayer.params)\\n self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)\\n self.errors = self.logLayer.errors(self.y)\",\n \"def _build_network(self,\\n input_dim,\\n dense_layers,\\n nodes_per_layer=None,\\n hidden_act='relu',\\n output_act='sigmoid',\\n dropout_layers=None):\\n\\n if nodes_per_layer is None:\\n nodes = [10] * dense_layers\\n else:\\n nodes = nodes_per_layer\\n\\n if dropout_layers is None:\\n do_layers = [0] * dense_layers\\n else:\\n do_layers = dropout_layers\\n\\n self.model.add(Dense(nodes[0], input_dim=input_dim,\\n activation=hidden_act))\\n\\n if dense_layers > 1:\\n for l in range(1, dense_layers - 1):\\n if do_layers[l - 1] != 0:\\n self.model.add(Dropout(do_layers[l - 1]))\\n\\n self.model.add(Dense(nodes[l], activation=hidden_act))\\n\\n self.model.add(Dense(1, activation=output_act))\",\n \"def _initialize_cnn(image_size, action_size, learning_rate=None):\\n\\n # All layers are randomly initialized using Glorot initializer\\n\\n # Create the Inputs of the Neural Network\\n image_input = Input(shape=(image_size, image_size, 1))\\n scalar_input = Input(shape=(2,))\\n\\n # Create the first layer of convolution\\n conv1 = Conv2D(filters=16,\\n kernel_size=5,\\n activation=\\\"relu\\\")(image_input)\\n\\n pool1 = MaxPooling2D(pool_size=3)(conv1)\\n\\n # Create the second layer of convolution\\n conv2 = Conv2D(filters=16,\\n kernel_size=3,\\n activation=\\\"relu\\\")(pool1)\\n pool2 = MaxPooling2D(pool_size=3)(conv2)\\n\\n # Create the third layer of convolution\\n conv3 = Conv2D(filters=16,\\n kernel_size=3,\\n activation=\\\"relu\\\")(pool2)\\n pool3 = MaxPooling2D(pool_size=2)(conv3)\\n\\n # Flatten the input, so it can be used with dense layers\\n flatten = Flatten()(pool3)\\n\\n # Merge the results of the convolutional layers with the scalar input\\n merge = concatenate([flatten, scalar_input])\\n\\n # Create the dense layers\\n # (256 neurons, ReLU)\\n dense1 = Dense(256,\\n activation=\\\"relu\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(merge)\\n dense2 = Dense(256,\\n activation=\\\"relu\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(dense1)\\n\\n # Create the output layer (action_size outputs, Lineal)\\n # Note that the output MUST be lineal (instead of the typical sigmoid function)\\n # for Deep Reinforcement Learning\\n output = Dense(action_size,\\n activation=\\\"linear\\\",\\n kernel_initializer=\\\"glorot_uniform\\\")(dense2)\\n\\n # Create and compile the model of the full CNN (Adam optimizer, MSE)\\n # Mean Square Error is used (instead of more typical cross-entropy values) due to Deep Reinforcement Learning\\n # (since MSE is the value trying to be minimized)\\n model = Model(inputs=[image_input, scalar_input],\\n outputs=output)\\n\\n # Note that beta_1 is set to 0.99 to improve the GPU performance while training\\n model.compile(optimizer=Adam(beta_1=0.99,\\n learning_rate=learning_rate) if learning_rate\\n else Adam(beta_1=0.99),\\n loss=\\\"mse\\\",\\n run_eagerly=True)\\n\\n return model\",\n \"def __init__(self, input_dim=3*32*32, hidden_dim=100, num_classes=10,\\n weight_scale=1e-3, reg=0.0):\\n self.params = {}\\n self.reg = reg\\n\\n ############################################################################\\n # TODO: Initialize the weights and biases of the two-layer net. Weights #\\n # should be initialized from a Gaussian centered at 0.0 with #\\n # standard deviation equal to weight_scale, and biases should be #\\n # initialized to zero. All weights and biases should be stored in the #\\n # dictionary self.params, with first layer weights #\\n # and biases using the keys 'W1' and 'b1' and second layer #\\n # weights and biases using the keys 'W2' and 'b2'. #\\n ############################################################################\\n self.params['W1'] = weight_scale * np.random.randn(input_dim, hidden_dim)\\n self.params['b1'] = np.zeros(hidden_dim)\\n self.params['W2'] = weight_scale * np.random.randn(hidden_dim, num_classes)\\n self.params['b2'] = np.zeros(num_classes)\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\",\n \"def __init__(self, network_path='.', logging=True,\\n input_image_size=None, n_input_channels=None,\\n n_output_classes=None,\\n fc1_dropout=1.0, alpha=4e-4 ):\\n self.logging = logging\\n\\n # If network path does not yet exists\\n self.network_path = network_path\\n if not os.path.isdir(self.network_path):\\n # Make network directory\\n os.mkdir(self.network_path)\\n now = datetime.datetime.now()\\n self.log(\\\"\\\\n\\\\n++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\"Creation of new network: \\\")\\n self.log( \\\" {}\\\".format(self.network_path) )\\n self.log( \\\" @ {}\\\".format(now.strftime(\\\"%Y-%m-%d %H:%M\\\")) )\\n self.log( \\\"++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log(\\\"\\\\nNetwork did not exist ... \\\")\\n self.log(\\\"Created new network with supplied (or default) architecture\\\")\\n\\n # Set up new network\\n self.y_res = input_image_size[0]\\n self.x_res = input_image_size[1]\\n self.n_input_channels = n_input_channels\\n self.n_output_classes = n_output_classes\\n self.fc1_dropout = fc1_dropout\\n self.alpha = alpha\\n self.n_samples_trained = 0\\n self.n_class_samples_trained = self.n_output_classes*[0]\\n self.n_samples_list = []\\n self.n_class_samples_list = [[] for _ in range(self.n_output_classes)]\\n self.accuracy_list = [[] for _ in range(self.n_output_classes)]\\n self.precision_list = [[] for _ in range(self.n_output_classes)]\\n self.recall_list = [[] for _ in range(self.n_output_classes)]\\n self.F1_list = [[] for _ in range(self.n_output_classes)]\\n\\n # Save network architecture\\n self.save_network_architecture( network_path=self.network_path )\\n\\n else:\\n now = datetime.datetime.now()\\n self.log(\\\"\\\\n\\\\n++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\"Re-initialization of existing network: \\\")\\n self.log( \\\" {}\\\".format(self.network_path) )\\n self.log( \\\" @ {}\\\".format(now.strftime(\\\"%Y-%m-%d %H:%M\\\")) )\\n self.log( \\\"++++++++++++++++++++++++++++++++++++++++++++++++++++\\\")\\n self.log( \\\" \\\")\\n\\n # Load network architecture from directory\\n net_architecture = self.load_network_architecture(self.network_path)\\n\\n # Set up network variables from loaded architecture\\n self.y_res = net_architecture['y_res']\\n self.x_res = net_architecture['x_res']\\n self.n_input_channels = net_architecture['n_input_channels']\\n self.n_output_classes = net_architecture['n_output_classes']\\n self.fc1_dropout = net_architecture['fc1_dropout']\\n self.alpha = net_architecture['alpha']\\n self.n_samples_trained = net_architecture['n_samples_trained']\\n self.n_class_samples_trained = net_architecture['n_class_samples_trained']\\n self.n_samples_list = net_architecture['n_samples_list']\\n self.n_class_samples_list = net_architecture['n_class_samples_list']\\n self.accuracy_list = net_architecture['accuracy_list']\\n self.precision_list = net_architecture['precision_list']\\n self.recall_list = net_architecture['recall_list']\\n self.F1_list = net_architecture['F1_list']\\n\\n # Update values of alpha and dropout if supplied\\n if self.alpha != alpha:\\n self.alpha = alpha\\n self.log(\\\"Updated learning rate 'alpha' to {}\\\".format(self.alpha))\\n if self.fc1_dropout != fc1_dropout:\\n self.fc1_dropout = fc1_dropout\\n self.log(\\\"Updated dropout fraction to {}\\\".format(self.fc1_dropout))\\n\\n # Clear previous graphs\\n tf.reset_default_graph()\\n\\n #########################################################\\n # Input and target variable placeholders\\n # x = [ m_samples x [channel_1_data, channel_2_data, etc.] ]\\n self.x = tf.placeholder( tf.float32, shape = [None,\\n self.n_input_channels * self.y_res * self.x_res] )\\n self.y_trgt = tf.placeholder( tf.float32, \\\\\\n shape = [None, self.n_output_classes] )\\n\\n # Set up dropout option for inputs\\n self.fc1_keep_prob = tf.placeholder(tf.float32)\\n self.x_drop = tf.nn.dropout(self.x, self.fc1_keep_prob)\\n\\n #########################################################\\n # Readout layer\\n # Weights and bias\\n self.fc_out_shape = \\\\\\n [self.y_res * self.x_res * self.n_input_channels,\\n self.n_output_classes]\\n self.W_fc_out = tf.Variable( tf.truncated_normal(\\n shape=self.fc_out_shape, stddev=0.1 ) )\\n self.b_fc_out = tf.Variable( tf.constant(0.1,\\n shape=[self.fc_out_shape[1]] ))\\n\\n # Calculate network step\\n self.fc_out_lin = tf.matmul( self.x_drop,\\n self.W_fc_out ) + self.b_fc_out\\n\\n #########################################################\\n # Define cost function and optimizer algorithm\\n self.cross_entropy = tf.reduce_mean(\\n tf.nn.softmax_cross_entropy_with_logits(\\n logits=self.fc_out_lin, labels=self.y_trgt ) )\\n self.train_step = tf.train.AdamOptimizer(self.alpha).minimize(\\n self.cross_entropy )\\n\\n #########################################################\\n # Define how to test trained model\\n self.network_prediction = tf.cast( tf.argmax(\\n self.fc_out_lin, 1 ), tf.float32 )\\n self.is_correct_prediction = tf.equal( tf.argmax( self.fc_out_lin, 1 ),\\n tf.argmax( self.y_trgt, 1 ) )\\n self.accuracy = tf.reduce_mean( tf.cast(\\n self.is_correct_prediction, tf.float32 ) )\\n\\n #########################################################\\n # Create save operation\\n self.saver = tf.train.Saver()\",\n \"def create_neural_network():\\n network_input = keras.layers.Input((NETWORK_INPUT_SIZE,))\\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_input)\\n network_layer = keras.layers.Dense(100, kernel_initializer='random_uniform', activation='tanh')(network_layer)\\n network_output = keras.layers.Dense(NETWORK_OUTPUT_SIZE, kernel_initializer='random_uniform', activation='linear')(network_layer)\\n network = keras.models.Model(inputs=network_input, outputs=network_output)\\n network.compile(loss=\\\"mse\\\", optimizer=\\\"Adam\\\")\\n return network\",\n \"def create_model_net(n_input,n_hidden,n_output):\\n net = Sequential(\\n L.Linear(n_input, n_hidden), F.relu,\\n L.Linear(n_hidden, n_hidden), F.relu,\\n L.Linear(n_hidden, n_output), F.softmax)\\n return net\",\n \"def setup_net(self):\\n\\t\\tself.src_net = get_model(self.base_model, num_cls=self.num_cls, \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t l2_normalize=self.l2_normalize, temperature=self.temperature)\\n\\t\\tself.tgt_net = self.custom_copy(self.src_net, self.weight_sharing)\\n\\n\\t\\tinput_dim = self.num_cls\\n\\t\\tself.discriminator = nn.Sequential(\\n\\t\\t\\t\\tnn.Linear(input_dim, 500),\\n\\t\\t\\t\\tnn.ReLU(),\\n\\t\\t\\t\\tnn.Linear(500, 500),\\n\\t\\t\\t\\tnn.ReLU(),\\n\\t\\t\\t\\tnn.Linear(500, 2),\\n\\t\\t\\t\\t)\\n\\n\\t\\tself.image_size = self.src_net.image_size\\n\\t\\tself.num_channels = self.src_net.num_channels\",\n \"def __init__(self):\\n super(CustomNetwork, self).__init__()\\n self.fc1 = nn.Linear(28*28, 500)\\n self.fc2 = nn.Linear(500, 256)\\n self.fc3 = nn.Linear(256, 10)\\n self.loss = Loss()\",\n \"def __init__(self, input_size, hidden_size, num_layers, nonlinearity=torch.tanh):\\n super().__init__()\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n\\n # input weights\\n self.weight_ih_l0 = Parameter(torch.Tensor(3*hidden_size, input_size))\\n\\n # hidden weights\\n self.weight_hh_l0 = Parameter(torch.Tensor(3*hidden_size, hidden_size))\\n\\n # bias\\n self.bias_ih_l0 = Parameter(torch.Tensor(3*hidden_size)) # input\\n self.bias_hh_l0 = Parameter(torch.Tensor(3*hidden_size)) # hidden\\n\\n self.f = nonlinearity\\n\\n self.init_weights()\",\n \"def initialize_network(self):\\n # intermediate layer size\\n ils = int((self.specbinnum + self.numfilters) / 2)\\n\\n network = lasagne.layers.InputLayer((None, 1, self.specbinnum, self.numtimebins), self.input_var)\\n\\n network = NormalisationLayer(network, self.specbinnum)\\n self.normlayer = network\\n\\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=ils)\\n network = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.numfilters)\\n network = batch_norm(network)\\n\\n network = lasagne.layers.NonlinearityLayer(network, nonlinearity=elu)\\n self.latents = network\\n network = ZeroOutBackgroundLatentsLayer(self.latents,\\n mp_down_factor=self.mp_down_factor,\\n numfilters=self.numfilters,\\n numtimebins=self.numtimebins,\\n background_latents_factor=self.background_latents_factor,\\n use_maxpool=self.use_maxpool)\\n network, _ = custom_convlayer_2(network, in_num_chans=self.numfilters, out_num_chans=ils)\\n network = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=ils, out_num_chans=self.specbinnum)\\n network = batch_norm(network)\\n\\n # output_size\\n num_time_samples = int(audioframe_len/2 * (self.numtimebins + 1))\\n # network = batch_norm(DenseLayer(network, num_time_samples)) # MemoryError\\n network, _ = custom_convlayer_2(network, in_num_chans=self.specbinnum, out_num_chans=num_time_samples)\\n network, _ = batch_norm(network)\\n network, _ = custom_convlayer_2(network, in_num_chans=num_time_samples, out_num_chans=1)\\n network, _ = batch_norm(network)\\n\\n self.network = network\",\n \"def __init__(self, nn_architecture, seed=99):\\n self.nn_architecture = nn_architecture\\n self.seed = seed\",\n \"def __init__(self, n_input, n_output, hidden_layer_size, reg):\\n self.reg = reg\\n self.fulllayer1 = FullyConnectedLayer(n_input, hidden_layer_size)\\n self.reglayer1 = ReLULayer()\\n self.fulllayer2 = FullyConnectedLayer(hidden_layer_size, n_output)\",\n \"def __init__(self, num_lemmas, num_pos, num_dep, num_directions=5, n_epochs=10, num_relations=2,\\n alpha=0.01, lemma_embeddings=None, dropout=0.0, use_xy_embeddings=False, num_hidden_layers=0):\\n self.n_epochs = n_epochs\\n self.num_lemmas = num_lemmas\\n self.num_pos = num_pos\\n self.num_dep = num_dep\\n self.num_directions = num_directions\\n self.num_relations = num_relations\\n self.alpha = alpha\\n self.dropout = dropout\\n self.use_xy_embeddings = use_xy_embeddings\\n self.num_hidden_layers = num_hidden_layers\\n self.update = True\\n\\n self.lemma_vectors = None\\n if lemma_embeddings is not None:\\n self.lemma_vectors = lemma_embeddings\\n self.lemma_embeddings_dim = lemma_embeddings.shape[1]\\n else:\\n self.lemma_embeddings_dim = LEMMA_DIM\\n\\n # Create the network\\n print 'Creating the network...'\\n self.builder, self.model, self.model_parameters = create_computation_graph(self.num_lemmas, self.num_pos,\\n self.num_dep, self.num_directions,\\n self.num_relations,\\n self.lemma_vectors,\\n use_xy_embeddings,\\n self.num_hidden_layers,\\n self.lemma_embeddings_dim)\\n print 'Done!'\",\n \"def test_ctor(self):\\r\\n # the network model itself\\r\\n model = densenet.DenseNet(\\r\\n depth=40,\\r\\n Block=densenet.BasicBlock,\\r\\n growth_rate=12,\\r\\n compression_rate=1.0,\\r\\n mask=True,\\r\\n num_classes=100,\\r\\n )\\r\\n num_params = model_utils.get_model_num_params(model)\\r\\n\\r\\n self.assertAlmostEqual(num_params, 1.06, places=1) # around 1.7\\r\\n self.assertEqual(model_utils.get_num_conv2d_layers(model), 40)\",\n \"def __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\\n print(\\\"Initialize model Multi-layer Perceptron\\\")\\n self.hidden_layer_sizes = hidden_layer_sizes\\n self.activation = activation\\n self.reg = reg\\n self.k_fold = k_fold\\n self.random_state = random_state\\n self.model = sklearn.neural_network.MLPClassifier(self.hidden_layer_sizes,\\n activation=self.activation,\\n alpha=self.reg, max_iter=1000, \\n random_state=self.random_state)\",\n \"def __init__(self, inputLayerSize, outputLayerSize, \\\\\\n hiddenLayerSize):\\n #Network hyperparameters - neurons per layer - **not altered by training**\\n self.inputLayerSize = inputLayerSize\\n self.outputLayerSize = outputLayerSize\\n self.hiddenLayerSize = hiddenLayerSize\\n self.num_params = inputLayerSize * hiddenLayerSize + \\\\\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\\\\n + outputLayerSize\\n #--Weights--\\n #w_ih - weights of synapses linking input -> hidden\\n self.w_ih = np.random.randn( self.inputLayerSize, \\\\\\n self.hiddenLayerSize)\\n #w_ho - weights of synapses linking hidden -> output\\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\\\\n self.outputLayerSize)\\n \\n #--Biases--\\n #b_h - biases of hidden layer\\n self.b_h = np.random.randn( self.hiddenLayerSize )\\n #b_o - biases of output layer\\n self.b_o = np.random.randn( self.outputLayerSize )\",\n \"def init_model(self, input_size, hidden_size, **kwargs):\\n # activation function for gates\\n self.gatefun = AcFun(kwargs.get('GATE_FUN') or 'sigmoid')\\n # parameters for input gate\\n self.igate = Nodes(input_size, hidden_size, kwargs.get('EN_BIAS'))\\n # parameters for forget gate\\n self.fgate = Nodes(input_size, hidden_size, kwargs.get('EN_BIAS'))\\n # parameters for output gate\\n self.ogate = Nodes(input_size, hidden_size, kwargs.get('EN_BIAS'))\\n super(LSTM, self).init_model(input_size, hidden_size, **kwargs)\",\n \"def __init__(self, latent_space, input_features):\\r\\n\\r\\n self._latent_space = latent_space\\r\\n self._input_cells = input_features\\r\\n\\r\\n self._encoder = None\\r\\n self._decoder = None\\r\\n self._autoencoder = None\\r\\n self._configure_network()\",\n \"def __init__(self,\\n num_actions,\\n name = None,\\n dropout = 0.0,\\n rand_conv = False,\\n projection = True,\\n **kwargs):\\n super(JumpyWorldNetwork, self).__init__(**kwargs)\\n self.kwargs = kwargs\\n self._dropout = dropout\\n self._num_actions = num_actions\\n if rand_conv:\\n self.rand_conv = RandConv()\\n else:\\n self.rand_conv = None\\n self._projection = projection\\n # Defining layers.\\n activation_fn = tf.keras.activations.relu\\n self.conv0 = tf.keras.layers.Conv2D(\\n 32, [8, 8],\\n strides=4,\\n padding='same',\\n activation=activation_fn,\\n name='Conv')\\n self.conv1 = tf.keras.layers.Conv2D(\\n 64, [4, 4],\\n strides=2,\\n padding='same',\\n activation=activation_fn,\\n name='Conv1')\\n self.conv2 = tf.keras.layers.Conv2D(\\n 64, [3, 3],\\n strides=1,\\n padding='same',\\n activation=activation_fn,\\n name='Conv2')\\n self.flatten = tf.keras.layers.Flatten()\\n self.dense0 = tf.keras.layers.Dense(256, activation=activation_fn)\\n self.dense1 = tf.keras.layers.Dense(64, activation=activation_fn)\\n self.dense2 = tf.keras.layers.Dense(num_actions, name='fully_connected')\",\n \"def build_neuron_network(nb_features_map: Union[Sequence[int], None] = None,\\n size_linear_layers: Union[Sequence[int], None] = None,\\n dropout_rate: Union[Tuple[float, float], float] = 0.3,\\n conv_kernel_size: Union[Sequence[int], int] = 3,\\n conv_stride: int = 1,\\n conv_padding: int = 1,\\n conv_activation: str = \\\"relu\\\",\\n conv_architecture: str = \\\"CPD\\\",\\n pool_kernel_size: int = 2,\\n pool_stride: int = 2,\\n dense_activation: str = \\\"relu\\\",\\n pretrained: Union[str, None] = None,\\n grayscale: bool = True,\\n optimizer: str = \\\"Adam\\\",\\n weight_decay: float = 0.,\\n learning_rate: float = 0.001,\\n ) -> Tuple[nn.Module, List, torch.optim.Optimizer]:\\n # Initializations\\n if pretrained is not None:\\n grayscale = False\\n if grayscale:\\n channels = 1\\n else:\\n channels = 3\\n if nb_features_map is None:\\n nb_features_map = [8]\\n if size_linear_layers is None:\\n size_linear_layers = []\\n height = 224\\n width = 224\\n module = nn.Module()\\n shapes = [(\\\"input\\\", channels, height, width)]\\n layers = {\\\"extractor\\\": [], \\\"regressor\\\": []}\\n if not hasattr(dropout_rate, \\\"__len__\\\"):\\n dropout_rate = (dropout_rate, 0.)\\n next_dropout_rate = dropout_rate[0]\\n # If a pretrained model is used:\\n if pretrained is None:\\n # Input checks\\n if hasattr(conv_kernel_size, \\\"__len__\\\"):\\n if len(conv_kernel_size) != len(nb_features_map):\\n raise ValueError(\\\"The length of nb_features_map shall match the length of conv_kernel_size\\\")\\n else:\\n conv_kernel_size = [conv_kernel_size] * len(nb_features_map)\\n # Feature extractor\\n next_layer_type = itertools.cycle(conv_architecture)\\n nb_feature_map = None\\n i = 0\\n while True:\\n layer_type = next(next_layer_type)\\n if layer_type == \\\"C\\\":\\n # Convolutional layer\\n try:\\n nb_feature_map = nb_features_map[i]\\n except IndexError:\\n break\\n name = \\\"conv2d-{:02d}\\\".format(i+1)\\n conv = nn.Conv2d(shapes[-1][1], nb_feature_map, conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n layers[\\\"extractor\\\"].append((name, conv))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=conv_kernel_size[i], stride=conv_stride,\\n padding=conv_padding)\\n shapes.append((name, nb_feature_map, h, w))\\n i += 1\\n # Activation\\n if conv_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif conv_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif conv_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(conv_activation, i)\\n layers[\\\"extractor\\\"].append((name, activ))\\n # activation does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n elif layer_type == \\\"P\\\":\\n # Max-pooling\\n name = \\\"maxpool2d-{:02d}\\\".format(i)\\n pool = nn.MaxPool2d(pool_kernel_size, pool_stride)\\n layers[\\\"extractor\\\"].append((name, pool))\\n h, w = output_shape_conv_and_pool_layer(rows=shapes[-1][2], columns=shapes[-1][3],\\n kernel=pool_kernel_size, stride=pool_stride)\\n shapes.append((name, nb_feature_map, h, w))\\n elif layer_type == \\\"D\\\":\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"extractor\\\"].append((name, dropout))\\n # Dropout does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n next_dropout_rate += dropout_rate[1]\\n elif layer_type == \\\"B\\\":\\n # Batch normalization\\n name = \\\"batchnorm-{:02d}\\\".format(i)\\n batch = nn.BatchNorm2d(shapes[-1][1])\\n layers[\\\"extractor\\\"].append((name, batch))\\n # Batch norm. does not change the size\\n shapes.append((name, shapes[-1][1], shapes[-1][2], shapes[-1][3]))\\n # Add a flatten layer\\n name = \\\"flatten\\\"\\n flatten = nn.Flatten(1)\\n layers[\\\"extractor\\\"].append((name, flatten))\\n shapes.append((name, shapes[-1][1] * shapes[-1][2] * shapes[-1][3]))\\n # Create extractor module\\n extractor = nn.Sequential(OrderedDict(layers[\\\"extractor\\\"]))\\n module.add_module(\\\"extractor\\\", extractor)\\n elif pretrained == \\\"VGG16\\\":\\n pre_trained = models.vgg16(pretrained=True)\\n modules = []\\n for _name, _module in pre_trained.named_children():\\n if _name != 'classifier':\\n modules.append((_name, _module))\\n modules.append((\\\"flatten\\\", nn.Flatten(1)))\\n vgg16 = nn.Sequential(OrderedDict(modules))\\n # Freeze all parameters in the pre-trained model\\n # So we prevent gradients from being calculated, it will save computation time\\n for param in vgg16.parameters():\\n param.requires_grad = False\\n module.add_module('extractor', vgg16)\\n shapes.append((pretrained, 25088))\\n else:\\n raise ValueError(f\\\"Unknown pre-trained model '{pretrained}'.\\\")\\n # Regressor\\n for i, size_linear_layer in enumerate(size_linear_layers):\\n # Add a linear layer\\n name = \\\"linear-{:02d}\\\".format(i + 1)\\n linear = nn.Linear(shapes[-1][1], size_linear_layer)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, size_linear_layer))\\n # Activation\\n if dense_activation == \\\"relu\\\":\\n activ = nn.ReLU()\\n elif dense_activation == \\\"elu\\\":\\n activ = nn.ELU(alpha=0.1)\\n elif dense_activation == \\\"leaky\\\":\\n activ = nn.LeakyReLU()\\n else:\\n activ = nn.ReLU()\\n name = \\\"{}-{:02d}\\\".format(dense_activation, i + 1)\\n layers[\\\"regressor\\\"].append((name, activ))\\n shapes.append((name, shapes[-1][1])) # activation does not change the size\\n # Dropout\\n if next_dropout_rate > 0.:\\n name = \\\"dropout-{:02d}\\\".format(i + 1)\\n dropout = nn.Dropout(p=next_dropout_rate)\\n layers[\\\"regressor\\\"].append((name, dropout))\\n shapes.append((name, shapes[-1][1])) # Dropout does not change the size of array\\n next_dropout_rate += dropout_rate[1]\\n # Add the final layer, the output size is fixed to 68 x 2 = 136\\n name = \\\"output\\\"\\n linear = nn.Linear(shapes[-1][1], 136)\\n layers[\\\"regressor\\\"].append((name, linear))\\n shapes.append((name, 136))\\n # Create regressor module\\n regressor = nn.Sequential(OrderedDict(layers[\\\"regressor\\\"]))\\n module.add_module(\\\"regressor\\\", regressor)\\n # Weight initialization\\n module.apply(weight_initialization)\\n # Optimizer\\n if optimizer == \\\"Adam\\\":\\n optim = torch.optim.Adam(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"AdamW\\\":\\n optim = torch.optim.AdamW(module.parameters(), lr=learning_rate, weight_decay=weight_decay)\\n elif optimizer == \\\"SGD\\\":\\n optim = torch.optim.SGD(module.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)\\n else:\\n raise ValueError(f\\\"Unknown optimizer {optimizer}.\\\")\\n return module, shapes, optim\",\n \"def __init__(self, obs_dim, *, seed=None):\\n # TODO: apply jax.jit() to everything in sight\\n net_init, self._net_apply = self.make_stax_model()\\n if seed is None:\\n # oh well\\n seed = np.random.randint((1 << 63) - 1)\\n rng = jrandom.PRNGKey(seed)\\n out_shape, self._net_params = net_init(rng, (-1, obs_dim))\\n self._net_grads = jax.grad(self._net_apply)\\n # output shape should just be batch dim, nothing else\\n assert out_shape == (-1,), \\\"got a weird output shape %s\\\" % (out_shape,)\",\n \"def create(self):\\n output = None\\n if self.output_bias is not None:\\n output_bias = tf.keras.initializers.Constant(self.output_bias)\\n else:\\n output_bias = None\\n kernel_init = None\\n if self.activation_name == 'relu' or self.activation_name == 'elu':\\n # Kaiming He initialization\\n kernel_init = tf.keras.initializers.he_normal()\\n elif self.activation_name == 'selu':\\n # LeCun initialization\\n kernel_init = tf.keras.initializers.lecun_uniform()\\n elif self.activation_name == 'tanh' or self.activation_name == \\\\\\n 'sigmoid':\\n # Xavier Glorot initialization\\n kernel_init = tf.keras.initializers.glorot_uniform()\\n if self.layer_type == 'dense':\\n kernel_reg = tf.keras.regularizers.l1_l2(l1=self.l1_reg,\\n l2=self.l2_reg)\\n output = tf.keras.layers.Dense(units=self.n_nodes,\\n activation=self.activation_name,\\n bias_initializer=output_bias,\\n kernel_initializer=kernel_init,\\n kernel_regularizer=kernel_reg,\\n name=self.name)\\n # elif self.layer_type == 'clipping':\\n # output = Clipping(self.upper)\\n elif self.layer_type == 'dropout':\\n output = tf.keras.layers.Dropout(rate=self.dropout_rate,\\n name=self.name)\\n return output\",\n \"def build_model_mobilenet(num_classes):\",\n \"def make_architecture(self, X, Y):\\n\\n sh = X[0].shape\\n ip = Input(shape=sh)\\n h = ip\\n h = Flatten()(h) if len(sh) > 1 else h\\n\\n for i in range(2):\\n h = Dense(128, W_constraint=WeightClip(), bias_constraint=WeightClip())(h)\\n h = LeakyReLU()(h)\\n\\n # final output - single score value\\n h = Dense(1, W_constraint=WeightClip(), bias_constraint=WeightClip())(h)\\n\\n self.model = Model(inputs=ip, outputs=h)\\n return self\",\n \"def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\\n super().__init__(input_nodes, hidden_nodes, hidden_layers, output_nodes)\",\n \"def buildNet(inputShape, numUniqueClasses):\\n layers = InputLayer((None,) + inputShape[1:4])\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1))\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1), stride= (5,1))\\n layers = ResidualLayer(layers, 8, \\n filter_size = (3,1))\\n layers = ResidualLayer(layers, 1, \\n filter_size = (3,1), stride= (3,1))\\n layers = NonlinearityLayer(layers, nonlinearity = nonlinearity)\\n layers = DropoutLayer(layers,p=.3) \\n layers = batch_norm(NNHelpers.LocallyConnected2DLayer(layers,1,(5,1),\\n W=He('relu'),\\n nonlinearity=nonlinearity)) \\n layers = DenseLayer(layers,num_units=numUniqueClasses,\\n nonlinearity=linear) \\n layers = NonlinearityLayer(layers, nonlinearity=softmax) \\n return layers\",\n \"def __init__(self, session, input_size, seq_size, output_size, learning_rate, model_name, net_name):\\n self.session = session\\n self.input_size = input_size\\n self.seq_size = seq_size\\n self.output_size = output_size\\n\\n self.learning_rate = learning_rate\\n self.net_name = net_name\\n self.x = None\\n self.model_name = model_name\\n\\n self._build_network()\",\n \"def __init__(self, D_in, D_out, H, learning_rate):\\n self.model = th.nn.Sequential(\\n th.nn.Linear(D_in, H),\\n th.nn.Tanh(),\\n th.nn.Linear(H, D_out),\\n ).double()\\n\\n for x in self.model.modules():\\n if isinstance(x, th.nn.Linear):\\n x.weight.data = th.normal(means=th.zeros(x.weight.size())).type(dtype)\\n x.bias.data = th.zeros(x.bias.size()).type(dtype)\\n\\n self.H = H\\n self.lr = learning_rate\\n self.loss_fn = th.nn.MSELoss(size_average=False)\",\n \"def create_model(self): # noqa: D103\\n # reference for creation of the model https://yilundu.github.io/2016/12/24/Deep-Q-Learning-on-Space-Invaders.html\\n model=Sequential()\\n model.add(Flatten( input_shape=(84,84,4)))\\n model.add(Dense(self.num_actions)) \\n\\n return model\",\n \"def _generate_network_initialization(self, graph, memory_manager):\\n\\n # TODO: To be changed if we want to support multiple outputs\\n output_buffer_name = graph.outputs[0].name\\n\\n ops_to_ignore = ['Reshape', 'Mul']\\n\\n buffers_allocated = []\\n\\n buffer_declaration = \\\"\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **kernels;\\\\n\\\"\\n buffer_declaration += \\\" pico_cnn::naive::Tensor **biases;\\\\n\\\"\\n\\n constructor_code = \\\"\\\"\\n #constructor_code += \\\"Network::Network() {\\\\n\\\\n\\\"\\n\\n num_layers = 0\\n num_kernels = 0\\n num_biases = 0\\n\\n for node in graph.nodes:\\n \\\"\\\"\\\"Do not count the reshape layers as the input tensor will only define the dimensions\\\"\\\"\\\"\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n num_layers += 1\\n for num, input in enumerate(node.input_tensors):\\n if input in buffers_allocated:\\n continue\\n else:\\n tensor = node.input_tensors[input]\\n buffers_allocated.append(input)\\n if len(tensor.shape) == 1:\\n num_biases += 1\\n else:\\n num_kernels += 1\\n\\n \\\"\\\"\\\"The arrays kernels and biases will be used to pass only two variables to read_binary_weights\\\"\\\"\\\"\\n constructor_code += \\\" kernels = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\".format(num_kernels)\\n constructor_code += \\\" biases = new pico_cnn::naive::Tensor*[{}]();\\\\n\\\\n\\\".format(num_biases)\\n\\n pos = -1\\n pos_kernel = -1\\n pos_bias = -1\\n\\n buffers_allocated.clear()\\n\\n \\\"\\\"\\\"Iterate over all nodes in the graph and generate the corresponding allocation code.\\\"\\\"\\\"\\n for node_id, node in enumerate(graph.nodes):\\n\\n if len(node.input_tensors) > 0 and node.op_type not in ops_to_ignore:\\n pos += 1\\n\\n buffer_declaration += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n constructor_code += \\\" // Layer: \\\" + node.name + \\\", Operation: \\\" + node.op_type + \\\"\\\\n\\\"\\n\\n # Allocate memory for kernels and biases\\n buffer_declaration += \\\" // Inputs\\\\n\\\"\\n constructor_code += \\\" // Inputs\\\\n\\\"\\n for num, input in enumerate(node.input_tensors):\\n\\n if node.op_type in ops_to_ignore:\\n continue\\n\\n if input in buffers_allocated:\\n continue\\n else:\\n buffers_allocated.append(input)\\n\\n tensor = node.input_tensors[input]\\n if len(tensor.shape) == 1:\\n pos_bias += 1\\n else:\\n pos_kernel += 1\\n\\n buffer = memory_manager.get_buffer(graph, input)\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"KernelAllocation\\\")\\n impl = functionality[0].create(buffer, pos, pos_kernel, pos_bias)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\" // Outputs\\\\n\\\"\\n constructor_code += \\\" // Outputs\\\\n\\\"\\n for num, output in enumerate(node.outputs):\\n\\n buffer = memory_manager.get_buffer(graph, output)\\n\\n if output == output_buffer_name:\\n buffer_declaration += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n constructor_code += \\\" // Output tensor {} with shape {} of network provided as argument of Network::run()\\\".format(buffer.name, str(buffer.shape))\\n continue\\n\\n buffer_declaration += \\\" // \\\" + str(buffer.shape) + \\\"\\\\n\\\"\\n\\n pico_cnn_tensor = \\\" pico_cnn::naive::Tensor *\\\"\\n\\n buffer_declaration += pico_cnn_tensor + buffer.name + \\\";\\\\n\\\"\\n\\n constructor_code += \\\" // \\\" + str(buffer.shape) + \\\"\\\" # TODO maybe we sometimes need \\\\n\\n\\n functionality = CodeRegistry.get_funct(\\\"OutputAllocation\\\")\\n impl = functionality[0].create(buffer)\\n\\n if impl:\\n constructor_code += impl.generate_code()\\n constructor_code += \\\"\\\\n\\\"\\n\\n buffer_declaration += \\\"\\\\n\\\\n\\\"\\n constructor_code += \\\"\\\\n\\\\n\\\"\\n\\n #constructor_code += \\\"}\\\\n\\\"\\n\\n self.buffer_declaration = buffer_declaration\\n self.constructor_code = constructor_code\",\n \"def __init__(self, state_dim, action_dim, learning_rate, weight_decay):\\n self.dynamics_net = ForwardModel(state_dim, action_dim)\\n self.rewards_net = RewardModel(state_dim, action_dim)\\n self.done_net = RewardModel(state_dim, action_dim)\\n\\n self.dyn_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\\n self.reward_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\\n self.done_optimizer = tfa_optimizers.AdamW(\\n learning_rate=learning_rate, weight_decay=weight_decay)\",\n \"def initialise_network(self):\\n raise NotImplementedError\",\n \"def _build_model(self):\\n if self.weight_function is None:\\n self.weight_function = default_weight_function\\n\\n tf.reset_default_graph()\\n\\n # Placeholders for the inputs\\n self.x0 = tf.placeholder(\\n shape=[None, self.num_features],\\n dtype=self.dtype,\\n name=\\\"x0\\\"\\n )\\n self.x1 = tf.placeholder(\\n shape=[None, self.num_features],\\n dtype=self.dtype,\\n name=\\\"x1\\\"\\n )\\n # Placeholder for the real classes\\n self.y0 = tf.placeholder(\\n shape=[None, 1],\\n dtype=self.dtype,\\n name=\\\"y0\\\"\\n )\\n # Placeholder for the weights\\n self.w0 = tf.placeholder(\\n shape=[None, ],\\n dtype=self.dtype,\\n name=\\\"w0\\\"\\n )\\n\\n # Drop placeholder\\n self.should_drop = tf.placeholder(tf.bool, name=\\\"drop\\\")\\n\\n # Regularization\\n regularizer = tf.keras.regularizers.l2(self.weight_regularization)\\n\\n # Input_Dropout\\n in0 = tf.layers.dropout(inputs=self.x0,\\n rate=self.input_dropout,\\n training=self.should_drop\\n )\\n\\n in1 = tf.layers.dropout(inputs=self.x1,\\n rate=self.input_dropout,\\n training=self.should_drop\\n )\\n\\n # Constructing the feature creation part of the net\\n nn0 = tf.layers.dense(\\n inputs=in0,\\n units=self.hidden_layers[0],\\n activation=self.feature_activation,\\n use_bias=self.feature_bias,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_hidden_0\\\"\\n )\\n\\n # By giving nn1 the same name as nn0 and using the flag reuse=True,\\n # the weights and biases of all neurons in each branch are identical\\n nn1 = tf.layers.dense(\\n inputs=in1,\\n units=self.hidden_layers[0],\\n activation=self.feature_activation,\\n use_bias=self.feature_bias,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_hidden_0\\\",\\n reuse=True\\n )\\n\\n # Layer Dropout\\n nn0 = tf.layers.dropout(inputs=nn0,\\n rate=self.dropout,\\n training=self.should_drop\\n )\\n nn1 = tf.layers.dropout(inputs=nn1,\\n rate=self.dropout,\\n training=self.should_drop\\n )\\n\\n for i in range(1, len(self.hidden_layers)):\\n nn0 = tf.layers.dense(\\n inputs=nn0,\\n units=self.hidden_layers[i],\\n activation=self.feature_activation,\\n use_bias=self.feature_bias,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_hidden_\\\" + str(i)\\n )\\n nn1 = tf.layers.dense(\\n inputs=nn1,\\n units=self.hidden_layers[i],\\n activation=self.feature_activation,\\n use_bias=self.feature_bias,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_hidden_\\\" + str(i),\\n reuse=True\\n )\\n\\n # Layer Dropout\\n nn0 = tf.layers.dropout(inputs=nn0,\\n rate=self.dropout,\\n training=self.should_drop\\n )\\n nn1 = tf.layers.dropout(inputs=nn1,\\n rate=self.dropout,\\n training=self.should_drop\\n )\\n\\n # Creating antisymmetric features for the ranking\\n self.nn = (nn0 - nn1) / 2.\\n\\n self.nn = tf.layers.dense(\\n inputs=self.nn,\\n units=1,\\n activation=self.ranking_activation,\\n use_bias=False,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_rank\\\"\\n )\\n\\n self.nn_cls = tf.layers.dense(\\n inputs=nn0 / 2.,\\n units=1,\\n activation=self.ranking_activation,\\n use_bias=False,\\n kernel_initializer=self.kernel_initializer,\\n kernel_regularizer=regularizer,\\n name=\\\"nn_rank\\\",\\n reuse=True\\n )\\n\\n nn_out = tf.identity(\\n input=self.nn,\\n name=\\\"nn\\\"\\n )\",\n \"def __build_nn_architecture(self, dim_Y, hidden_dimensions):\\n Y = tf.placeholder(tf.float32, shape=[None, dim_Y])\\n config = tf.placeholder(tf.float32, shape=[None, len(self.knob_cols)])\\n placeholders = [config, Y]\\n weights, biases, outputs = self.__make_fc_layers(\\n Y, dim_Y, hidden_dimensions, self.activations, trainable=[True] *\\n (len(hidden_dimensions) + 1))\\n architecture = [placeholders, weights, biases, outputs]\\n return architecture\",\n \"def __init__(self, N_neurons, opt_kwargs): \\n # Define global step for checkpointing.\\n self.global_step=tf.Variable(0, dtype=tf.int32, trainable=False, name=\\\"global_step\\\")\\n\\n self.L=40 # system linear size\\n self.n_feats=self.L**2 # 40x40 square lattice\\n self.n_categories=2 # 2 Ising phases: ordered and disordered\\n\\n # Create placeholders for input X and label Y.\\n self.create_placeholders()\\n # Create weight and bias, initialized to 0 and construct DNN to predict Y from X.\\n self.deep_layer_neurons=N_neurons\\n self.create_DNN()\\n # Define loss function.\\n self.create_loss()\\n # Use gradient descent to minimize loss.\\n self.create_optimiser(opt_kwargs)\\n # Create accuracy.\\n self.create_accuracy()\",\n \"def init_dense(self, layer):\\n pass\",\n \"def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):\\n # set number of nodes in each input, hidden, output layer\\n self.inodes = inputnodes\\n self.hnodes = hiddennodes\\n self.onodes = outputnodes\\n\\n #learning rate\\n self.lr = learningrate\",\n \"def __init__(self, incoming, n_units, flatten_input=False, W=tf.zeros, b=tf.zeros, a=tf.sigmoid, name='DenseLayer'):\\n super(DenseLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n \\n if (len(self.incoming_shape) > 2) and flatten_input:\\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\\n elif len(self.incoming_shape) == 4:\\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\\n elif len(self.incoming_shape) >= 5:\\n incoming_shape = [self.incoming_shape[0], self.incoming_shape[1], np.prod(self.incoming_shape[2:])]\\n else:\\n incoming_shape = self.incoming_shape\\n \\n # Set init for W\\n W = tofov(W, shape=[incoming_shape[-1], n_units], var_params=dict(name='W_dense'))\\n \\n # Set init for b\\n if b is not None:\\n b = tofov(b, [n_units], var_params=dict(name='b_dense'))\\n \\n self.a = a\\n self.b = b\\n self.W = W\\n \\n self.n_units = n_units\\n self.flatten_input = flatten_input\\n self.incoming_shape = incoming_shape\\n \\n self.out = tf.zeros(self.get_output_shape())\\n self.name = name\",\n \"def build_densenet(l_in, input_var=None, first_output=64, growth_rate=32, num_blocks=4, dropout=0):\\n \\n\\n nb_layers = [6, 12, 32, 32] # For DenseNet-169\\n nb_layers = [6, 12, 24, 16] # For DenseNet-121\\n # initial convolution\\n network = Conv2DLayer(l_in, first_output, filter_size=7, stride=2, pad='same',\\n W=lasagne.init.HeNormal(gain='relu'),\\n b=None, nonlinearity=None, name='pre_conv')\\n network = BatchNormLayer(network, name='pre_bn', beta=None, gamma=None)\\n network = ScaleLayer(network, name='pre_scale')\\n network = BiasLayer(network, name='pre_shift')\\n network = dnn.MaxPool2DDNNLayer(network, pool_size=3, stride=2) \\n # note: The authors' implementation does *not* have a dropout after the\\n # initial convolution. This was missing in the paper, but important.\\n # if dropout:\\n # network = DropoutLayer(network, dropout)\\n # dense blocks with transitions in between\\n\\n for b in range(num_blocks):\\n network = dense_block(network, nb_layers[b], growth_rate, dropout,\\n name_prefix='block%d' % (b + 1))\\n if b < num_blocks - 1:\\n network = transition(network, dropout,\\n name_prefix='block%d_trs' % (b + 1))\\n # post processing until prediction\\n network = ScaleLayer(network, name='post_scale')\\n network = BiasLayer(network, name='post_shift')\\n network = NonlinearityLayer(network, nonlinearity=rectify, name='post_relu')\\n\\n return network\",\n \"def LeNet5_architecture(self, input_shape):\\r\\n\\r\\n # Convolution layer (C1) hyperparameters\\r\\n s1 = self.hparameters[\\\"s1\\\"]\\r\\n f1 = self.hparameters[\\\"f1\\\"]\\r\\n n1 = self.hparameters[\\\"n1\\\"]\\r\\n\\r\\n # Average pooling layer(S2) hyperparameters\\r\\n s2 = self.hparameters[\\\"s2\\\"]\\r\\n f2 = self.hparameters[\\\"f2\\\"]\\r\\n\\r\\n # Convolutional layer (C3) hyperparameters\\r\\n s3 = self.hparameters[\\\"s3\\\"]\\r\\n f3 = self.hparameters[\\\"f3\\\"]\\r\\n n3 = self.hparameters[\\\"n3\\\"]\\r\\n\\r\\n # Average pooling layers (S4) hyperparameters\\r\\n s4 = self.hparameters[\\\"s4\\\"]\\r\\n f4 = self.hparameters[\\\"f4\\\"]\\r\\n\\r\\n # Convolutional layer (C5) hyperparameters\\r\\n s5 = self.hparameters[\\\"s5\\\"]\\r\\n f5 = self.hparameters[\\\"f5\\\"]\\r\\n n5 = self.hparameters[\\\"n5\\\"]\\r\\n\\r\\n # Number of outputs\\r\\n num_classes = self.num_classes\\r\\n\\r\\n X_input = Input(input_shape)\\r\\n X = X_input\\r\\n\\r\\n # Convolution layer 1\\r\\n X = Conv2D(n1, (f1,f1), strides = (s1, s1), padding = 'valid', name = 'C1', kernel_initializer = glorot_uniform(seed = 0))(X)\\r\\n # Average pooling\\r\\n X = AveragePooling2D(pool_size= (f2,f2), strides = (s2,s2), padding = 'valid', name = 'S2')(X)\\r\\n # Activation\\r\\n X = Activation('tanh')(X)\\r\\n # Convolution layer 2\\r\\n X = Conv2D(n3, (f3,f3), strides = (s3, s3), padding = 'valid', name = 'C3', kernel_initializer = glorot_uniform(seed = 0))(X)\\r\\n #Average pooling\\r\\n X = AveragePooling2D(pool_size= (f4,f4), strides = (s4,s4), padding = 'valid', name = 'S4')(X)\\r\\n # Activation\\r\\n X = Activation('tanh')(X)\\r\\n # Convolutional layer 3\\r\\n X = Conv2D(n5, (f5,f5), strides = (s5, s5), padding = 'valid', name = 'C5', kernel_initializer = glorot_uniform(seed = 0))(X)\\r\\n # Activation\\r\\n X = Activation('tanh')(X)\\r\\n # Flatten\\r\\n X = Flatten()(X)\\r\\n # Fully Connected layer\\r\\n X = Dense(num_classes, activation = 'softmax', name = 'FC', kernel_initializer = glorot_uniform(seed = 0))(X)\\r\\n\\r\\n #create model\\r\\n model = Model(inputs = X_input, outputs = X, name = 'LeNet5')\\r\\n\\r\\n return model\",\n \"def __init__(self, *args, **kwargs):\\n self.params = kwargs\\n self.output_len = kwargs['num_neurons']\\n self.input_len = kwargs['input_len']\\n self.weights = Vector(data=np.random.randn(self.output_len, self.input_len))\\n self.biases = Vector(data=np.zeros((self.output_len, 1)))\\n self.input_activations = None\\n self.output_activations = Vector()\",\n \"def _init_networks(self, state_dict: OrderedDict):\\n self.dqn = Brain(self.backbone_cfg, self.head_cfg).to(self.device)\\n self.dqn.load_state_dict(state_dict)\\n self.dqn.eval()\",\n \"def __init__(self, dropout, nonlinearity):\\n super(LeNet300, self).__init__()\\n\\n layers = [(784, 300), (300, 100), (100, 10)]\\n\\n cfg = [('reshape', LambdaLayer(lambda x: x.view(x.size(0),-1)))]\\n for i, l in enumerate(layers):\\n cfg.append(('compressible_' + str(i), nn.Linear(*l)))\\n if i != len(layers)-1:\\n # only non terminal layers have nonlinearity and (possible) dropouts\\n cfg.append(('nonlinearity_' + str(i), nonlinearity()))\\n if dropout:\\n cfg.append(('drop_'+str(i), nn.Dropout()))\\n\\n self.output = nn.Sequential(OrderedDict(cfg))\\n self.loss = nn.CrossEntropyLoss()\\n self.apply(_weights_init)\",\n \"def __init__(\\n self, state_dim, action_dim, sizes, activations, use_batch_norm: bool = False\\n ) -> None:\\n super().__init__()\\n assert state_dim > 0, \\\"state_dim must be > 0, got {}\\\".format(state_dim)\\n assert action_dim > 0, \\\"action_dim must be > 0, got {}\\\".format(action_dim)\\n self.state_dim = state_dim\\n self.action_dim = action_dim\\n assert len(sizes) == len(\\n activations\\n ), \\\"The numbers of sizes and activations must match; got {} vs {}\\\".format(\\n len(sizes), len(activations)\\n )\\n\\n # The last layer gives the concentration of the distribution.\\n self.fc = FullyConnectedNetwork(\\n [state_dim] + sizes + [action_dim],\\n activations + [\\\"linear\\\"],\\n use_batch_norm=use_batch_norm,\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69732815","0.69310397","0.6879293","0.6875603","0.6796704","0.6787399","0.6776941","0.6755538","0.673781","0.67071885","0.66999316","0.6690914","0.6687706","0.6639211","0.6602322","0.65980804","0.6596391","0.65892094","0.65678","0.6567025","0.6549191","0.65445906","0.65141255","0.6504316","0.6494444","0.64922917","0.6486867","0.6480577","0.6479416","0.64673054","0.6466779","0.64473456","0.64401644","0.6420957","0.64119774","0.6411143","0.640327","0.6401053","0.6398763","0.6376252","0.63680005","0.6359063","0.6353078","0.63434005","0.63429505","0.6341815","0.63411635","0.63399047","0.63396645","0.63273865","0.6317193","0.63149214","0.63082105","0.6307375","0.6305125","0.6302656","0.6297439","0.6286205","0.6285206","0.62836146","0.62828946","0.6266431","0.6265438","0.625807","0.6257997","0.6256707","0.62490463","0.6248045","0.62439096","0.6242733","0.6236635","0.623356","0.6228069","0.6226185","0.6224112","0.62239313","0.62227815","0.62221426","0.6218057","0.6216757","0.6213266","0.621229","0.6210841","0.6209744","0.620962","0.6203918","0.6201944","0.6201077","0.61974317","0.6197387","0.61968255","0.61926407","0.619035","0.61831623","0.6180332","0.6179187","0.6174571","0.61706716","0.6169507","0.61676276","0.61661655"],"string":"[\n \"0.69732815\",\n \"0.69310397\",\n \"0.6879293\",\n \"0.6875603\",\n \"0.6796704\",\n \"0.6787399\",\n \"0.6776941\",\n \"0.6755538\",\n \"0.673781\",\n \"0.67071885\",\n \"0.66999316\",\n \"0.6690914\",\n \"0.6687706\",\n \"0.6639211\",\n \"0.6602322\",\n \"0.65980804\",\n \"0.6596391\",\n \"0.65892094\",\n \"0.65678\",\n \"0.6567025\",\n \"0.6549191\",\n \"0.65445906\",\n \"0.65141255\",\n \"0.6504316\",\n \"0.6494444\",\n \"0.64922917\",\n \"0.6486867\",\n \"0.6480577\",\n \"0.6479416\",\n \"0.64673054\",\n \"0.6466779\",\n \"0.64473456\",\n \"0.64401644\",\n \"0.6420957\",\n \"0.64119774\",\n \"0.6411143\",\n \"0.640327\",\n \"0.6401053\",\n \"0.6398763\",\n \"0.6376252\",\n \"0.63680005\",\n \"0.6359063\",\n \"0.6353078\",\n \"0.63434005\",\n \"0.63429505\",\n \"0.6341815\",\n \"0.63411635\",\n \"0.63399047\",\n \"0.63396645\",\n \"0.63273865\",\n \"0.6317193\",\n \"0.63149214\",\n \"0.63082105\",\n \"0.6307375\",\n \"0.6305125\",\n \"0.6302656\",\n \"0.6297439\",\n \"0.6286205\",\n \"0.6285206\",\n \"0.62836146\",\n \"0.62828946\",\n \"0.6266431\",\n \"0.6265438\",\n \"0.625807\",\n \"0.6257997\",\n \"0.6256707\",\n \"0.62490463\",\n \"0.6248045\",\n \"0.62439096\",\n \"0.6242733\",\n \"0.6236635\",\n \"0.623356\",\n \"0.6228069\",\n \"0.6226185\",\n \"0.6224112\",\n \"0.62239313\",\n \"0.62227815\",\n \"0.62221426\",\n \"0.6218057\",\n \"0.6216757\",\n \"0.6213266\",\n \"0.621229\",\n \"0.6210841\",\n \"0.6209744\",\n \"0.620962\",\n \"0.6203918\",\n \"0.6201944\",\n \"0.6201077\",\n \"0.61974317\",\n \"0.6197387\",\n \"0.61968255\",\n \"0.61926407\",\n \"0.619035\",\n \"0.61831623\",\n \"0.6180332\",\n \"0.6179187\",\n \"0.6174571\",\n \"0.61706716\",\n \"0.6169507\",\n \"0.61676276\",\n \"0.61661655\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":19798,"cells":{"query":{"kind":"string","value":"For disordered systems with relaxed atomic positions, it might be better to use initial atomic positions to use the symmetry of the structure (POSCAR_initial)."},"document":{"kind":"string","value":"def run(self):\n poscar = Poscar('POSCAR')\n number_of_atoms = poscar.get_atoms().get_number_of_atoms()\n dummy_symbols = self.create_dummy_symbols(number_of_atoms)\n poscar.get_atoms().set_chemical_symbols(dummy_symbols)\n poscar.write_poscar('POSCAR_ideal')"},"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 propanolIntermediate():\n coords = [\n [-1.60306996, 0.10333519, 0.50792736],\n [-0.66904416, -0.46962566, -0.55371646],\n [0.67345677, 0.26436258, -0.61179298],\n [1.26292797, -0.10585085, -1.45392921],\n [0.49744830, 1.34089332, -0.75955140],\n [1.47742183, 0.05176805, 0.52349829],\n [0.98773122, 0.34094585, 1.30125393],\n [-0.48213061, -1.52528483, -0.34815476],\n [-1.14165995, -0.39229359, -1.53423716],\n [-2.56608070, -0.40007121, 0.47312929],\n [-1.76619136, 1.16652831, 0.34003517],\n [-1.19366144, -0.03197289, 1.50775619],\n ]\n\n symbols = [\n \"C\",\n \"C\",\n \"C\",\n \"H\",\n \"H\",\n \"O\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n ]\n\n atoms = []\n for i, _ in enumerate(coords):\n atoms.append(Atom(symbols[i], position=coords[i]))\n return Molecule(symbols=atoms)","def propanolLowest():\n coords = [\n [-1.9554949371, 0.1467391618, 0.0031595607],\n [-0.5906278346, -0.5279387138, -0.0201649611],\n [0.5440986558, 0.4958779663, 0.0283462055],\n [0.4812068385, 1.1678478833, -0.8308000219],\n [0.4590669813, 1.0993020658, 0.9450529713],\n [1.8195161785, -0.0957487212, -0.0534239359],\n [1.9103706588, -0.7338049177, 0.6631507673],\n [-0.5004127933, -1.2028008461, 0.8364936998],\n [-0.4854009629, -1.1250023438, -0.9282499098],\n [-2.7476736372, -0.5972665554, -0.0242488945],\n [-2.0700756998, 0.8040326560, -0.8554507953],\n [-2.0722381370, 0.7410005769, 0.9069567477],\n ]\n\n symbols = [\n \"C\",\n \"C\",\n \"C\",\n \"H\",\n \"H\",\n \"O\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n \"H\",\n ]\n\n atoms = []\n for i, _ in enumerate(coords):\n atoms.append(Atom(symbols[i], position=coords[i]))\n return Molecule(symbols=atoms)","def parse_POSCAR(POSCAR=\"POSCAR\"):\n\n fin = open(POSCAR, 'r')\n poscar = fin.read().splitlines()\n scaling_para = float(poscar[1])\n abc = np.array([[float(i) for i in line.split()] for line in poscar[2:5]])\n\n # lattice constants in angstrom\n latt_mat = abc * scaling_para\n length_a = np.linalg.norm(latt_mat[0, :], 2)\n length_b = np.linalg.norm(latt_mat[1, :], 2)\n length_c = np.linalg.norm(latt_mat[2, :], 2)\n latt_consts = [length_a, length_b, length_c]\n\n # angles in degrees\n alpha = angle_btw(abc[1, :], abc[2, :])\n beta = angle_btw(abc[0, :], abc[2, :])\n gamma = angle_btw(abc[0, :], abc[1, :])\n angles = [alpha, beta, gamma]\n\n # Lines 6 and 7 of POSCAR. atomic species and corresponding atoms numbers\n atomNames = poscar[5].split()\n atomNums = list(map(int, poscar[6].split()))\n # combine atom names and numbers into a dict\n atomNum_Dict = dict(zip(atomNames, atomNums))\n # read in the coordinates of each species\n atomCoor_Dict = dict.fromkeys(atomNum_Dict, [])\n st_line = 8 # starting line number of atom coordinates\n for i in atomCoor_Dict.keys():\n end_line = st_line + atomNum_Dict[i]\n coor = np.array([[float(e) for e in line.split()[0:3]] for line in poscar[st_line: end_line]])\n st_line = end_line\n atomCoor_Dict[i] = coor\n fin.close()\n\n return latt_mat, latt_consts, angles, atomNum_Dict, atomCoor_Dict","def p2orbit(p, primary, verbose=False):\n o = Orbit()\n if primary.m <= TINY:\n if verbose is True:\n print(\"Star has no mass.\")\n return o # all values set to None\n \n dx = p.x - primary.x\n dy = p.y - primary.y\n dz = p.z - primary.z\n o.r = math.sqrt ( dx*dx + dy*dy + dz*dz )\n if o.r <= TINY:\n if verbose is True:\n print('Particle and primary positions are the same.')\n return o\n \n dvx = p.vx - primary.vx\n dvy = p.vy - primary.vy\n dvz = p.vz - primary.vz\n v = math.sqrt ( dvx*dvx + dvy*dvy + dvz*dvz )\n \n mu = G*(p.m+primary.m)\n o.a = -mu/( v*v - 2.*mu/o.r ) # semi major axis\n \n h0 = (dy*dvz - dz*dvy) # angular momentum vector\n h1 = (dz*dvx - dx*dvz)\n h2 = (dx*dvy - dy*dvx)\n o.h = math.sqrt ( h0*h0 + h1*h1 + h2*h2 ) # abs value of angular momentum\n if o.h/o.r/v <= MIN_REL_ERROR:\n if verbose is True:\n print('Particle orbit is radial.')\n return o\n \n vr = (dx*dvx + dy*dvy + dz*dvz)/o.r\n e0 = 1./mu*( (v*v-mu/o.r)*dx - o.r*vr*dvx )\n e1 = 1./mu*( (v*v-mu/o.r)*dy - o.r*vr*dvy )\n e2 = 1./mu*( (v*v-mu/o.r)*dz - o.r*vr*dvz )\n o.e = math.sqrt( e0*e0 + e1*e1 + e2*e2 ) # eccentricity\n \n o.P = math.copysign(2.*math.pi*math.sqrt( math.fabs(o.a*o.a*o.a/mu) ), o.a) # period\n o.inc = math.acos( h2/o.h ) # inclination (wrt xy-plane)\n # if pi/2<i<pi it's retrograde\n n0 = -h1 # node vector\n n1 = h0 # in xy plane => no z component\n n = math.sqrt( n0*n0 + n1*n1 )\n er = dx*e0 + dy*e1 + dz*e2\n if n/o.r/v<=MIN_REL_ERROR or o.inc<=MIN_REL_ERROR:# we are in the xy plane\n o.Omega=0.\n if o.e <= MIN_REL_ERROR: # omega not defined for circular orbit\n o.omega = 0.\n else:\n if e1>=0.:\n o.omega=math.acos(e0/o.e)\n else:\n o.omega = 2.*math.pi-math.acos(e0/o.e)\n else:\n if o.e <= MIN_REL_ERROR:\n o.omega = 0.\n else:\n if e2>=0.: # omega=0 if perictr at asc node\n o.omega=math.acos(( n0*e0 + n1*e1 )/(n*o.e))\n else:\n o.omega=2.*math.pi-math.acos(( n0*e0 + n1*e1 )/(n*o.e))\n if n1>=0.:\n o.Omega = math.acos(n0/n)\n else:\n o.Omega=2.*math.pi-math.acos(n0/n)# Omega=longitude of asc node\n # taken in xy plane from x axis\n \n if o.e<=MIN_REL_ERROR: # circular orbit\n o.f=0. # f has no meaning\n o.l=0.\n else:\n cosf = er/(o.e*o.r)\n cosea = (1.-o.r/o.a)/o.e\n \n if -1.<=cosf and cosf<=1.: # failsafe\n o.f = math.acos(cosf)\n else:\n o.f = math.pi/2.*(1.-cosf)\n \n if -1.<=cosea and cosea<=1.:\n ea = math.acos(cosea)\n else:\n ea = math.pi/2.*(1.-cosea)\n \n if vr<0.:\n o.f=2.*math.pi-o.f\n ea =2.*math.pi-ea\n \n o.l = ea -o.e*math.sin(ea) + o.omega + o.Omega # mean longitude\n \n return o","def to_init_position(self):\n if self._pinit == None:\n raise Exception('initial position for motor {} not known'.format(self._port))\n self.change_position(self._pinit)","def __init__(self, topology_proposal, direction=\"forward\"):\n from simtk.openmm import app\n\n self._topology_proposal = topology_proposal\n self._direction = direction\n self._hydrogen = app.Element.getByAtomicNumber(1.0)\n\n # Set the direction\n if direction == \"forward\":\n self._destination_system = self._topology_proposal.new_system\n self._new_atoms = self._topology_proposal.unique_new_atoms\n self._destination_topology = self._topology_proposal.new_topology\n self._atoms_with_positions = self._topology_proposal.new_to_old_atom_map.keys()\n _nx_graph = self._topology_proposal._new_topology._get_networkx_molecule()\n elif direction == \"reverse\":\n self._destination_system = self._topology_proposal.old_system\n self._new_atoms = self._topology_proposal.unique_old_atoms\n self._destination_topology = self._topology_proposal.old_topology\n self._atoms_with_positions = self._topology_proposal.old_to_new_atom_map.keys()\n _nx_graph = self._topology_proposal._old_topology._get_networkx_molecule()\n else:\n raise ValueError(\"Direction must be either forward or reverse.\")\n\n self._new_atom_objects = list(self._destination_topology.atoms())\n self._new_atoms_to_place = [atom for atom in self._destination_topology.atoms() if atom.index in self._new_atoms]\n\n self._atoms_with_positions_set = set(self._atoms_with_positions)\n\n self._hydrogens = []\n self._heavy = []\n\n # Sort the new atoms into hydrogen and heavy atoms:\n for atom in self._new_atoms_to_place:\n if atom.element == self._hydrogen:\n self._hydrogens.append(atom.index)\n else:\n self._heavy.append(atom.index)\n\n # Sanity check\n if len(self._hydrogens)==0 and len(self._heavy)==0:\n msg = 'NetworkXProposalOrder: No new atoms for direction {}\\n'.format(direction)\n msg += str(topology_proposal)\n raise Exception(msg)\n\n # Choose the first of the new atoms to find the corresponding residue:\n #transforming_residue = self._new_atom_objects[self._new_atoms[0]].residue\n\n self._residue_graph = _nx_graph\n self._reference_connectivity_graph = self._create_reference_connectivity_graph()","def _set_init_pose(self):\n cmd = np.zeros(16 * self.n)\n self.move_joints(cmd)","def alignMonoPlane(entry,prec=1E-4,seed_index=0,supercell=2,\n c_mag=50,dist_from_plane=3):\n\n\n # Keep original copy of structure\n s = copy.deepcopy(entry[0])\n\n\n new_latt,fit_fracs= getNewLattice(entry,dim=2,prec=prec,seed_index=seed_index,\n supercell=supercell,c_mag=c_mag)\n\n\n \n\n # Identify plane to translate atoms towards\n\n plane = Plane(Point3D(s.sites[seed_index].coords),\n normal_vector=new_latt[2])\n \n # Create list of translationss\n trans = list(itertools.product([1,-1,0],repeat=3))\n\n lat = np.array(s.lattice.as_dict()['matrix'])\n final_sites = []\n i=0\n \n # Ensure that the atoms are nearby each other\n for site in [x.coords for x in s.sites]:\n point = Point3D(site)\n if 1==1:\n\n news = []\n \n # translate atomic sites to see which position is closest to plane\n for t in trans:\n point = Point3D(site+np.dot(np.transpose(lat),t))\n news.append([float(plane.distance(point)),t])\n news.sort(key = lambda x:x[0])\n for new in news:\n if not np.any([magni((site+np.dot(np.transpose(lat),new[1]))-x)<=prec for x in final_sites]):\n final_sites.append(site+\n np.dot(np.transpose(lat),new[1]))\n break\n i+=1\n \n # Create new lattice matricies\n lat1 = np.array([new_latt[0],new_latt[1],new_latt[2]])\n lat2 = np.array([new_latt[1],new_latt[0],new_latt[2]])\n\n # Generate atomic fractions\n new_fracs1 = np.linalg.solve(lat1.T,np.array(final_sites).T).T\n new_fracs2 = np.linalg.solve(lat2.T,np.array(final_sites).T).T\n\n species=fit_fracs[1]\n\n return([species,new_fracs1,lat1],[species,new_fracs2,lat2])","def set_init_pose(self):\n self.move_joints(self.init_cart_vel)\n\n return True","def test_init_attr(self):\n import itertools\n\n # K = 0\n\n s = space(curvature=0)\n p = s.make_origin(0)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1]\n ))))\n p = s.make_origin(2)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1, 0, 0]\n ))))\n p = s.make_point((1, 0), 1)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1, 1, 0]\n ))))\n\n # K = 1\n\n sn1_ref = 0.841470984807896506652502321630345\n cn1_ref = 0.540302305868139717400936607442955\n\n s = space(curvature=1)\n p = s.make_origin(0)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1]\n ))))\n p = s.make_origin(2)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1, 0, 0]\n ))))\n p = s.make_point((1, 0), 1)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [cn1_ref, sn1_ref, 0]\n ))))\n\n # K = -1\n\n sh1_ref = 1.17520119364380145688238185059568\n ch1_ref = 1.54308063481524377847790562075713\n\n s = space(curvature=-1)\n p = s.make_origin(0)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1]\n ))))\n p = s.make_origin(2)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [1, 0, 0]\n ))))\n p = s.make_point((1, 0), 1)\n self.assertTrue(all(itertools.starmap(isclose, zip(\n p.x,\n [ch1_ref, sh1_ref, 0]\n ))))","def simulate(\n init_pos, init_en, model, pcas, desc_scalers, en_scaler, soap,\n steps=100000, delta=0.04, T=100, dataset='zundel_100k'):\n\n hartree = 4.3597443419e-18\n kb = 1.381e-23 / hartree\n beta = 1 / (kb * T)\n\n n_atoms = data.get_n_atoms(dataset)\n atoms = data.get_atoms_list(dataset)\n symbols = data.get_symbols(dataset)\n\n acceptance = 0\n cur_pos = np.copy(init_pos)\n cur_en = init_en\n\n pos_history = np.empty((steps, n_atoms, 3))\n en_history = np.empty(steps)\n\n for i in tqdm(range(steps)):\n dr = np.random.random((n_atoms, 3)) * 2 * delta - delta\n try_pos = np.copy(cur_pos) + dr\n\n molec = np.empty(1, dtype=object)\n molec[0] = Atoms(symbols, positions=try_pos)\n\n desc = data.compute_desc(\n molec, dataset=dataset, soap_params=soap\n )\n\n desc = preprocessing.transform_set(\n atoms=atoms, descriptors=desc, transformers=pcas\n )\n\n desc = preprocessing.transform_set(\n atoms=atoms, descriptors=desc, transformers=desc_scalers\n )\n\n desc = preprocessing.convert_to_inputs(desc)\n\n try_en = model.predict(desc)\n try_en = en_scaler.inverse_transform(try_en)[0, 0]\n \n if try_en < cur_en or exp(-beta * (try_en - cur_en)) >= random():\n acceptance += 1\n cur_pos, cur_en = try_pos, try_en\n\n pos_history[i] = cur_pos\n en_history[i] = cur_en\n\n return pos_history, en_history, float(acceptance) / steps","def standarization_ofPS(a2_data, num_dim, a2_tuple):\n py_order = ['BURNUP', 'TEMPERATURE_COMBUSTIBLE',\n 'CONCENTRATION_EN_BORE', 'DENSITE_MODERATEUR', 'PISCINE',\n 'BURNUPstep', 'CONTROL_ROD', 'POWER_DENSITY', 'PHASE']\n # interface is manege here to make functions as pure as possible\n # a2_data['PS'] = efective_real_state_space(a2_data['PS'], num_dim)\n temp = efective_real_state_space(a2_data, num_dim)\n a2_data = OrderedDict()\n a2_data['real'] = OrderedDict()\n a2_data['real']['data'] = ordered_real_state_space(temp, py_order, a2_tuple)\n a2_data['nmlz'] = OrderedDict()\n a2_data['nmlz']['tau_gen'] = normalize_state_space(a2_data['real']['data'])\n a2_data['nmlz']['N_tau'] = [len(vec) for vec in a2_data['nmlz']['tau_gen'].values()]\n a2_data['nmlz']['N_prod'] = np.prod(a2_data['nmlz']['N_tau'])\n a2_data['nmlz']['grid'] = to_pppack_style(a2_data['nmlz']['tau_gen'].values())\n if len(a2_data['nmlz']['grid']) != a2_data['nmlz']['N_prod']:\n raise RuntimeError('Generation of grid did not reproduce Cartesian construction %r != %r'\n % (len(a2_data['nmlz']['grid']), a2_data['nmlz']['N_prod'])\n )\n a2_data['nmlz']['indx'] = OrderedDict()\n a2_data['nmlz']['indx']['tau'] = [[idx for idx, _ in enumerate(vec)] for vec in a2_data[\n 'nmlz']['tau_gen'].values()]\n a2_data['nmlz']['indx']['grid'] = to_pppack_style(a2_data['nmlz']['indx']['tau'])\n return a2_data","def update_initial_pose(self, msg):\n xy_theta = convert_pose_to_xy_and_theta(msg.pose.pose)\n self.initialize_particle_cloud(xy_theta)\n self.fix_map_to_odom_transform(msg)","def _precession_matrix(oldequinox, newequinox):\n return earth._precession_matrix_besselian(oldequinox.byear, newequinox.byear)","def setup_layout_constants(self):\n # determines the spacing between the edge and nmos (rail to active\n # metal or poly_to_poly spacing)\n half_gate_to_gate = 0.5 * (drc[\"poly_to_poly\"] - drc[\"minwidth_metal1\"])\n edge_to_nmos = max(drc[\"metal1_to_metal1\"] - self.nmos.active_contact_positions[0].y,\n half_gate_to_gate - self.nmos.poly_positions[0].y)\n\n # determine the position of the first transistor from the left\n self.nmos_position1 = vector(0,\n 0.5 * drc[\"minwidth_metal1\"] + edge_to_nmos)\n offset = self.nmos_position1 + vector(0,self.nmos.height)\n\n x = vector(self.nmos.active_width - self.nmos.active_contact.width, 0)\n self.nmos_position2 = x + self.nmos_position1.scale(0,1)\n\n # determines the spacing between the edge and pmos\n edge_to_pmos = max(drc[\"metal1_to_metal1\"] - self.pmos.active_contact_positions[0].y,\n half_gate_to_gate - self.pmos.poly_positions[0].y)\n self.pmos_position1 = vector(0,\n self.height - 0.5 * drc[\"minwidth_metal1\"]\n - edge_to_pmos - self.pmos.height)\n self.pmos_position2 = self.pmos_position1 + vector(self.pmos.width,0)\n\n self.well_width = max(self.pmos_position2.x + self.pmos.active_position.x\n + self.pmos.active_width\n + drc[\"active_to_body_active\"] + self.nwell_contact.width \n + drc[\"well_enclosure_active\"],\n self.nmos_position2.x + self.nmos.active_position.x \n + self.nmos.active_width \n + drc[\"active_to_body_active\"] + drc[\"well_enclosure_active\"])\n self.width = self.well_width","def align_resistors(self):\n\n if not self.been_solved:\n self.solve()\n for element in self.elements:\n if is_resistor(element) and element.current < 0:\n element.pos, element.neg = element.neg, element.pos\n element.current = -1 * element.current","def test_canonical_ordering_rdkit(self):\n from openforcefield.utils.toolkits import RDKitToolkitWrapper\n\n rdkit = RDKitToolkitWrapper()\n # get ethanol in canonical order\n ethanol = create_ethanol()\n # get reversed non canonical ethanol\n reversed_ethanol = create_reversed_ethanol()\n # get the canonical ordering\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(rdkit)\n # make sure the mapping between the ethanol and the rdkit ref canonical form is the same\n assert (\n True,\n {0: 2, 1: 0, 2: 1, 3: 8, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7},\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)","def obInit(position, angle, center):\n\tif angle > 360.0:\n\t angle = angle - 360\n\tif angle < - 360:\n\t angle = -angle - 360\n\tif angle > -360 and angle < 0:\n\t angle = -angle\n\tadjPosition = position - center\n\tnewposition = adjPosition.rotate(angle) + center\n\treturn newposition","def preferred_init_points(self):\n if self._initial_state is None:\n return None\n else:\n # If an initial state was set by the user, then we want to make sure that the VQE does\n # not start from a random point. Thus, we return an all-zero initial point for the\n # optimizer which is used (unless it gets overwritten by a higher-priority setting at\n # runtime of the VQE).\n # However, in order to determine the correct length, we must build the QuantumCircuit\n # first, because otherwise the operators may not be set yet.\n self._build()\n return np.zeros(self.reps * len(self.operators), dtype=float)","def test_left_canonize():\n \n for n in range(Nmin, Nmax+1):\n random_state = new_random_state(d, n)\n \n rand_mps = []\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\n \n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\n rand_mps.append(np.random.rand(*shape)) \n \n MPS_leftcanonical = left_canonize(rand_mps)\n \n assert check_left_canonization(MPS_leftcanonical[:-1]), \"left_canonize error\"","def fill_from_simbad (self, ident, debug=False):\n import sys\n info = get_simbad_astrometry_info (ident, debug=debug)\n posref = 'unknown'\n\n for k, v in info.iteritems ():\n if '~' in v:\n continue # no info\n\n if k == 'COO(d;A)':\n self.ra = float (v) * D2R\n elif k == 'COO(d;D)':\n self.dec = float (v) * D2R\n elif k == 'COO(E)':\n a = v.split ()\n self.pos_u_maj = float (a[0]) * A2R * 1e-3 # mas -> rad\n self.pos_u_min = float (a[1]) * A2R * 1e-3\n self.pos_u_pa = float (a[2]) * D2R\n elif k == 'COO(B)':\n posref = v\n elif k == 'PM(A)':\n self.promo_ra = float (v) # mas/yr\n elif k == 'PM(D)':\n self.promo_dec = float (v) # mas/yr\n elif k == 'PM(E)':\n a = v.split ()\n self.promo_u_maj = float (a[0]) # mas/yr\n self.promo_u_min = float (a[1])\n self.promo_u_pa = float (a[2]) * D2R # rad!\n elif k == 'PLX(V)':\n self.parallax = float (v) # mas\n elif k == 'PLX(E)':\n self.u_parallax = float (v) # mas\n elif k == 'RV(V)':\n self.vradial = float (v) # km/s\n elif k == 'RV(E)':\n self.u_vradial = float (v) #km/s\n\n if self.ra is None:\n raise Exception ('no position returned by Simbad for \"%s\"' % ident)\n if self.u_parallax == 0:\n self.u_parallax = None\n if self.u_vradial == 0:\n self.u_vradial = None\n\n # Get the right epoch of position for 2MASS positions\n\n if posref == '2003yCat.2246....0C':\n self.pos_epoch = get_2mass_epoch (self.ra, self.dec, debug)\n\n return self # eases chaining","def test_canonical_ordering_rdkit(self):\n from openff.toolkit.utils.toolkits import RDKitToolkitWrapper\n\n rdkit = RDKitToolkitWrapper()\n # get ethanol in canonical order\n ethanol = create_ethanol()\n # get reversed non canonical ethanol\n reversed_ethanol = create_reversed_ethanol()\n # get the canonical ordering\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(rdkit)\n # make sure the mapping between the ethanol and the rdkit ref canonical form is the same\n assert (\n True,\n {0: 2, 1: 0, 2: 1, 3: 8, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7},\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)","def _standardize_pose(self):\n self.mesh_.center_vertices_bb()\n vertex_array_cent = np.array(self.mesh_.vertices())\n\n # find principal axes\n pca = sklearn.decomposition.PCA(n_components = 3)\n pca.fit(vertex_array_cent)\n\n # count num vertices on side of origin wrt principal axes\n comp_array = pca.components_\n norm_proj = vertex_array_cent.dot(comp_array.T)\n opposite_aligned = np.sum(norm_proj < 0, axis = 0)\n same_aligned = np.sum(norm_proj >= 0, axis = 0)\n pos_oriented = 1 * (same_aligned > opposite_aligned) # trick to turn logical to int\n neg_oriented = 1 - pos_oriented\n\n # create rotation from principal axes to standard basis\n target_array = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]]) # Z+, Y+, X+\n target_array = target_array * pos_oriented + -1 * target_array * neg_oriented\n R = np.linalg.solve(comp_array, target_array)\n R = R.T\n\n # rotate vertices, normals and reassign to the mesh\n vertex_array_rot = R.dot(vertex_array_cent.T)\n vertex_array_rot = vertex_array_rot.T\n self.mesh_.set_vertices(vertex_array_rot.tolist())\n self.mesh_.center_vertices_bb()\n\n if self.mesh_.normals() is not None:\n normals_array = np.array(self.mesh_.normals_)\n normals_array_rot = R.dot(normals_array.T)\n self.mesh_.set_normals(normals_array_rot.tolist())","def reinit_pose(self, Xnew):\n self.X = sym.Matrix([[Xnew[0]], [Xnew[1]], [Xnew[2]]])","def test_diatomic_dummy_molecule_rotation_around_global_axis():\n mol = Molecule()\n mol.atoms = ['C'] * 2\n mol.coordinates = np.array([[1, 0, 0], [0, 1, 0]])\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi / 2, center=False)\n assert np.allclose(mol.coordinates, [[0, 1, 0], [-1, 0, 0]])\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi, center=False)\n assert np.allclose(mol.coordinates, [[0, -1, 0], [1, 0, 0]])","def set_radicals_correctly_from_xyz(self):\n self.assertEqual(self.spc1.multiplicity, 1) # NH(S), a nitrene\n self.assertTrue(all([atom.radical_electrons == 0 for atom in self.spc1.mol.atoms]))\n self.assertEqual(self.spc2.multiplicity, 1) # NH(S), a nitrene\n self.assertTrue(all([atom.radical_electrons == 0 for atom in self.spc2.mol.atoms]))\n self.assertEqual(self.spc3.multiplicity, 1) # NCN(S), a singlet birad\n self.assertTrue(all([atom.radical_electrons == 1 for atom in self.spc3.mol.atoms if atom.is_nitrogen()]))\n self.assertEqual(self.spc3.multiplicity, 3) # NCN(T)\n self.assertTrue(all([atom.radical_electrons == 1 for atom in self.spc3.mol.atoms if atom.is_nitrogen()]))","def test_leading_order_convergence(self):\n # Create models\n leading_order_model = pybamm.lead_acid.LOQS()\n composite_model = pybamm.lead_acid.Composite()\n full_model = pybamm.lead_acid.Full()\n\n # Same parameters, same geometry\n parameter_values = full_model.default_parameter_values\n parameter_values[\"Current function [A]\"] = \"[input]\"\n parameter_values.process_model(leading_order_model)\n parameter_values.process_model(composite_model)\n parameter_values.process_model(full_model)\n geometry = full_model.default_geometry\n parameter_values.process_geometry(geometry)\n\n # Discretise (same mesh, create different discretisations)\n var = pybamm.standard_spatial_vars\n var_pts = {var.x_n: 3, var.x_s: 3, var.x_p: 3}\n mesh = pybamm.Mesh(geometry, full_model.default_submesh_types, var_pts)\n\n method_options = {\"extrapolation\": {\"order\": \"linear\", \"use bcs\": False}}\n spatial_methods = {\n \"macroscale\": pybamm.FiniteVolume(method_options),\n \"current collector\": pybamm.ZeroDimensionalSpatialMethod(method_options),\n }\n loqs_disc = pybamm.Discretisation(mesh, spatial_methods)\n loqs_disc.process_model(leading_order_model)\n comp_disc = pybamm.Discretisation(mesh, spatial_methods)\n comp_disc.process_model(composite_model)\n full_disc = pybamm.Discretisation(mesh, spatial_methods)\n full_disc.process_model(full_model)\n\n def get_max_error(current):\n pybamm.logger.info(\"current = {}\".format(current))\n # Solve, make sure times are the same and use tight tolerances\n t_eval = np.linspace(0, 3600 * 17 / current)\n solver = pybamm.CasadiSolver()\n solver.rtol = 1e-8\n solver.atol = 1e-8\n solution_loqs = solver.solve(\n leading_order_model, t_eval, inputs={\"Current function [A]\": current}\n )\n solution_comp = solver.solve(\n composite_model, t_eval, inputs={\"Current function [A]\": current}\n )\n solution_full = solver.solve(\n full_model, t_eval, inputs={\"Current function [A]\": current}\n )\n\n # Post-process variables\n voltage_loqs = solution_loqs[\"Terminal voltage\"]\n voltage_comp = solution_comp[\"Terminal voltage\"]\n voltage_full = solution_full[\"Terminal voltage\"]\n\n # Compare\n t_loqs = solution_loqs.t\n t_comp = solution_comp.t\n t_full = solution_full.t\n t = t_full[: np.min([len(t_loqs), len(t_comp), len(t_full)])]\n loqs_error = np.max(np.abs(voltage_loqs(t) - voltage_full(t)))\n comp_error = np.max(np.abs(voltage_comp(t) - voltage_full(t)))\n return (loqs_error, comp_error)\n\n # Get errors\n currents = 0.5 / (2 ** np.arange(3))\n errs = np.array([get_max_error(current) for current in currents])\n loqs_errs, comp_errs = [np.array(err) for err in zip(*errs)]\n # Get rates: expect linear convergence for loqs, quadratic for composite\n loqs_rates = np.log2(loqs_errs[:-1] / loqs_errs[1:])\n\n np.testing.assert_array_less(0.99 * np.ones_like(loqs_rates), loqs_rates)\n # Composite not converging as expected\n comp_rates = np.log2(comp_errs[:-1] / comp_errs[1:])\n np.testing.assert_array_less(0.99 * np.ones_like(comp_rates), comp_rates)\n # Check composite more accurate than loqs\n np.testing.assert_array_less(comp_errs, loqs_errs)","def test_canonical_ordering_openeye(self):\n from openforcefield.utils.toolkits import OpenEyeToolkitWrapper\n\n openeye = OpenEyeToolkitWrapper()\n # get ethanol in canonical order\n ethanol = create_ethanol()\n # get reversed non canonical ethanol\n reversed_ethanol = create_reversed_ethanol()\n # get the canonical ordering\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(openeye)\n # make sure the mapping between the ethanol and the openeye ref canonical form is the same\n assert (\n True,\n {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8},\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)","def propagator_testprep():\n import mdtraj as md\n from coddiwomple.particles import Particle\n from coddiwomple.openmm.states import OpenMMParticleState\n from qmlify.utils import generate_propagator_inputs\n\n vac_sys_pos_top, sol_sys_pos_top = generate_testsystem()\n vac_system, vac_positions, vac_topology = vac_sys_pos_top\n sol_system, sol_positions, sol_topology = sol_sys_pos_top\n\n md_topology = md.Topology.from_openmm(sol_topology)\n md_subset_topology = md.Topology.from_openmm(vac_topology)\n pdf_state, pdf_state_subset, integrator, ani_handler, atom_map = generate_propagator_inputs(system = sol_system,\n system_subset = vac_system,\n md_topology = md_topology,\n md_subset_topology = md_subset_topology)\n particle = Particle(0)\n box_vectors = sol_system.getDefaultPeriodicBoxVectors()\n particle_state = OpenMMParticleState(positions = sol_positions, box_vectors = box_vectors)\n particle.update_state(particle_state)\n\n return pdf_state, pdf_state_subset, integrator, ani_handler, atom_map, particle","def propositional_skeleton(self):\n # Task 9.5\n return Formula.skel_helper(self, {}) # use skel_helper with an empty dict to solve","def update_initial_pose(self, msg):\n xy_theta = \\\n self.tf_helper.convert_pose_to_xy_and_theta(msg.pose.pose)\n\n self.tf_helper.fix_map_to_odom_transform(msg.pose.pose,\n msg.header.stamp)\n self.tf_helper.send_last_map_to_odom_transform()\n # initialize your particle filter based on the xy_theta tuple","def test_canonical_ordering_openeye(self):\n from openff.toolkit.utils.toolkits import OpenEyeToolkitWrapper\n\n openeye = OpenEyeToolkitWrapper()\n # get ethanol in canonical order\n ethanol = create_ethanol()\n # get reversed non canonical ethanol\n reversed_ethanol = create_reversed_ethanol()\n # get the canonical ordering\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(openeye)\n # make sure the mapping between the ethanol and the openeye ref canonical form is the same\n assert (\n True,\n {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8},\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)","def move_three_atoms(poscar,iat,icoord,ih,jat,jcoord,jh,kat,kcoord,kh):\n nruter=copy.deepcopy(poscar)\n disp=np.zeros(3)\n disp[icoord]=ih\n nruter[\"positions\"][:,iat]+=scipy.linalg.solve(nruter[\"lattvec\"],\n disp)\n disp[:]=0.\n disp[jcoord]=jh\n nruter[\"positions\"][:,jat]+=scipy.linalg.solve(nruter[\"lattvec\"],\n disp)\n disp[:]=0.\n disp[kcoord]=kh\n nruter[\"positions\"][:,kat]+=scipy.linalg.solve(nruter[\"lattvec\"],\n disp)\n return nruter","def supress_atomPosition_singulrarities(self) -> None:\n\n if (\"POSITION\" in dir(self)):\n for ind, atom in enumerate(self.POSITION.content):\n atom.xp = atom.xp + 10 ** (-7) * ind\n atom.yp = atom.yp - 10 ** (-7) * ind\n atom.zp = atom.zp - 10 ** (-7) * ind","def assert_stored_sp_rel_pos(self):\n# ## Temporal\n# if self.sp_relative_pos is not None:\n# if self._constant_neighs:\n# if self.staticneighs:\n# assert(len(np.array(self.sp_relative_pos).shape) == 3)\n# else:\n# assert(len(np.array(self.sp_relative_pos).shape) == 4)\n# #################\n array_types = [list, np.ndarray]\n if self.sp_relative_pos is not None:\n assert(type(self.sp_relative_pos) in [list, np.ndarray])\n# if type(self.sp_relative_pos) in [float, int, np.int32, np.int64]:\n# ### Probably redundant\n# # it is needed or possible this situation?\n# pass\n assert(type(self.sp_relative_pos) in [list, np.ndarray])\n# if self.ks is None:\n# assert(self.staticneighs)\n# assert(len(self.sp_relative_pos) == len(self.iss))\n if self.staticneighs:\n assert(len(self.sp_relative_pos) == len(self.iss))\n ## Assert deep 3\n if len(self.iss):\n assert(type(self.sp_relative_pos[0]) in array_types)\n else:\n assert(self.ks is not None)\n assert(len(self.sp_relative_pos) == len(self.ks))\n if type(self.sp_relative_pos[0]) in array_types:\n if not self.staticneighs:\n assert(len(self.sp_relative_pos[0]) == len(self.iss))\n if len(self.sp_relative_pos[0]) > 0:\n assert(type(self.sp_relative_pos[0][0]) in array_types)","def test_zero_modes(self):\n # make random numbers reproducible\n torch.manual_seed(0)\n \n n = 5\n # draw random numbers for positive definite, symmetric n x n matrix of width parameters\n Gi = 5.0 * 2.0*(torch.rand(n,n) - 0.5)\n # symmetrize\n Gi = 0.5*(Gi + Gi.T)\n # random numbers for position and momentum\n qi,pi = torch.rand(n,1), torch.rand(n,1)\n qj,pj = qi,pi #torch.rand(n,1), torch.rand(n,1)\n # check <qi,pi,Gi|qi,pi,Gi> = 1 \n cso = CoherentStatesOverlap(Gi,Gi)\n olap = cso(qi,pi, qj,pj)\n\n # turn Gi into a singular matrix by embedding it into a larger space\n Gi_ = torch.zeros((n+1,n+1))\n Gi_[:n,:n] = Gi\n qi_, pi_, qj_, pj_ = (torch.cat((x, torch.zeros(1,1)), 0) for x in (qi,pi,qj,pj))\n # The zero dimension should have no effect on the overlaps\n cso_ = CoherentStatesOverlap(Gi_,Gi_)\n olap_ = cso_(qi_,pi_, qj_,pj_)\n\n self.assertEqual(olap.squeeze().item(), olap_.squeeze().item())","def InitPositions(N, L):\n #make the position array\n Pos = np.zeros((N,3), float)\n #compute integer grid # of locations for cubic lattice\n NLat = int(N**(1./3.) + 1.)\n LatSpac = float(L) / float(NLat)\n #make an array of lattice sites\n r = LatSpac * np.arange(NLat, dtype=float) - 0.5*L\n #loop through x, y, z positions in lattice until done\n #for every atom in the system\n i = 0\n for x in r:\n for y in r:\n for z in r:\n Pos[i] = np.array([x,y,z], float)\n #add a random offset to help initial minimization\n Offset = 0.1 * LatSpac * (np.random.rand(3) - 0.5)\n Pos[i] = Pos[i] + Offset\n i += 1\n #if done placing atoms, return\n if i >= N:\n return Pos\n return Pos","def init_morphed(self, init_from: dict):\n for k1 in self.m_ops.keys():\n f = init_from.get(k1, -1) # where the op is originating from\n if f not in self.m_ops:\n continue\n self.m_ops[k1][0].init_from(self.m_ops[f][0])","def model_prem_iso(r):\n\n\t#- normalised radius\n\tx = r / 6371000.0\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\t#- upper crust\n\tif (r >= 6356000.0):\n\t\trho = 2.6\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 3.2\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- lower crust\n\telif (r >= 6346000.6) & (r < 6356000.0):\n\t\trho = 2.9\n\t\tvpv = 6.8\n\t\tvph = vpv\n\t\tvsv = 3.9\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- LID\n\telif (r >= 6291000.0) & (r < 6346000.6):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 4.1875 + 3.9382 * x\n\t\tvph = vpv\n\t\tvsv = 2.1519 + 2.3481 * x\n\t\tvsh = vsv\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- LVZ\n\telif (r >= 6151000.0) & (r < 6291000.0):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 4.1875 + 3.9382 * x\n\t\tvph = vpv\n\t\tvsv = 2.1519 + 2.3481 * x\n\t\tvsh = vsv\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- Transition zone 1\n\telif (r >= 5971000.0) & (r < 6151000.0):\n\t\trho = 7.1089 - 3.8045 * x\n\t\tvpv = 20.3926 - 12.2569 * x\n\t\tvph = vpv\n\t\tvsv = 8.9496 - 4.4597 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 2\n\telif (r >= 5771000.0) & (r < 5971000.0):\n\t\trho = 11.2494 - 8.0298 * x\n\t\tvpv = 39.7027 - 32.6166 * x\n\t\tvph = vpv\n\t\tvsv = 22.3512 - 18.5856 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 3\n\telif (r >= 5701000.0) & (r < 5771000.0):\n\t\trho = 5.3197 - 1.4836 * x\n\t\tvpv = 19.0957 - 9.8672 * x\n\t\tvph = vpv\n\t\tvsv = 9.9839 - 4.9324 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 1\n\telif (r >= 5600000.0) & (r < 5701000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- Lower mantle 2\n\telif (r >= 3630000.0) & (r < 5600000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\n\t\tvph = vpv\n\t\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 3\n\telif (r >= 3480000.0) & (r < 3630000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Outer core\n\telif (r >= 1221000.5) & (r < 3480000.0):\n\t\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\n\t\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\n\t\tvph = vpv\n\t\tvsv = 0.0\n\t\tvsh = 0.0\n\t\teta = 1.0\n\n\t#- Inner Core\n\telif (r >= 0.0) & (r < 1221000.5):\n\t\trho = 13.0885 - 8.8381 * x**2\n\t\tvpv = 11.2622 - 6.3640 * x**2\n\t\tvph = vpv\n\t\tvsv = 3.6678 - 4.4475 * x**2\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def assign_electrons(molecule, electrons):\n # Assign electrons based upon unperturbed atoms and ignore impact of\n # fractional nuclear charge.\n nuclei = [int(round(atom.charge)) for atom in molecule]\n total_charge = sum(nuclei) - sum(electrons)\n # Construct a dummy iso-electronic neutral system.\n neutral_molecule = [copy.copy(atom) for atom in molecule]\n if total_charge != 0:\n logging.warning(\n 'Charged system. Using heuristics to set initial electron positions')\n charge = 1 if total_charge > 0 else -1\n while total_charge != 0:\n # Poor proxy for electronegativity.\n atom_index = nuclei.index(max(nuclei) if total_charge < 0 else min(nuclei))\n atom = neutral_molecule[atom_index]\n atom.charge -= charge\n atom.atomic_number = int(round(atom.charge))\n if int(round(atom.charge)) == 0:\n neutral_molecule.pop(atom_index)\n else:\n atom.symbol = elements.ATOMIC_NUMS[atom.atomic_number].symbol\n total_charge -= charge\n nuclei = [int(round(atom.charge)) for atom in neutral_molecule]\n\n spin_pol = lambda electrons: electrons[0] - electrons[1]\n abs_spin_pol = abs(spin_pol(electrons))\n if len(neutral_molecule) == 1:\n elecs_atom = [electrons]\n else:\n elecs_atom = []\n spin_pol_assigned = 0\n for ion in neutral_molecule:\n # Greedily assign up and down electrons based upon the ground state spin\n # configuration of an isolated atom.\n atom_spin_pol = elements.ATOMIC_NUMS[ion.atomic_number].spin_config\n nelec = ion.atomic_number\n na = (nelec + atom_spin_pol) // 2\n nb = nelec - na\n # Attempt to keep spin polarisation as close to 0 as possible.\n if (spin_pol_assigned > 0 and\n spin_pol_assigned + atom_spin_pol > abs_spin_pol):\n elec_atom = [nb, na]\n else:\n elec_atom = [na, nb]\n spin_pol_assigned += spin_pol(elec_atom)\n elecs_atom.append(elec_atom)\n\n electrons_assigned = [sum(e) for e in zip(*elecs_atom)]\n spin_pol_assigned = spin_pol(electrons_assigned)\n if np.sign(spin_pol_assigned) == -np.sign(abs_spin_pol):\n # Started with the wrong guess for spin-up vs spin-down.\n elecs_atom = [e[::-1] for e in elecs_atom]\n spin_pol_assigned = -spin_pol_assigned\n\n if spin_pol_assigned != abs_spin_pol:\n logging.info('Spin polarisation does not match isolated atoms. '\n 'Using heuristics to set initial electron positions.')\n while spin_pol_assigned != abs_spin_pol:\n atom_spin_pols = [abs(spin_pol(e)) for e in elecs_atom]\n atom_index = atom_spin_pols.index(max(atom_spin_pols))\n elec_atom = elecs_atom[atom_index]\n if spin_pol_assigned < abs_spin_pol and elec_atom[0] <= elec_atom[1]:\n elec_atom[0] += 1\n elec_atom[1] -= 1\n spin_pol_assigned += 2\n elif spin_pol_assigned < abs_spin_pol and elec_atom[0] > elec_atom[1]:\n elec_atom[0] -= 1\n elec_atom[1] += 1\n spin_pol_assigned += 2\n elif spin_pol_assigned > abs_spin_pol and elec_atom[0] > elec_atom[1]:\n elec_atom[0] -= 1\n elec_atom[1] += 1\n spin_pol_assigned -= 2\n else:\n elec_atom[0] += 1\n elec_atom[1] -= 1\n spin_pol_assigned -= 2\n\n electrons_assigned = [sum(e) for e in zip(*elecs_atom)]\n if spin_pol(electrons_assigned) == -spin_pol(electrons):\n elecs_atom = [e[::-1] for e in elecs_atom]\n electrons_assigned = electrons_assigned[::-1]\n\n logging.info(\n 'Electrons assigned %s.', ', '.join([\n '{}: {}'.format(atom.symbol, elec_atom)\n for atom, elec_atom in zip(molecule, elecs_atom)\n ]))\n if any(e != e_assign for e, e_assign in zip(electrons, electrons_assigned)):\n raise RuntimeError(\n 'Assigned incorrect number of electrons ([%s instead of %s]' %\n (electrons_assigned, electrons))\n if any(min(ne) < 0 for ne in zip(*elecs_atom)):\n raise RuntimeError('Assigned negative number of electrons!')\n electron_positions = np.concatenate([\n np.tile(atom.coords, e[0])\n for atom, e in zip(neutral_molecule, elecs_atom)\n ] + [\n np.tile(atom.coords, e[1])\n for atom, e in zip(neutral_molecule, elecs_atom)\n ])\n return electron_positions","def init_joints_pose(self, init_pos):\n self.current_joint_pose =[]\n self.current_joint_pose = copy.deepcopy(init_pos)\n#\tprint(\"[current_joint_pose]:\", self.current_joint_pose, type(self.current_joint_pose))\n return self.current_joint_pose","def test_library_charges_to_three_ethanols_different_atom_ordering(self):\n # Define a library charge parameter for ethanol (C1-C2-O3) where C1 has charge -0.2, and its Hs have -0.02,\n # C2 has charge -0.1 and its Hs have -0.01, and O3 has charge 0.3, and its H has charge 0.08\n\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_ff,\n )\n\n # ethanol.sdf\n # H5 H8\n # | |\n # H6 - C1 - C2 - O3 - H4\n # | |\n # H7 H9\n #\n # ethanol_reordered.sdf (The middle C and O switch indices)\n # H5 H8\n # | |\n # H6 - C1 - C3 - O2 - H4\n # | |\n # H7 H9\n #\n # create_reversed_ethanol()\n # H5 H2\n # | |\n # H4 - C8 - C7 - O6 - H0\n # | |\n # H3 H1\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n create_reversed_ethanol(),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n 0.08,\n -0.01,\n -0.01,\n -0.02,\n -0.02,\n -0.02,\n 0.3,\n -0.1,\n -0.2,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge","def _reset_internal(self):\n super()._reset_internal()\n\n # Reset all object positions using initializer sampler if we're not directly loading from an xml\n if not self.deterministic_reset:\n\n # Sample from the placement initializer for all objects\n obj_pos, obj_quat = self.placement_initializer.sample()\n\n # Loop through all objects and reset their positions\n for i, (obj_name, _) in enumerate(self.mujoco_objects.items()):\n self.sim.data.set_joint_qpos(obj_name, np.concatenate([np.array(obj_pos[i]), np.array(obj_quat[i])]))","def generate_pure_initial_state(state0, dimensions, states):\n\n cluster_state = 1\n\n for i, s in enumerate(states):\n d = dimensions[i]\n n = int(round((d - 1) / 2 - s))\n\n state = np.zeros(d)\n state[n] = 1\n cluster_state = np.kron(cluster_state, state)\n\n with_central_spin = np.kron(cluster_state, state0)\n\n return with_central_spin","def reset_position(self):\n self.translate_to_point_O()\n\n # inverse rotation:\n rotation_matrix = np.stack(\n (self.pcs.i_hat, self.pcs.j_hat, self.pcs.k_hat), axis=0\n )\n\n self.rotate(rotation_matrix)","def solvate(self):\n\n pass","def _get_quad_initial_pos(self, msg):\n \n self._quad_initial_pos, dummy = self._odometry_to_pos_vel(msg)\n self._sub.unregister()\n self._got_quad_initial_pos_flag = True","def add_initial_side_chains_from_propensities(\n self, G, raw_or_rank, test=False, input_num={}\n ):\n\n # Initialises dictionary of starting sequences\n initial_networks = OrderedDict()\n ids_list = []\n for num in range(2*self.pop_size):\n unique_id = ''.join(\n [random.choice(string.ascii_letters + string.digits)\n for i in range(10)]\n )\n initial_networks[unique_id] = copy.deepcopy(G)\n ids_list.append(unique_id)\n\n # Extracts individual amino acid propensity scales for the surface\n intext_index = self.dict_name_indices['intorext']\n eoc_index = self.dict_name_indices['edgeorcent']\n prop_index = self.dict_name_indices['prop1']\n pairindv_index = self.dict_name_indices['pairorindv']\n discorcont_index = self.dict_name_indices['discorcont']\n proporfreq_index = self.dict_name_indices['proporfreq']\n dicts = OrderedDict({\n dict_label: scale_dict for dict_label, scale_dict in\n {**self.propensity_dicts, **self.frequency_dicts}.items()\n if dict_label.split('_')[pairindv_index] == 'indv'\n })\n\n for node_index, node in enumerate(list(G.nodes())):\n if G.nodes()[node]['type'] == 'loop':\n continue\n\n int_ext = G.nodes()[node]['int_ext']\n sub_dicts = OrderedDict(\n {dict_label: scale_dict for dict_label, scale_dict in dicts.items()\n if dict_label.split('_')[intext_index] in [int_ext, '-']}\n )\n if self.barrel_or_sandwich == '2.60':\n # Filters propensity and frequency scales depending upon\n # whether the node is in an edge or a central strand\n eoc = G.nodes()[node]['eoc']\n sub_dicts = OrderedDict(\n {dict_label: scale_dict for dict_label, scale_dict in sub_dicts.items()\n if dict_label.split('_')[eoc_index] in [eoc, '-']}\n )\n\n if sub_dicts == {}:\n if test is True: # Avoids code crashing if e.g. there are no\n # dicts for ext residues\n continue\n else:\n raise ValueError('No propensity or scoring metrics '\n 'available for node {}'.format(node))\n\n # Calculates summed propensity for each amino acid across all\n # structural features considered in the design process\n node_indv_propensities = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\n node_indv_frequencies = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\n\n for dict_index, dict_label in enumerate(list(sub_dicts.keys())):\n scale_dict = sub_dicts[dict_label]\n dict_weight = self.dict_weights[dict_label]\n node_prop = dict_label.split('_')[prop_index]\n node_val = np.nan\n\n if node_prop != '-':\n try:\n node_val = G.nodes()[node][node_prop]\n except KeyError:\n raise KeyError('{} not defined for node {}'.format(node_prop, node))\n # Converts non-float values into np.nan\n if node_val in ['', 'nan', 'NaN', np.nan]:\n node_val = np.nan\n\n value = np.nan\n if dict_label.split('_')[discorcont_index] == 'cont' and not np.isnan(node_val):\n if dict_label.split('_')[proporfreq_index] != 'propensity':\n raise Exception(\n 'Unexpected dictionary {} - expect only continuous '\n 'propensity dictionaries'.format(dict_label)\n )\n\n # Interpolate dictionary\n for aa, aa_scale in scale_dict.items():\n aa_index = self.aa_list.index(aa)\n value = linear_interpolation(node_val, aa_scale, dict_label)\n\n if value <= 0:\n raise ValueError(\n '{} returned after interpolation of {} for node'\n ' {}'.format(value, dict_label, node)\n )\n\n if np.isnan(value):\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n value = 0.0001 # Since dataset used to generate\n # prop and freq dicts is ~10,000 aas => smallest\n # propensity could be is ((1/5000)/(5001/10000)\n # = 0.0004 (for a discrete propensity))\n\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n node_indv_propensities[dict_index][aa_index] = (\n dict_weight*np.negative(np.log(value))\n )\n\n elif dict_label.split('_')[discorcont_index] == 'disc':\n # Filter dataframe\n scale_dict_copy = copy.deepcopy(scale_dict).set_index('FASTA', drop=True)\n for aa_index, aa in enumerate(self.aa_list):\n if node_prop == '-':\n try:\n value = scale_dict_copy.iloc[:,0][aa]\n except KeyError:\n raise Exception('{} not defined in {}'.format(aa, dict_label))\n elif node_prop == 'phipsi':\n if not np.isnan(node_val):\n try:\n value = scale_dict_copy[node_val][aa]\n except KeyError:\n raise Exception('{},{} not defined in {}'.format(\n node_val, aa, dict_label\n ))\n\n if value <= 0:\n raise ValueError(\n '{} returned after interpolation of {} for node'\n ' {}'.format(value, dict_label, node)\n )\n\n if np.isnan(value):\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n value = 0.0001 # Since dataset used to generate\n # prop and freq dicts is ~10,000 aas => smallest\n # propensity could be is ((1/5000)/(5001/10000)\n # = 0.0004 (for a discrete propensity))\n else:\n value = 0\n\n if dict_label.split('_')[proporfreq_index] == 'propensity':\n node_indv_propensities[dict_index][aa_index] = (\n dict_weight*np.negative(np.log(value))\n )\n elif dict_label.split('_')[proporfreq_index] == 'frequency':\n node_indv_frequencies[dict_index][aa_index] = dict_weight*value\n\n # Sums propensity and frequency values, then filters to remove amino\n # acids with a propensity / frequency of 0\n node_indv_propensities = np.nansum(node_indv_propensities, axis=0)\n node_indv_frequencies = np.nansum(node_indv_frequencies, axis=0)\n\n if (\n set(node_indv_propensities) == {0}\n or (self.frequency_dicts != {} and set(node_indv_frequencies) == {0})\n ):\n raise Exception('Cannot select side chain identity for node '\n '{}'.format(node))\n\n # Removes aas for which all propensity and/or frequency readings (as\n # appropriate) are np.nan\n filt_aa_list = []\n filt_node_prop = []\n filt_node_freq = []\n for aa_index, aa in enumerate(self.aa_list):\n prop = node_indv_propensities[aa_index]\n freq = node_indv_frequencies[aa_index]\n if (\n (self.frequency_dicts == {} and prop == 0)\n or (self.frequency_dicts != {} and prop == 0 and freq == 0)\n ):\n continue\n filt_aa_list.append(aa)\n filt_node_prop.append(prop)\n filt_node_freq.append(freq)\n filt_aa_list = np.array(filt_aa_list)\n filt_node_prop = np.array(filt_node_prop)\n filt_node_freq = np.array(filt_node_freq)\n\n # Converts propensities and frequencies into probability\n # distributions\n (node_prop_index, node_prop, node_prop_probabilities\n ) = calc_probability_distribution(\n node_indv_propensities, 'propensity', raw_or_rank, test\n )\n node_prop_index = node_prop_index.astype(int)\n if self.frequency_dicts != {}:\n (node_freq_index, node_freq, node_freq_probabilities\n ) = calc_probability_distribution(\n filt_node_freq, 'frequency', raw_or_rank, test\n )\n else:\n node_freq_index = copy.deepcopy(node_prop_index)\n node_freq = np.full(filt_node_freq.shape, 0)\n node_freq_probabilities = np.full(filt_node_freq.shape, 0)\n node_freq_index = node_freq_index.astype(int)\n\n node_probabilities = np.full(node_prop_probabilities.shape, np.nan)\n for index_prop, aa in np.ndenumerate(copy.deepcopy(node_prop_index)):\n index_freq = np.where(node_freq_index == aa)[0][0]\n propensity = node_prop_probabilities[index_prop]\n frequency = node_freq_probabilities[index_freq]\n\n # Since propensity_weight is a hyperparameter to be optimised\n # with hyperopt, for initial sequence generation the propensity\n # and frequency scales are weighted equally (unless not\n # performing hyperparameter optimisation, in which case use the\n # propensity_weight specified in the input file)\n try:\n prop_weight = self.propensity_weight\n freq_weight = 1 - self.propensity_weight\n except AttributeError:\n prop_weight = 0.5\n freq_weight = 0.5\n probability = (prop_weight*propensity) + (freq_weight*frequency)\n node_probabilities[index_prop] = probability\n filt_aa_list = filt_aa_list[node_prop_index]\n node_cumulative_probabilities = gen_cumulative_probabilities(\n node_probabilities, node\n )\n\n # Selects amino acid weighted by its probability\n for unique_id in ids_list:\n if test is False:\n random_number = random.uniform(0, 1)\n elif test is True:\n random_number = input_num[node]\n nearest_index = (np.abs(node_cumulative_probabilities-random_number)).argmin()\n\n if node_cumulative_probabilities[nearest_index] >= random_number:\n selected_aa = filt_aa_list[nearest_index]\n else:\n selected_aa = filt_aa_list[nearest_index+1]\n\n nx.set_node_attributes(\n initial_networks[unique_id],\n values={'{}'.format(node): {'aa_id': '{}'.format(selected_aa)}}\n )\n\n return initial_networks","def update_initial_pose(self, msg):\n xy_theta = \\\n self.transform_helper.convert_pose_to_xy_and_theta(msg.pose.pose)\n\n # TODO this should be deleted before posting\n self.transform_helper.fix_map_to_odom_transform(msg.pose.pose,\n msg.header.stamp)\n # initialize your particle filter based on the xy_theta tuple","def setup_nonlinear_model_p(M, C, K, sx='x,y,th', \n rho=1.225, chord=0.2, polarFilename='tjaere11_ds.csv', drag=False, # Aero options\n y_AQ=0, y_AT=None, x_AQ=0, x_AT=0,\n ds='oye', tau=0.08, # tau: used for Oye, but should be taken from Polar!\n di=None):\n # \n p = defaultParams(chord=chord, rho=rho, sx=sx, ds=ds, di=di,\n M=M, C=C, K=K)\n\n # --- Aerodynamic parameters\n if y_AQ>0: \n print('[WARN] y_AQ positive is unconventional')\n p['y_AQ'] = y_AQ\n if y_AT is None:\n p['y_AT'] = y_AQ+chord/2 # default is approximatively half a chord behind\n else:\n p['y_AT'] = y_AT\n p['x_AQ'] = x_AQ\n p['x_AT'] = x_AT\n\n # Read polar\n pol = Polar(polarFilename, fformat=None, radians=True, compute_params=True) # compute_params for DS\n ppol = polarParams(pol, chord=p['chord'], tau=tau)\n p.update(ppol)\n\n# # --- Dictionary\n# p.update({'linModel':False, 'drag':drag})\n return p","def gen_SPOSCAR(poscar,na,nb,nc):\n nruter=dict()\n nruter[\"na\"]=na\n nruter[\"nb\"]=nb\n nruter[\"nc\"]=nc\n nruter[\"lattvec\"]=np.array(poscar[\"lattvec\"])\n nruter[\"lattvec\"][:,0]*=na\n nruter[\"lattvec\"][:,1]*=nb\n nruter[\"lattvec\"][:,2]*=nc\n nruter[\"elements\"]=copy.copy(poscar[\"elements\"])\n nruter[\"numbers\"]=na*nb*nc*poscar[\"numbers\"]\n nruter[\"positions\"]=np.empty((3,poscar[\"positions\"].shape[1]*na*nb*nc))\n pos=0\n for pos,(k,j,i,iat) in enumerate(itertools.product(xrange(nc),\n xrange(nb),\n xrange(na),\n xrange(\n poscar[\"positions\"].shape[1]))):\n nruter[\"positions\"][:,pos]=(poscar[\"positions\"][:,iat]+[i,j,k])/[\n na,nb,nc]\n nruter[\"types\"]=[]\n for i in xrange(na*nb*nc):\n nruter[\"types\"].extend(poscar[\"types\"])\n return nruter","def swapProchiralResonance(resonance, makeAmbiguous=False):\n \n from ccpnmr.analysis.core.MoleculeBasic import areAtomsBound\n\n if resonance.resonanceSet and (len(resonance.resonanceSet.atomSets) == 1):\n atomSet = resonance.resonanceSet.findFirstAtomSet()\n atom = atomSet.findFirstAtom()\n chemAtom = atom.chemAtom\n chemAtomSet = chemAtom.chemAtomSet\n chemAtom0 = None\n \n if chemAtomSet:\n if chemAtomSet.isEquivalent:\n for chemAtomSet0 in chemAtom.chemComp.findAllChemAtomSets(isProchiral=True):\n chemAtomSets = list(chemAtomSet0.chemAtomSets)\n if chemAtomSet in chemAtomSet0.chemAtomSets:\n chemAtomSets.remove(chemAtomSet)\n chemAtom0 = chemAtomSets[0].findFirstChemAtom()\n break\n \n elif chemAtomSet.isProchiral:\n for chemAtom1 in chemAtomSet.chemAtoms:\n if chemAtom1 is not chemAtom:\n chemAtom0 = chemAtom1\n break\n\n if chemAtom0:\n atom0 = atom.residue.findFirstAtom(name=chemAtom0.name)\n if atom0 and atom0.atomSet:\n \n resonances0 = list(resonance.resonanceSet.resonances)\n resonances1 = []\n \n for resonanceSet in atom0.atomSet.resonanceSets:\n if len(resonanceSet.atomSets) == 1:\n resonances1 = list(resonanceSet.resonances)\n break\n \n resonance.resonanceSet.delete()\n if resonances1:\n resonances1[0].resonanceSet.delete()\n \n if makeAmbiguous:\n for resonance1 in resonances1:\n assignAtomsToRes([atomSet,atom0.atomSet],resonance1)\n\n for resonance0 in resonances0:\n assignAtomsToRes([atomSet,atom0.atomSet],resonance0)\n\n else:\n \n for resonance1 in resonances1:\n assignAtomsToRes([atomSet, ],resonance1)\n\n for resonance0 in resonances0:\n assignAtomsToRes([atom0.atomSet, ],resonance0)\n \n if chemAtomSet.isEquivalent:\n for resonance0 in resonances0:\n resonancesX = getBoundResonances(resonance0, recalculate=True)\n \n for bound in resonancesX:\n if bound.resonanceSet:\n atomB = bound.resonanceSet.findFirstAtomSet().findFirstAtom()\n \n if areAtomsBound(atom, atomB):\n swapProchiralResonance(bound, makeAmbiguous)\n \n break\n \n else:\n for resonance1 in resonances1:\n resonancesX = getBoundResonances(resonance0, recalculate=True)\n \n for bound in resonancesX:\n if bound.resonanceSet:\n atomB = bound.resonanceSet.findFirstAtomSet().findFirstAtom()\n \n if areAtomsBound(atom0, atomB):\n swapProchiralResonance(bound, makeAmbiguous)\n \n break","def reset_mocap2body_xpos(sim):\n\n if (sim.model.eq_type is None or\n sim.model.eq_obj1id is None or\n sim.model.eq_obj2id is None):\n return\n for eq_type, obj1_id, obj2_id in zip(sim.model.eq_type,\n sim.model.eq_obj1id,\n sim.model.eq_obj2id):\n if eq_type != mujoco_py.const.EQ_WELD:\n continue\n\n mocap_id = sim.model.body_mocapid[obj1_id]\n if mocap_id != -1:\n # obj1 is the mocap, obj2 is the welded body\n body_idx = obj2_id\n else:\n # obj2 is the mocap, obj1 is the welded body\n mocap_id = sim.model.body_mocapid[obj2_id]\n body_idx = obj1_id\n\n assert (mocap_id != -1)\n sim.data.mocap_pos[mocap_id][:] = sim.data.body_xpos[body_idx]\n # sim.data.mocap_quat[mocap_id][:] = sim.data.body_xquat[body_idx]","def get_pi1(mol, atom, coord):\n\n omega = np.identity(2)\n spin_j = np.einsum(\"ij,kl->ikjl\", omega, omega)\n\n pi_py = -mol.intor(\"int2e_ip1\")[coord] #minus sign due to pyscf definition\n\n j1_spatial = np.zeros((pi_py.shape[0],pi_py.shape[0],pi_py.shape[0],\n pi_py.shape[0]))\n\n for i in range(pi_py.shape[0]):\n\n lambda_i = int(i in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for j in range(pi_py.shape[0]):\n\n lambda_j = int(j in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for k in range(pi_py.shape[0]):\n\n lambda_k = int(k in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n for l in range(pi_py.shape[0]):\n\n lambda_l = int(l in range(mol.aoslice_by_atom()[atom][2],\n mol.aoslice_by_atom()[atom][3]))\n\n j1_spatial[i][j][k][l] += (pi_py[i][j][k][l] * lambda_i\n + pi_py[j][i][k][l] * lambda_j\n + pi_py[k][l][i][j] * lambda_k\n + pi_py[l][k][i][j] * lambda_l)\n\n j1_spatial = np.einsum(\"abcd->acbd\", j1_spatial,\n optimize='optimal') #convert to physicists\n j1 = np.kron(spin_j, j1_spatial)\n k1 = np.einsum(\"ijkl->ijlk\", j1,\n optimize='optimal') #physicists notation\n\n pi1 = j1 - k1\n\n return pi1","def test_parameterize_ethanol_different_reference_ordering_openeye(\n self, force_field\n ):\n toolkit_registry = ToolkitRegistry(toolkit_precedence=[OpenEyeToolkitWrapper])\n pdbfile = app.PDBFile(get_data_file_path(\"systems/test_systems/1_ethanol.pdb\"))\n # Load the unique molecules with one atom ordering\n molecules1 = [Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\"))]\n topology1 = Topology.from_openmm(\n pdbfile.topology,\n unique_molecules=molecules1,\n )\n\n omm_system1 = force_field.create_openmm_system(\n topology1,\n toolkit_registry=toolkit_registry,\n )\n # Load the unique molecules with a different atom ordering\n molecules2 = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\"))\n ]\n topology2 = Topology.from_openmm(\n pdbfile.topology,\n unique_molecules=molecules2,\n )\n omm_system2 = force_field.create_openmm_system(\n topology2,\n toolkit_registry=toolkit_registry,\n )\n\n serialized_1 = XmlSerializer.serialize(omm_system1)\n serialized_2 = XmlSerializer.serialize(omm_system2)\n\n serialized_1 = round_charge(serialized_1)\n serialized_2 = round_charge(serialized_2)\n\n assert serialized_1 == serialized_2","def _set_boron_ppm_positions(self):\n \n #################################################################################################################################################\n # Sets the boron impurity values in the active fuel region in each autofilled element position\n self.fuel_ppm_positions ={\n 'C___1':'7.6 ppm', 'B___1':'7.6 ppm', 'A___1':'7.6 ppm',\n 'C___2':'7.6 ppm', 'B___2':'7.6 ppm', 'A___2':'7.6 ppm',\n 'C___3':'7.6 ppm', 'B___3':'7.6 ppm', 'A___3':'7.6 ppm',\n }","def test_PRP(initial):\n return plan_route((initial[0],initial[1]), initial[2],\n # Goals:\n [(2,3),(3,2)],\n # Allowed locations:\n [(0,0),(0,1),(0,2),(0,3),\n (1,0),(1,1),(1,2),(1,3),\n (2,0), (2,3),\n (3,0),(3,1),(3,2),(3,3)])","def test_same_results_on_fixed_random_state_pca_init(self):\n tsne1 = TSNE(random_state=1, initialization='pca')\n embedding1 = tsne1.fit(self.x)\n\n tsne2 = TSNE(random_state=1, initialization='pca')\n embedding2 = tsne2.fit(self.x)\n\n np.testing.assert_array_equal(embedding1, embedding2,\n 'Same random state produced different initial embeddings')","def __init__(self):\n self.__deviceselected__ = \"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\"\n self.__source__ = \"SR-DMS4AP{LOCALBUMP}S-SP\"\n self.__plane__ = \"SR-DMS4AP{LOCALBUMP}PLANE-SP\"\n #self.__xshift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\"\n #self.__yshift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\"\n #self.__xangle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\"\n #self.__yangle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\"\n self.__shift__ = \"SR-DMS4AP{LOCALBUMP}SHIFT-SP\"\n self.__angle__ = \"SR-DMS4AP{LOCALBUMP}ANGLE-SP\"\n # with all offsets\n self.__anglerb__ = \"SR-DMS4AP{LOCALBUMP}ANGLE-I\"\n self.__positionrb__ = \"SR-DMS4AP{LOCALBUMP}POS-I\"\n # with BBA offset only\n self.__anglerb0__ = \"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\"\n self.__positionrb0__ = \"SR-DMS4AP{LOCALBUMP}POS:BBA-I\"\n\n self.__bpmposition__ = \"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\"\n self.__bpmorbitx__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\"\n self.__bpmorbity__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\"\n self.__bpmorbitx0__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\"\n self.__bpmorbity0__ = \"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\"\n\n self.__correctorposition__ = \"SR-DMS4AP{LOCALBUMP:COR}Pos-I\"\n self.__hcorrectorcurrent__ = \"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\"\n self.__hcorrectordiff__ = \"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\"\n self.__vcorrectorcurrent__ = \"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\"\n self.__vcorrectordiff__ = \"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\"\n\n self.__undo__ = \"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\"\n self.__apply__ = \"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\"\n self.__status__ = \"SR-DMS4AP{LOCALBUMP}TS-I\"\n self.__idposinfo__ = \"SR-DMS4AP{LOCALBUMP}S-I\"\n self.__srcposition__ = \"SR-DMS4AP{LOCALBUMP}SRC-SP\"","def test_order_atoms(self):\n mol1 = converter.s_bonds_mol_from_xyz(self.xyz10['dict'])\n mol2 = converter.s_bonds_mol_from_xyz(self.xyz10['dict_diff_order1'])\n mol3 = converter.s_bonds_mol_from_xyz(self.xyz10['dict_diff_order2'])\n converter.order_atoms(ref_mol=mol1, mol=mol2)\n for atom1, atom2 in zip(mol1.atoms, mol2.atoms):\n self.assertEqual(atom1.symbol, atom2.symbol)\n converter.order_atoms(ref_mol=mol3, mol=mol1)\n for atom1, atom2 in zip(mol3.atoms, mol1.atoms):\n self.assertEqual(atom1.symbol, atom2.symbol)\n\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\n for mol in mol_list:\n converter.order_atoms(ref_mol=ref_mol, mol=mol)\n bond_dict = dict()\n for index1, atom1 in enumerate(ref_mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = ref_mol.atoms.index(atom2)\n if index1 < index2:\n if index1 not in bond_dict:\n bond_dict[index1] = [index2]\n else:\n bond_dict[index1].append(index2)\n for index1, atom1 in enumerate(mol.atoms):\n for atom2 in atom1.edges.keys():\n index2 = mol.atoms.index(atom2)\n if index1 < index2:\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols","def sort_poscar(by, key=None, reverse=False, poscar_filename=\"POSCAR\", cal_loc=\".\"):\n available_by_list = [\"atomic_species\", \"cart_coords\", \"frac_coords\", \"selective_dynamics_mode\", \"lattice_matrix\"]\n assert by in available_by_list, 'Input argument \"by\" of fuction sort_poscar must be \"atomic_species\", \"cart_coords\", \"frac_coords\", \"selective_dynamics_mode\" or \"lattice_matrix\"'\n poscar_dict = read_poscar(poscar_filename=poscar_filename, cal_loc=cal_loc)\n \n sorted_index_list = [ind_value_pair[0] for ind_value_pair in sorted(enumerate(poscar_dict[by]), key=key, reverse=reverse)]\n if by in [\"atomic_species\", \"cart_coords\", \"frac_coords\", \"selective_dynamics_mode\"]:\n for quantity in [\"atomic_species\", \"cart_coords\", \"frac_coords\", \"selective_dynamics_mode\"]:\n poscar_dict[quantity] = [poscar_dict[quantity][ind] for ind in sorted_index_list]\n elif by == \"lattice_matrix\":\n new_lattice_matrix = [poscar_dict[\"lattice_matrix\"][ind] for ind in sorted_index_list]\n poscar_dict[\"lattice_matrix\"] = new_lattice_matrix\n poscar_dict.update(get_lattice_properties(new_lattice_matrix))\n for quantity in [\"cart_coords\", \"frac_coords\", \"selective_dynamics_mode\"]:\n for atom_ind, atom_quantity in enumerate(poscar_dict[quantity]):\n new_atom_quantity = [atom_quantity[ind] for ind in sorted_index_list]\n poscar_dict[quantity][atom_ind] = new_atom_quantity\n else:\n raise Exception(\"You should not arrive here!\")\n \n return poscar_dict","def set_init_pose(self, init_pose):\n \tself.check_publishers_connection()\n \tself.move_joints(init_pose)","def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\n\n Mol_SO = 0\n \n # Special Case - Acetleyne - S\n if Nat == 4 and multip == 2 and charge == 1:\n countH_temp =0\n countC_temp =0\n for tmp in range(len(sym)):\n if sym[tmp] == \"H\":\n countH_temp= countH_temp +1\n if sym[tmp] == \"C\":\n countC_temp = countC_temp +1\n if countH_temp == 2 and countC_temp == 2:\n Mol_SO = -0.07 #-0.07d0\n \n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\n\")\n ther_chem.write(\"Ref: JCP 114, 9287, 2001\\n\\n\")\n # Special Case - Acetleyne - E\n \n # For diatomics with multip = 2\n if Nat == 2 and multip == 2 :\n sort_sym = sorted(sym, reverse=True)\n if SO_3rdrow_mols_val == \"true\": # for 3rd_row elements\n \n if charge == 0:\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\n \n # COMMMENT: paper has it for cation, but it looks like it is for neutral\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\n \n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\n \n else: # for non 3rd row elements, first and second rows\n if charge == 0:\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\n \n if charge == -1:\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\n \n if charge == +1:\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\n \n return(Mol_SO)","def standarization_ofPScodomain(a2_data, PS):\n\n if 'grid' not in PS['nmlz']['indx'].keys():\n raise RuntimeError('py-user indexed grid required for mapping codomain')\n\n # generating mapping from a2 to py in FP style\n # ATTENTION: \"-1\" is substracted from the return a2 tuple due to a2 starting indexing with 1\n # while this info is not present in the incoming data this has to be hardcoded in the mapping\n map_a2_2_py = []\n for dimi in PS['real']['data'].keys():\n if dimi.dim_name.lower() == \"burnup\":\n if dimi.a2_idx is not None:\n raise RuntimeError('assumed indexation g(iota,bu) is false')\n else:\n map_a2_2_py.append(lambda x, i_bound=dimi.a2_idx: x[i_bound] - 1)\n\n # print map_a2_2_py\n # sys.exit()\n # flatting a2 data as x_{py-grid-point}, g(x)\n gx_unordered = []\n for a2_tuple in a2_data:\n if type(a2_tuple) != tuple:\n raise RuntimeError('cant understand codomain')\n for bu_idx, val in enumerate(a2_data[a2_tuple]):\n gx_unordered.append([tuple([bu_idx] + [f(a2_tuple) for f in map_a2_2_py]), val])\n\n grid_len = len(PS['nmlz']['indx']['grid'])\n if len(gx_unordered) != grid_len:\n print PS['nmlz']['indx']['grid']\n print gx_unordered\n raise RuntimeError('Mismatch between the length of a2 data and corresponding grid points')\n\n # ordering the calc points according to the py-grid (ppack order)\n gx_pygridindex_unordered = []\n for x, gx in gx_unordered:\n try:\n # stored as [required position, value]\n gx_pygridindex_unordered.append([PS['nmlz']['indx']['grid'].index(x), gx])\n except ValueError:\n print 'a2 point could not be found in grid'\n sys.exit()\n\n if len(gx_pygridindex_unordered) != grid_len: # this should be Order(1)\n raise RuntimeError('Mismatch between the length of a2 data and corresponding grid points')\n gx_ordered = np.array([gx[1] for gx in sorted(\n gx_pygridindex_unordered, key=lambda x:x[0])], order='F')\n gx_ordered.setflags(write=False)\n return gx_ordered","def initial(self):\n return zero","def test_mixed_canonize():\n \n for n in range(Nmin, Nmax+1):\n random_state = new_random_state(d, n)\n rand_mps = []\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\n \n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\n rand_mps.append(np.random.rand(*shape)) \n \n MPS_mixedcanonical = rand_mps\n for pos in range(n): \n #set the site at pos as center of orthogonality\n if pos > 0:\n MPS_mixedcanonical = left_canonize(MPS_mixedcanonical[:pos+1]) + MPS_mixedcanonical[pos+1:]\n if pos < n-1:\n MPS_mixedcanonical = MPS_mixedcanonical[:pos] + right_canonize(MPS_mixedcanonical[pos:])\n\n if pos > 0:\n assert check_left_canonization(MPS_mixedcanonical[:pos+1]), \"Error in mixed left\"\n if pos < n-1:\n assert check_right_canonization(MPS_mixedcanonical[pos:]), \"Error in mixed right\"","def move(self):\n \"\"\" Responsible for transformations \"\"\"\n pos, com, success = self.perception \n if self.destination is None:\n return array([0,0])\n\n if not self.awake:\n return array([0,0])\n\n\n if self.phase == 4 and self.proper_formation is not None:\n no_go = []\n for i in range(0,len(self.proper_formation)):\n if i != self.order and self.proper_formation[i][0] == self.proper_formation[self.order][0]:\n no_go.append(self.transform(self.proper_formation[i][1] - self.position))\n pos = merge_array_lists(pos, no_go)\n\n if self.phase == 2:\n point = self.destination.copy() - self.position\n elif self.phase > 2:\n point = self.transform(self.destination.copy() - self.position)\n else:\n point = self.destination.copy()\n\n if not array_equal(point, array([0,0])):\n reachable, path = findpathtoclosest(array([0,0]), point, pos)\n \n if len(path) == 0:\n move = array([0,0]) \n else:\n move = path[0]\n if not reachable and not array_equal(move,array([0,0])):\n if self.phase == 2:\n self.closest_i_could_get = path[-1] + self.position\n elif self.phase > 2:\n self.closest_i_could_get = self.transform2(path[-1]) + self.position\n else:\n self.closest_i_could_get = path[-1]\n elif not reachable:\n if self.phase > 1:\n self.closest_i_could_get = self.position\n else:\n self.closest_i_could_get = array([0,0])\n else:\n self.closest_i_could_get = None\n\n if reachable and self.phase == 4 and array_equal(move,array([0,0])):\n move = self.randomStep()\n self.closest_i_could_get = None\n\n else:\n move = array([0,0])\n self.closest_i_could_get = None\n\n return move","def __init__(self, slipPlane, slipDir, crystalStructure, cOverA=None):\n self.crystalStructure = crystalStructure\n\n # Stored as Miller indices (Miller-Bravais for hexagonal)\n self.planeIdc = tuple(slipPlane)\n self.dirIdc = tuple(slipDir)\n\n # Stored as vectors in a cartesian basis\n if self.crystalStructure.name == \"cubic\":\n self.slipPlane = slipPlane / norm(slipPlane)\n self.slipDir = slipDir / norm(slipDir)\n self.cOverA = None\n elif self.crystalStructure.name == \"hexagonal\":\n if cOverA is None:\n raise Exception(\"No c over a ratio given\")\n self.cOverA = cOverA\n\n # Convert plane and dir from Miller-Bravais to Miller\n slipPlaneM = convertIdc('mb', plane=slipPlane)\n slipDirM = convertIdc('mb', dir=slipDir)\n\n # Transformation from crystal to orthonormal coords\n lMatrix = CrystalStructure.lMatrix(\n 1, 1, cOverA, np.pi / 2, np.pi / 2, np.pi * 2 / 3\n )\n # Q matrix for transforming planes\n qMatrix = CrystalStructure.qMatrix(lMatrix)\n\n # Transform into orthonormal basis and then normalise\n self.slipPlane = np.matmul(qMatrix, slipPlaneM)\n self.slipPlane /= norm(self.slipPlane)\n self.slipDir = np.matmul(lMatrix, slipDirM)\n self.slipDir /= norm(self.slipDir)\n else:\n raise Exception(\"Only cubic and hexagonal currently supported.\")","def init_m(pos):\n x, y, z = pos\n\n k = 0.1\n nx = k * (x - 0.5)\n\n return (0, np.sin(nx), np.cos(nx))","def align_c_axis_along_001(structure):\n\n c = structure.lattice._matrix[2]\n z = [0, 0, 1]\n axis = np.cross(c, z)\n if not(axis[0] == 0 and axis[1] == 0):\n theta = (np.arccos(np.dot(c, z) / (np.linalg.norm(c) * np.linalg.norm(z))))\n R = get_rotation_matrix(axis, theta)\n rotation = SymmOp.from_rotation_and_translation(rotation_matrix=R)\n structure.apply_operation(rotation)\n return structure","def rip1_to_parp():\n Monomer('MLKL', ['bRHIM', 'state'], {'state':['unmod', 'active', 'inactive']})\n Parameter('MLKL_0' , 1.0e6) # molecules per cell\n alias_model_components()\n Initial(MLKL(bRHIM = None, state = 'unmod'), MLKL_0) # MLKL\n \n Rule('Rip_PO4lation', RIP1(bRHIM=ANY, state = 'unmod')%RIP3(bRHIM=ANY, state='unmod') >> RIP1(bRHIM=ANY, state = 'po4')%RIP3(bRHIM=ANY, state = 'po4'), Parameter('k19', 1e-1))\n Rule('Rip_PO4lation_alt', RIP1(bRHIM=ANY, state = 'deub')%RIP3(bRHIM=ANY, state='unmod') >> RIP1(bRHIM=ANY, state = 'po4')%RIP3(bRHIM=ANY, state = 'po4'), Parameter('k19a', 1e-1))\n \n catalyze_state(RIP1(state='po4'), 'bPARP', MLKL(), 'bRHIM', 'state', 'unmod', 'active', [1e-6,1e-3, 1e-1])\n catalyze_state(MLKL(state='active'), 'bRHIM', MLKL(), 'bRHIM', 'state', 'unmod', 'active', [1e-7, 0.2, 0.01])","def metropolis_step(self, positions):\n \"\"\"with brute-force sampling of new positions.\"\"\"\n\n # r = random.random()*random.choice((-1, 1))\n # r is a random number drawn from the uniform prob. dist. in [0,1]\n r = np.zeros(self.num_d)\n for i in range(self.num_d):\n r[i] = np.random.uniform(-1, 1)\n # Pick a random particle\n random_index = np.random.randint(0, high=len(positions))\n new_positions = np.array(positions)\n new_random_position = new_positions[random_index, :]\n # Suggest a new move\n new_positions[random_index, :] = new_random_position + r*self.delta_R\n # Old system and wavefunction\n wavefunction = self.w.wavefunction(positions)\n old_wavefunction_squared = wavefunction**2\n\n # Test the new position with a new system and wavefunction\n # sys_test = System(self.num_p, self.num_d)\n # sys_test.positions_distances(new_positions)\n # alpha = self.w.alpha\n # beta = self.w.beta\n # a = self.w.a\n # wave_test = Wavefunction(self.num_p, self.num_d, alpha, beta, a, sys_test)\n # test_wavefunction = wave_test.wavefunction(new_positions)\n test_wavefunction = self.w.wavefunction(new_positions)\n\n new_wavefunction_squared = test_wavefunction**2\n # print ('Old = ', positions)\n\n if new_wavefunction_squared <= 1e-14:\n pass\n else:\n # acceptance_ratio = self.w.wavefunction_ratio(positions,\n # new_positions)\n acceptance_ratio = new_wavefunction_squared/old_wavefunction_squared\n epsilon = np.random.sample()\n\n if acceptance_ratio > epsilon:\n positions = new_positions\n # print ('New = ', positions)\n # self.s.distances_update(positions, random_index)\n # self.s.positions_distances(new_positions)\n self.c += 1.0\n\n else:\n pass\n\n return positions","def initialize_from_ramp(self):\n self.center_position = self.ramp_object.top_center","def test_phase_damping_error_full_canonical(self):\n error = phase_damping_error(1, canonical_kraus=True)\n circ, p = error.error_term(0)\n targets = [np.diag([1, 0]), np.diag([0, 1])]\n self.assertEqual(p, 1, msg=\"Kraus probability\")\n self.assertEqual(circ[0][\"qubits\"], [0])\n for op in circ[0]['params']:\n self.remove_if_found(op, targets)\n self.assertEqual(targets, [], msg=\"Incorrect kraus matrices\")","def firstpass(data, pbc, symbols, units):\n # Get units information\n units_dict = style.unit(units)\n \n # Initialize parameter values\n atomsstart = None\n velocitiesstart = None\n natoms = None\n natypes = None\n firstatoms = False\n atomscolumns = 0\n masses = None\n num_masses_to_read = 0\n xlo = xhi = ylo = yhi = zlo = zhi = None\n xy = 0.0\n xz = 0.0\n yz = 0.0\n i = 0\n \n # Read str and files in the same way\n with uber_open_rmode(data) as fp:\n \n # Loop over all lines in fp\n for i, fullline in enumerate(fp):\n try:\n fullline = fullline.decode('UTF-8')\n except:\n pass\n \n # Remove comments after '#'\n try:\n comment_index = fullline.index('#')\n except:\n line = fullline\n else:\n line = fullline[:comment_index]\n \n terms = line.split()\n\n # Skip blank lines\n if len(terms)>0:\n \n # Read number of atoms \n if len(terms) == 2 and terms[1] == 'atoms':\n natoms = int(terms[0])\n\n # Read number of atom types\n elif len(terms) == 3 and terms[1] == 'atom' and terms[2] == 'types': \n natypes = int(terms[0])\n \n # Read boundary info\n elif len(terms) == 4 and terms[2] == 'xlo' and terms[3] == 'xhi':\n xlo = uc.set_in_units(float(terms[0]), units_dict['length'])\n xhi = uc.set_in_units(float(terms[1]), units_dict['length'])\n\n elif len(terms) == 4 and terms[2] == 'ylo' and terms[3] == 'yhi':\n ylo = uc.set_in_units(float(terms[0]), units_dict['length'])\n yhi = uc.set_in_units(float(terms[1]), units_dict['length'])\n\n elif len(terms) == 4 and terms[2] == 'zlo' and terms[3] == 'zhi':\n zlo = uc.set_in_units(float(terms[0]), units_dict['length'])\n zhi = uc.set_in_units(float(terms[1]), units_dict['length'])\n\n elif len(terms) == 6 and terms[3] == 'xy' and terms[4] == 'xz' and terms[5] == 'yz':\n xy = uc.set_in_units(float(terms[0]), units_dict['length'])\n xz = uc.set_in_units(float(terms[1]), units_dict['length'])\n yz = uc.set_in_units(float(terms[2]), units_dict['length'])\n \n # Identify starting line number for Atoms data\n elif len(terms) == 1 and terms[0] == 'Atoms':\n atomsstart = i + 1\n firstatoms = True\n\n # Check for atom_style comment\n try: \n comment_index = fullline.index('#')\n except:\n atom_style = None\n else:\n atom_style = fullline[comment_index + 1:].strip()\n \n # Count number of columns in Atoms table\n elif firstatoms:\n atomscolumns = len(terms)\n firstatoms = False\n \n # Identify starting line for Masses data\n elif len(terms) == 1 and terms[0] == 'Masses':\n if natypes is None:\n raise FileFormatError('# atom types must appear before Masses list')\n masses = [None for i in range(natypes)]\n num_masses_to_read = natypes\n \n # Read masses\n elif num_masses_to_read > 0:\n read_mass(terms, masses)\n num_masses_to_read -= 1\n\n # Identify starting line number for Velocity data\n elif len(terms) == 1 and terms[0] == 'Velocities':\n velocitiesstart = i + 1\n \n if i == 0:\n raise FileNotFoundError(f'File {data} not found')\n\n if natoms is None:\n raise FileFormatError('# atoms not found')\n\n if xlo is None or xhi is None:\n raise FileFormatError('xlo, xhi box dimensions missing')\n\n if ylo is None or yhi is None:\n raise FileFormatError('ylo, yhi box dimensions missing')\n\n if zlo is None or zhi is None:\n raise FileFormatError('zlo, zhi box dimensions missing')\n\n if atomsstart is None:\n raise FileFormatError('Atoms section missing')\n\n # Create system with natoms\n box = Box(xlo=xlo, xhi=xhi,\n ylo=ylo, yhi=yhi,\n zlo=zlo, zhi=zhi,\n xy=xy, xz=xz, yz=yz)\n atoms = Atoms(natoms=natoms)\n system = System(box=box, atoms=atoms, pbc=pbc, symbols=symbols,\n masses=masses)\n\n # Compile dict of params\n params = {}\n params['atomsstart'] = atomsstart\n params['velocitiesstart'] = velocitiesstart\n params['atomscolumns'] = atomscolumns\n params['atom_style'] = atom_style\n\n return system, params","def generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos):\n out_name='POSCAR.'+formu\n out_name='POSCAR_files/'+out_name.replace(' ','')\n openfile = open(out_name,'wt')\n openfile.write(formu+'\\n')\n openfile.write(str(1.0)+'\\n')\n for str_lines in mat_list:\n openfile.write(str_lines+'\\n')\n openfile.write(my_ordered_elements+'\\n')\n openfile.write(my_ordered_numbers+'\\n')\n openfile.write('direct'+'\\n')\n for string_lines in revise_dos:\n openfile.write(string_lines+'\\n')\n openfile.close()","def initial_setup(N,L,dim):\r\n r = np.zeros((3,N))\r\n #n = int(np.rint((N/3)**(1/dim)))\r\n #nz = int(n+n)\r\n x1 = np.linspace(0+L/n/2,L-L/n/2,n)\r\n d0 = 1.0e-10 #intial distance between hydrogen and oxygen\r\n x2 = x1 + d0\r\n x3 = x1 - d0/np.sqrt(2)\r\n z = np.zeros(3*n)\r\n xy = np.zeros(3*n)\r\n for ii in range(n):\r\n z[ii*3+1] = x1[ii]\r\n z[ii*3+2] = x2[ii]\r\n z[ii*3] = x3[ii]\r\n xy[ii*3] = x1[ii]\r\n xy[ii*3+1] = x1[ii]\r\n xy[ii*3+2] = x1[ii]\r\n rx, ry,rz = np.meshgrid(x1,x1,z)\r\n r[0,:] = np.reshape(rx,N)\r\n r[1,:] = np.reshape(ry,N)\r\n r[2,:] = np.reshape(rz,N)\r\n r[0,0::3] += d0/np.sqrt(2) #add additional offset to one Oxygen\r\n return r","def init_position(self):\n if self.invert_init_angle is False:\n self.theta_i_top = -self.theta_s_top\n self.theta_i_bot = -self.theta_s_bot\n else:\n self.theta_i_top = self.theta_s_top\n self.theta_i_bot = self.theta_s_bot\n\n self.move_mid_block(theta=self.theta_i_bot)\n self.move_top_block(theta=self.theta_i_top)\n\n # Variables used to motion\n self.x_offset = self.block_top.center.x\n self.d_top = np.sin(self.theta_s_top) * self.bars_top.length * 2\n self.d_bot = np.sin(self.theta_s_bot) * self.bars_bot.length * 2","def initial_coordinates(mof, energy_map, atom_list, energy_limit):\n reference_atom = 'C'\n ref_atom_index = atom_list['atom'].index(reference_atom) + 3\n initial_coors = []\n energy_count = 0\n pbc_count = 0\n for emap_line in energy_map:\n emap_coor = Coor([emap_line[0], emap_line[1], emap_line[2]])\n pbc_coor = emap_coor.pbc(mof.uc_size, mof.uc_angle, mof.frac_ucv)\n pbc_x = round(pbc_coor.x, 1)\n pbc_y = round(pbc_coor.y, 1)\n pbc_z = round(pbc_coor.z, 1)\n # print(emap_coor.x, pbc_x)\n if pbc_x == emap_coor.x and pbc_y == emap_coor.y and pbc_z == emap_coor.z:\n if emap_line[ref_atom_index] < energy_limit:\n initial_coors.append(Coor([emap_line[0], emap_line[1], emap_line[2]]))\n else:\n energy_count += 1\n else:\n pbc_count += 1\n\n # print('Ommited PBC: ', pbc_count, ' Energy: ', energy_count)\n return initial_coors","def get_construction_order(self) -> int:\n return 0","def __init__(self, phase, lc, err, airmass, crpa, common_mode_array, \\\n psf_width, psf_width_ratio, psf_yposition, shift_position,\n x1_array, prior_string, priorsigmas):\n self.phase = phase\n self.lc = lc\n self.err= err\n self.airmass = airmass\n self.crpa = crpa\n self.common_mode_array = common_mode_array\n self.psf_width = psf_width\n self.psf_width_ratio = psf_width_ratio\n self.psf_yposition = psf_yposition\n self.shift_position = shift_position\n self.x1_array = x1_array ## generic additional correction.\n self.prior_string = prior_string ## prior shape, 'gaus', 'tophat'\n self.priorsigmas = priorsigmas","def _initialize_default_start(self, state):\n state.tau = self.rng.gamma(0.5, 1 / self.fixed.tau_rate)\n eta = self.rng.standard_normal(self.fixed.n)\n eta = eta - eta.mean()\n state.eta = eta\n state.spatial = self.state.eta\n state.alpha = self.rng.multivariate_normal(\n self.fixed.a_mu, 100 * self.fixed.a_prec, method='cholesky'\n )\n state.beta = self.rng.multivariate_normal(\n self.fixed.b_mu, 100 * self.fixed.b_prec, method='cholesky'\n )\n return state","def sequence_rr_legacy(mol):\n F = Filters()\n Cleanup(mol)\n SanitizeMol(mol, sanitizeOps=SanitizeFlags.SANITIZE_ALL, catchErrors=False)\n AssignStereochemistry(mol, cleanIt=True, force=True, flagPossibleStereoCenters=True) # Fix bug TD201904.01\n mol = F.remove_isotope(mol)\n mol = F.neutralise_charge(mol)\n SanitizeMol(mol, sanitizeOps=SanitizeFlags.SANITIZE_ALL, catchErrors=False)\n mol = F.keep_biggest(mol)\n mol = F.add_hydrogen(mol, addCoords=True)\n mol = F.kekulize(mol)\n return mol","def _set_init_pose(self):\n raise NotImplementedError()","def _set_init_pose(self):\n raise NotImplementedError()","def _set_init_pose(self):\n raise NotImplementedError()","def restorePositionsOfUnownedAntennas() :\n if ( s.getInitializationFlag() == True ): return\n unownedAnts = subarrayAntSetup( True )\n progress(\"Setting positions of unowned and uninitialized antennas %s\" % helpers.formatAsRanges( unownedAnts) )\n progress(\"....Pads\")\n restoreAntCommand(pad, unownedAnts, subarray=DEFAULT)\n progress( \"....Pad Offsets\" )\n restoreAntCommand( padOffset, unownedAnts, subarray=DEFAULT )\n progress(\"....Antenna positional offset and axis non-intersection\")\n restoreAntCommand( antennaOffset, unownedAnts, subarray=DEFAULT )\n restoreAntCommand( axisNonIntersection, unownedAnts, subarray=DEFAULT )","def __init__(self, init_pose=None, init_velocities=None, \n init_angle_velocities=None, runtime=5., target_pos=None):\n \n # initial state\n self.state_scale = 1\n \n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\n self.init_pose[2] += 10\n self.init_velocities = np.array([0.,0.,0.])\n self.init_angle_velocities = np.array([0.,0.,0.])\n\n self.runtime = runtime\n \n # Simulation\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \n self.action_repeat = 1\n\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\n self.state_size = self.action_repeat * self.init_state.shape[0]\n \n self.action_low = 0 #-1\n self.action_high = 2*450 #1\n self.action_size = 4\n\n self.action_scale = 1 #450 # 1/2 max of the action \n #self.state_scale = 150 # 1/2 size of the state space\n \n # Goal\n self.target_pose = np.array([0.,0.,150.0])\n\n # The previous position\n self.prev_pose = self.init_pose","def test_known_commutators():\n fock = LocalSpace(\"0\")\n spin = SpinSpace(\"0\", spin=1)\n a = Destroy(hs=fock)\n a_dag = Create(hs=fock)\n assert Commutator.create(a, a_dag) == IdentityOperator\n assert Commutator.create(a_dag, a) == -IdentityOperator\n\n assert Commutator.create(\n LocalSigma(1, 0, hs=fock), LocalSigma(0, 1, hs=fock)\n ) == LocalProjector(1, hs=fock) - LocalProjector(0, hs=fock)\n assert Commutator.create(\n LocalSigma(1, 0, hs=fock), LocalProjector(1, hs=fock)\n ) == (-1 * LocalSigma(1, 0, hs=fock))\n assert Commutator.create(\n LocalSigma(1, 0, hs=fock), LocalProjector(0, hs=fock)\n ) == LocalSigma(1, 0, hs=fock)\n assert Commutator.create(LocalSigma(1, 0, hs=fock), Create(hs=fock)) == (\n -sqrt(2) * LocalSigma(2, 0, hs=fock)\n )\n assert Commutator.create(Jplus(hs=spin), Jz(hs=spin)) == -Jplus(hs=spin)","def robot6_sphericalwrist_invkin(robot, desired_pose, last_joints = None):\n \n \n \n R06 = desired_pose.R\n p0T = desired_pose.p\n \n if robot.R_tool is not None and robot.p_tool is not None:\n R06 = R06.dot(np.transpose(robot.R_tool))\n p0T = p0T - R06.dot(robot.p_tool)\n \n H = robot.H\n P = robot.P\n \n theta_v = []\n \n #Correct for spherical joint position vectors\n if not np.all(P[:,4] == 0):\n P4_d = P[:,4].dot(H[:,3])\n assert np.all(P[:,4] - P4_d*H[:,3] == 0)\n P[:,3] += P[:,4]\n P[:,4] = np.zeros(3)\n \n if not np.all(P[:,5] == 0):\n P5_d = P[:,5].dot(H[:,5])\n assert np.all(P[:,5] - P5_d*H[:,5] == 0)\n P[:,6] += P[:,5]\n P[:,5] = np.zeros(3) \n \n d1 = np.dot(ey, P[:,1] + P[:,2] + P[:,3])\n v1 = p0T - R06.dot(P[:,6]) \n p1 = ey\n \n Q1 = rox.subproblem4(p1, v1, -H[:,0], d1)\n \n normalize = normalize_joints(robot, last_joints)\n \n for q1 in normalize(0, Q1):\n \n R01=rox.rot(H[:,0], q1)\n \n p26_q1 = R01.T.dot(p0T - R06.dot(P[:,6])) - (P[:,0] + P[:,1])\n \n d3 = np.linalg.norm(p26_q1)\n v3 = P[:,2] \n p3 = P[:,3]\n Q3 = rox.subproblem3(p3, v3, H[:,2], d3)\n \n for q3 in normalize(2,Q3):\n \n R23=rox.rot(H[:,2],q3)\n \n v2 = p26_q1 \n p2 = P[:,2] + R23.dot(P[:,3])\n q2 = rox.subproblem1(p2, v2, H[:,1])\n \n q2 = normalize(1, [q2])\n if len(q2) == 0:\n continue\n q2 = q2[0] \n \n R12 = rox.rot(H[:,1], q2)\n \n R03 = R01.dot(R12).dot(R23)\n \n R36 = R03.T.dot(R06)\n \n v4 = R36.dot(H[:,5]) \n p4 = H[:,5]\n \n Q4_Q5 = rox.subproblem2(p4, v4, H[:,3], H[:,4])\n \n for q4, q5 in normalize((3,4), Q4_Q5):\n \n R35 = rox.rot(H[:,3], q4).dot(rox.rot(H[:,4], q5))\n R05 = R03.dot(R35)\n R56 = R05.T.dot(R06)\n \n p6 = H[:,4]\n v6 = R56.dot(H[:,4])\n \n q6 = rox.subproblem1(p6, v6, H[:,5])\n \n q6 = normalize(5, [q6])\n if len(q6) == 0:\n continue\n q6 = q6[0]\n \n theta_v.append(np.array([q1, q2, q3, q4, q5, q6])) \n if last_joints is not None:\n theta_dist = np.linalg.norm(np.subtract(theta_v,last_joints), axis=1)\n return [theta_v[i] for i in list(np.argsort(theta_dist))]\n else:\n return theta_v","def model_prem(r):\n\n\t#- normalised radius\n\tx = r / 6371000.0\n\n\t#- march through the various depth levels -----------------------------------------------------\n\n\t#- upper crust\n\tif (r >= 6356000.0):\n\t\trho = 2.6\n\t\tvpv = 5.8\n\t\tvph = vpv\n\t\tvsv = 3.2\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- lower crust\n\telif (r >= 6346000.6) & (r < 6356000.0):\n\t\trho = 2.9\n\t\tvpv = 6.8\n\t\tvph = vpv\n\t\tvsv = 3.9\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- LID\n\telif (r >= 6291000.0) & (r < 6346000.6):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 0.8317 + 7.2180 * x\n\t\tvph = 3.5908 + 4.6172 * x\n\t\tvsv = 5.8582 - 1.4678 * x\n\t\tvsh = -1.0839 + 5.7176 * x\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- LVZ\n\telif (r >= 6151000.0) & (r < 6291000.0):\n\t\trho = 2.6910 + 0.6924 * x\n\t\tvpv = 0.8317 + 7.2180 * x\n\t\tvph = 3.5908 + 4.6172 * x\n\t\tvsv = 5.8582 - 1.4678 * x\n\t\tvsh = -1.0839 + 5.7176 * x\n\t\teta = 3.3687 - 2.4778 * x\n\n\t#- Transition zone 1\n\telif (r >= 5971000.0) & (r < 6151000.0):\n\t\trho = 7.1089 - 3.8045 * x\n\t\tvpv = 20.3926 - 12.2569 * x\n\t\tvph = vpv\n\t\tvsv = 8.9496 - 4.4597 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 2\n\telif (r >= 5771000.0) & (r < 5971000.0):\n\t\trho = 11.2494 - 8.0298 * x\n\t\tvpv = 39.7027 - 32.6166 * x\n\t\tvph = vpv\n\t\tvsv = 22.3512 - 18.5856 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Transition zone 3\n\telif (r >= 5701000.0) & (r < 5771000.0):\n\t\trho = 5.3197 - 1.4836 * x\n\t\tvpv = 19.0957 - 9.8672 * x\n\t\tvph = vpv\n\t\tvsv = 9.9839 - 4.9324 * x\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 1\n\telif (r >= 5600000.0) & (r < 5701000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- Lower mantle 2\n\telif (r >= 3630000.0) & (r < 5600000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\n\t\tvph = vpv\n\t\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Lower mantle 3\n\telif (r >= 3480000.0) & (r < 3630000.0):\n\t\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\n\t\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\n\t\tvph = vpv\n\t\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\n\t\tvsh = vsv\n\t\teta = 1.0\n\n\t#- Outer core\n\telif (r >= 1221000.5) & (r < 3480000.0):\n\t\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\n\t\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\n\t\tvph = vpv\n\t\tvsv = 0.0\n\t\tvsh = 0.0\n\t\teta = 1.0\n\n\t#- Inner Core\n\telif (r >= 0.0) & (r < 1221000.5):\n\t\trho = 13.0885 - 8.8381 * x**2\n\t\tvpv = 11.2622 - 6.3640 * x**2\n\t\tvph = vpv\n\t\tvsv = 3.6678 - 4.4475 * x**2\n\t\tvsh = vsv\n\t\teta = 1.0 \n\n\t#- convert to elastic parameters --------------------------------------------------------------\n\n\trho = 1000.0 * rho\n\tvpv = 1000.0 * vpv\n\tvph = 1000.0 * vph\n\tvsv = 1000.0 * vsv\n\tvsh = 1000.0 * vsh\n\n\tA = rho * vph**2\n\tC = rho * vpv**2\n\tN = rho * vsh**2\n\tL = rho * vsv**2\n\tF = eta * (A - 2 * L)\n\n\treturn rho, A, C, F, L, N","def _initialise(self):\n if self._running:\n raise RuntimeError('Already initialised.')\n\n # Propose x0 as first points\n # Note proposal is multiple points this time!\n self._current = None\n self._current_log_pdfs = None\n self._proposed = self._x0\n self._proposed.setflags(write=False)\n\n # Number of chains left to update in this cycle\n self._remaining = np.arange(self._n_chains)\n\n # Update sampler state\n self._running = True","def initial_importer(initials, initialZMT=True):\n from .functions import cosd, lna\n ###filling the running variables with values depending on the systemconfiguration in rk4input###\n\n if Base.spatial_resolution == 0:\n dim = 0\n print('0D')\n Vars.T = initials['zmt']\n else:\n dim = 1\n # NS==True corresponds to southpole to northpole representation (180 Degrees)\n if Base.both_hemispheres == True:\n Latrange = 180\n\n # Checking if Temperature and Latitude is set on a latitudal circle (0°,10°,..if step=10)\n # or on a latitudinal belt and therefore between the boundaries (5°,15°,..if step=10)\n\n # circle==True and belt==False says on the latitudinal circle\n if Base.latitudinal_circle == True and Base.latitudinal_belt == False:\n Vars.Lat = np.linspace(-90 + Base.spatial_resolution, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution - 1))\n Vars.Lat2 = np.linspace(-90, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\n if initialZMT == True:\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution - 1))\n # Checking if the Temperature for each latitude starts with the same value or a\n # cosine shifted value range\n if initials['initial_temperature_cosine'] == True:\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\n\n # circle==False and belt==True say on the latitudinal belt\n if Base.latitudinal_circle == False and Base.latitudinal_belt == True:\n Vars.Lat2 = np.linspace(-90 + Base.spatial_resolution, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution - 1))\n Vars.Lat = np.linspace(-90, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\n if initialZMT == True:\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\n if initials['initial_temperature_cosine'] == True:\n if initials['initial_temperature_noise'] == True:\n z = [0] * len(Vars.Lat)\n for k in range(len(Vars.Lat)):\n z[k] = np.random.normal(0, initials['initial_temperature_noise_amplitude'])\n else:\n z = 0\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1) + lna(z)\n\n # Not from southpole to northpole rather equator to pole\n else:\n Latrange = 90\n if Base.latitudinal_circle == True and Base.latitudinal_belt == False:\n Vars.Lat = np.linspace(0, 90 - Base.spatial_resolution, int(Latrange / Base.spatial_resolution))\n Vars.Lat2 = np.linspace(0, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\n if initialZMT == True:\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\n if initials['initial_temperature_cosine'] == True:\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\n if Base.latitudinal_circle == False and Base.latitudinal_belt == True:\n Vars.Lat2 = np.linspace(0, 90 - Base.spatial_resolution, int(Latrange / Base.spatial_resolution))\n Vars.Lat = np.linspace(0, 90 - Base.spatial_resolution,\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\n if initialZMT == True:\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\n if initials['initial_temperature_cosine'] == True:\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\n\n Vars.t = initials['time']\n if Base.parallelization == True:\n if initialZMT == True:\n Vars.T = np.array([Vars.T] * Base.number_of_parallels)\n Vars.T_global = np.array([initials['gmt']] * Base.number_of_parallels)\n else:\n Vars.T_global = initials['gmt']","def neutral_molecule(force_field):\n nodes = [\n (1, {'charge_group': 1, 'resid': 1, 'resname': 'ALA', 'atomname': 'BB',\n 'charge': 0, 'atype': 'P5',\n 'modification': force_field.modifications['N-ter'],\n 'mapping_weights': {0: 1, 5: 1, 1: 1, 4: 1.0, 2: 1, 3: 1, 6: 1, 7: 1},\n 'chain': 'A', 'position': [0.12170435, 0.06658551, -0.0208]}),\n (2, {'charge_group': 2, 'resid': 2, 'resname': 'ALA', 'atomname': 'BB',\n 'charge': 0.0, 'atype': 'P4',\n 'mapping_weights': {12: 1.0, 17: 1.0, 13: 1.0, 16: 1.0, 14: 1.0, 15: 1.0},\n 'chain': 'A', 'position': [0.45269104, 0.23552239, 0.0214209]}),\n (3, {'charge_group': 3, 'resid': 3, 'resname': 'ALA', 'atomname': 'BB',\n 'charge': 0.0, 'atype': 'P4',\n 'mapping_weights': {22: 1.0, 27: 1.0, 23: 1.0, 26: 1.0, 24: 1.0, 25: 1.0},\n 'chain': 'A', 'position': [0.74704179, 0.45218955, -0.0214209]}),\n (4, {'charge_group': 4, 'resid': 4, 'resname': 'ALA', 'atomname': 'BB',\n 'charge': 0.0, 'atype': 'P4',\n 'mapping_weights': {32: 1.0, 37: 1.0, 33: 1.0, 36: 1.0, 34: 1.0, 35: 1.0},\n 'chain': 'A', 'position': [1.07289104, 0.61778657, 0.0214209]}),\n (5, {'charge_group': 5, 'resid': 5, 'resname': 'ALA', 'atomname': 'BB',\n 'charge': 0, 'atype': 'P5',\n 'modification': force_field.modifications['C-ter'],\n 'mapping_weights': {42: 1.0, 48: 1.0, 43: 1, 47: 1.0, 44: 1, 45: 1, 46: 1},\n 'chain': 'A', 'position': [1.40449639, 0.85126265, -0.01729157]})\n ]\n mol = Molecule()\n mol.add_nodes_from(nodes)\n mol.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 5)])\n return mol","def test_center_of_coordinates_shift():\n # print sys._getframe().f_code.co_name\n # c = commons()\n\n pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2)\n ncs_obj_phil = ncs.input(\n hierarchy=pdb_inp.construct_hierarchy())\n ncs_restraints_group_list = ncs_obj_phil.get_ncs_restraints_group_list()\n\n # ncs_restraints_group_list = c.ncs_restraints_group_list\n xrs = pdb_inp.xray_structure_simple()\n shifts = ncs_restraints_group_list.get_ncs_groups_centers(\n sites_cart = xrs.sites_cart())\n\n xyz = pdb_inp.atoms().extract_xyz()\n center_of_coor = (flex.vec3_double([xyz.sum()]) * (1/xyz.size())).round(8)\n # test shifts\n t1 = shifts[0].round(8)\n t2 = shifts[1].round(8)\n d1 = flex.sqrt((center_of_coor-t1).dot()).min_max_mean().as_tuple()\n d2 = flex.sqrt((center_of_coor-t2).dot()).min_max_mean().as_tuple()\n assert (d1 == d2)\n\n # test shift to center\n new_nrg = ncs_restraints_group_list.shift_translation_to_center(shifts = shifts)\n expected = (22.63275, 5.54625, 2.9375)\n assert (new_nrg[0].copies[0].t.round(5)).elems == expected\n # back to original coordinates system\n old_nrg = new_nrg.shift_translation_back_to_place(shifts=shifts)\n expected = (old_nrg[0].copies[0].t.round(5)).elems\n result = (ncs_restraints_group_list[0].copies[0].t.round(5)).elems\n assert result == expected","def preprocess(self):\n\n mm_magcoord.add_aacgm_coordinates(self)\n mm_magcoord.add_quasi_dipole_coordinates(self)\n mm_sc.calculate_ecef_velocity(self)\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\n\n return","def test_pair() -> None:\n ra = pybundle.ReconstructionAlignment()\n ra.add_shot(\"1\", 0, 0, 0, 0, 0, 0, False)\n ra.add_shot(\"2\", 0, 0, 0, 0, 0, 0, False)\n ra.add_reconstruction(\"a\", 0, 0, 0, 0, 0, 0, 4, False)\n ra.add_relative_motion_constraint(\n pybundle.RARelativeMotionConstraint(\"a\", \"1\", 0, 0, 0, 0, 0, 0)\n )\n ra.add_relative_motion_constraint(\n pybundle.RARelativeMotionConstraint(\"a\", \"2\", 0, 0, 0, -1, 0, 0)\n )\n ra.add_absolute_position_constraint(\"1\", 1, 0, 0, 1)\n ra.add_absolute_position_constraint(\"2\", 3, 0, 0, 1)\n\n ra.run()\n s1 = ra.get_shot(\"1\")\n s2 = ra.get_shot(\"2\")\n rec_a = ra.get_reconstruction(\"a\")\n\n assert np.allclose(get_shot_origin(s1), [1, 0, 0], atol=1e-6)\n assert np.allclose(get_shot_origin(s2), [3, 0, 0], atol=1e-6)\n assert np.allclose(get_reconstruction_origin(rec_a), [1, 0, 0], atol=1e-6)\n assert np.allclose(rec_a.scale, 0.5)","def test_remove_translational_rotational_dof(positions):\n class DummyTimeStep:\n def __init__(self, positions):\n self.positions = positions\n self.n_atoms = len(positions)\n ts = DummyTimeStep(positions=positions)\n\n transform = RemoveTransRotDOF(\n center_atom_idx=0,\n axis_atom_idx=2,\n plane_atom_idx=3,\n axis='z',\n plane='xz'\n )\n ts = transform(ts)\n\n # The center atom is at the origin.\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\n\n # The axis atom is on the expected axis.\n expected_axis_atom_position = transform.axis * np.linalg.norm(\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\n\n # The plane atom is orthogonal to the plane normal.\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\n\n # The constrained atom indices is correct.\n expected = np.array([0, 1, 2, 6, 7, 10])\n assert np.all(transform.constrained_dof_indices == expected)","def series_partial_order_representation(self, node=None):\n try:\n # Regard sp_order_list as a stack.\n sp_order_stack = list(nx.dfs_preorder_nodes(self.tree, node))\n sp_order_stack.reverse()\n\n # # New a stack to store the lower operation priority element.\n # temp_stack = []\n #\n # # New a list to store the series-parallel partial order formula\n # sp_order_list = []\n #\n # # New a stack to store the completed operations\n # operations_stack = []\n #\n # while len(sp_order_stack) + len(temp_stack) >= 2:\n # # ecah round we check whether the root of the first element is match the third element.\n # # if len(sp_order_stack) >= 3:\n # # the_first_element = sp_order_stack.pop()\n # # else:\n # # the_first_element = temp_stack.pop()\n # # the_second_element = sp_order_stack.pop()\n # # the_third_element = sp_order_stack.pop()\n #\n # current_elements = []\n #\n # while len(current_elements) < 3:\n # if sp_order_stack:\n # current_elements.append(sp_order_stack.pop())\n # else:\n # current_elements.append(temp_stack.pop())\n # current_elements.reverse()\n #\n # print current_elements\n #\n # print \"Current: {} {} {} {}\".format(current_elements[0], current_elements[1], current_elements[2],\n # sp_order_stack)\n # # if match then move the first two elements to sp_order_list\n # if self.tree.predecessors(current_elements[0])[0] == current_elements[2]:\n #\n # if not sp_order_list or self.tree.predecessors(sp_order_list[-1])[0] != current_elements[0]:\n # sp_order_list.append(current_elements[1])\n # # if self.tree.out_degree(the_first_element) > 0 and len(sp_order_stack) == 0:\n # # the_temp_operation_final_element = [[i, j, k] for i, j, k in operations_stack if\n # # k == the_first_element]\n # # i, j = the_temp_operation_final_element[0][0], the_temp_operation_final_element[0][1]\n # #\n # # sp_order_list.append(i)\n # # sp_order_list.append(j)\n # sp_order_list.append(current_elements[0])\n #\n # else:\n # if self.tree.out_degree(current_elements[0]) > 0 and len(sp_order_stack) == 0:\n # the_temp_operation_final_element = [[i, j, k] for i, j, k in operations_stack if\n # k == current_elements[0]]\n # i, j = the_temp_operation_final_element[0][0], the_temp_operation_final_element[0][1]\n #\n # sp_order_list.append(i)\n # sp_order_list.append(j)\n #\n # sp_order_list.append(current_elements[0])\n # sp_order_list.append(current_elements[1])\n # sp_order_stack.append(current_elements[2])\n #\n # else:\n # if self.tree.out_degree(current_elements[0]) > 0 and self.tree.successors(current_elements[0])[\n # 0] in sp_order_list and self.tree.successors(current_elements[0])[1] in sp_order_list:\n # # if the_first_element is the sub-tree that was already searched than\n # # push to operations_stack and put the operator as a stamp to Temp_stack.\n #\n # # else:\n # the_first_operation_element = sp_order_list.pop()\n # the_second_operation_element = sp_order_list.pop()\n # operations_stack.append(\n # [the_second_operation_element, the_first_operation_element, current_elements[0]])\n # temp_stack.append(current_elements[0])\n #\n # stamps_in_operations_stack = [k for i, j, k in operations_stack]\n # if stamps_in_operations_stack and current_elements[0] in stamps_in_operations_stack:\n #\n # # if stamps_in_operations_stack is not null then temp_stack can not be null\n # the_recover_element = temp_stack.pop()\n #\n # # in case of duplicate of the_first_element.\n # if temp_stack and the_recover_element == current_elements[0]:\n # the_recover_element = temp_stack.pop()\n #\n # # Recover the sp_order_stack to process next search.\n # sp_order_stack.append(current_elements[2])\n # sp_order_stack.append(current_elements[1])\n # if the_recover_element:\n # sp_order_stack.append(current_elements[0])\n # sp_order_stack.append(the_recover_element)\n # sp_order_stack.append(current_elements[0])\n #\n # else:\n # if len(temp_stack) <= 0:\n # # if temp_stack is null then store the first element to temp_stack\n # # and put the other two back to sp_order_stack.\n #\n # temp_stack.append(current_elements[0])\n # else:\n # # get a element from temp_stack to check if match\n # # No need to check if sp_order_list is null as at the final round,\n # # they must share the same parent(root).\n #\n # the_temp_element = temp_stack.pop()\n # the_temp_operation_element = [[i, j, k] for i, j, k in operations_stack if\n # k == the_temp_element]\n #\n # # To check the checked node is already a tree that was search.\n # if self.tree.predecessors(the_temp_element)[\n # 0] == current_elements[1] and the_temp_operation_element:\n #\n #\n # # To check if the node shared the same parent is a tree\n # # if so, then add its children before it.\n # # otherwise add itself after the output list.\n # the_temp_operation_second_element = [[i, j, k] for i, j, k in operations_stack if\n # k == current_elements[0]]\n #\n # if the_temp_operation_second_element:\n # i, j = the_temp_operation_second_element[0][0], \\\n # the_temp_operation_second_element[0][1]\n # sp_order_list.append(i)\n # sp_order_list.append(j)\n # operations_stack.remove(the_temp_operation_second_element[0])\n # sp_order_list.append(current_elements[0])\n #\n # i, j, k = the_temp_operation_element[0][0], the_temp_operation_element[0][1], \\\n # the_temp_operation_element[0][2]\n #\n # sp_order_list.append(i)\n # sp_order_list.append(j)\n # sp_order_list.append(k)\n # operations_stack.remove(the_temp_operation_element[0])\n #\n # # if the checked node match its parent\n # elif self.tree.predecessors(the_temp_element)[0] == current_elements[1]:\n # sp_order_list.append(current_elements[0])\n # sp_order_list.append(the_temp_element)\n #\n # # otherwise, put the_temp_element and the_first_element to temp_stack,\n # # as they all are not matched the parent searched so far\n # else:\n # temp_stack.append(the_temp_element)\n # temp_stack.append(current_elements[0])\n #\n # # Recover the sp_order_stack to process next search.\n # sp_order_stack.append(current_elements[2])\n # sp_order_stack.append(current_elements[1])\n #\n #\n # print \"Temp_stack: {}\".format(temp_stack)\n # print \"operations_stack: {}\".format(operations_stack)\n # print \"Output: {}\".format(sp_order_list)\n # print\n #\n # # current_elements.remove(current_elements[0])\n # # current_elements.remove(current_elements[1])\n # # current_elements.remove(current_elements[2])\n #\n # sp_root = sp_order_stack.pop()\n # sp_order_list.append(sp_root)\n #\n # while operations_stack:\n # i, j, k = operations_stack.pop()\n # sp_order_list.insert(sp_order_list.index(k), i)\n # sp_order_list.insert(sp_order_list.index(k), j)\n\n except Exception:\n raise TypeError(\"There is no {} in the binary construction tree\".format(node))\n return sp_order_stack","def test_diatomic_dummy_molecule_rotation_around_molecule_axis():\n mol = Molecule()\n mol.atoms = ['C'] * 2\n mol.coordinates = np.array([[1, 0, 0], [0, 1, 0]])\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi / 2, center=True)\n assert np.allclose(mol.coordinates, [[1, 1, 0], [0, 0, 0]])\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi, center=True)\n assert np.allclose(mol.coordinates, [[0, 0, 0], [1, 1, 0]])"],"string":"[\n \"def propanolIntermediate():\\n coords = [\\n [-1.60306996, 0.10333519, 0.50792736],\\n [-0.66904416, -0.46962566, -0.55371646],\\n [0.67345677, 0.26436258, -0.61179298],\\n [1.26292797, -0.10585085, -1.45392921],\\n [0.49744830, 1.34089332, -0.75955140],\\n [1.47742183, 0.05176805, 0.52349829],\\n [0.98773122, 0.34094585, 1.30125393],\\n [-0.48213061, -1.52528483, -0.34815476],\\n [-1.14165995, -0.39229359, -1.53423716],\\n [-2.56608070, -0.40007121, 0.47312929],\\n [-1.76619136, 1.16652831, 0.34003517],\\n [-1.19366144, -0.03197289, 1.50775619],\\n ]\\n\\n symbols = [\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"O\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n ]\\n\\n atoms = []\\n for i, _ in enumerate(coords):\\n atoms.append(Atom(symbols[i], position=coords[i]))\\n return Molecule(symbols=atoms)\",\n \"def propanolLowest():\\n coords = [\\n [-1.9554949371, 0.1467391618, 0.0031595607],\\n [-0.5906278346, -0.5279387138, -0.0201649611],\\n [0.5440986558, 0.4958779663, 0.0283462055],\\n [0.4812068385, 1.1678478833, -0.8308000219],\\n [0.4590669813, 1.0993020658, 0.9450529713],\\n [1.8195161785, -0.0957487212, -0.0534239359],\\n [1.9103706588, -0.7338049177, 0.6631507673],\\n [-0.5004127933, -1.2028008461, 0.8364936998],\\n [-0.4854009629, -1.1250023438, -0.9282499098],\\n [-2.7476736372, -0.5972665554, -0.0242488945],\\n [-2.0700756998, 0.8040326560, -0.8554507953],\\n [-2.0722381370, 0.7410005769, 0.9069567477],\\n ]\\n\\n symbols = [\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"C\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"O\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n \\\"H\\\",\\n ]\\n\\n atoms = []\\n for i, _ in enumerate(coords):\\n atoms.append(Atom(symbols[i], position=coords[i]))\\n return Molecule(symbols=atoms)\",\n \"def parse_POSCAR(POSCAR=\\\"POSCAR\\\"):\\n\\n fin = open(POSCAR, 'r')\\n poscar = fin.read().splitlines()\\n scaling_para = float(poscar[1])\\n abc = np.array([[float(i) for i in line.split()] for line in poscar[2:5]])\\n\\n # lattice constants in angstrom\\n latt_mat = abc * scaling_para\\n length_a = np.linalg.norm(latt_mat[0, :], 2)\\n length_b = np.linalg.norm(latt_mat[1, :], 2)\\n length_c = np.linalg.norm(latt_mat[2, :], 2)\\n latt_consts = [length_a, length_b, length_c]\\n\\n # angles in degrees\\n alpha = angle_btw(abc[1, :], abc[2, :])\\n beta = angle_btw(abc[0, :], abc[2, :])\\n gamma = angle_btw(abc[0, :], abc[1, :])\\n angles = [alpha, beta, gamma]\\n\\n # Lines 6 and 7 of POSCAR. atomic species and corresponding atoms numbers\\n atomNames = poscar[5].split()\\n atomNums = list(map(int, poscar[6].split()))\\n # combine atom names and numbers into a dict\\n atomNum_Dict = dict(zip(atomNames, atomNums))\\n # read in the coordinates of each species\\n atomCoor_Dict = dict.fromkeys(atomNum_Dict, [])\\n st_line = 8 # starting line number of atom coordinates\\n for i in atomCoor_Dict.keys():\\n end_line = st_line + atomNum_Dict[i]\\n coor = np.array([[float(e) for e in line.split()[0:3]] for line in poscar[st_line: end_line]])\\n st_line = end_line\\n atomCoor_Dict[i] = coor\\n fin.close()\\n\\n return latt_mat, latt_consts, angles, atomNum_Dict, atomCoor_Dict\",\n \"def p2orbit(p, primary, verbose=False):\\n o = Orbit()\\n if primary.m <= TINY:\\n if verbose is True:\\n print(\\\"Star has no mass.\\\")\\n return o # all values set to None\\n \\n dx = p.x - primary.x\\n dy = p.y - primary.y\\n dz = p.z - primary.z\\n o.r = math.sqrt ( dx*dx + dy*dy + dz*dz )\\n if o.r <= TINY:\\n if verbose is True:\\n print('Particle and primary positions are the same.')\\n return o\\n \\n dvx = p.vx - primary.vx\\n dvy = p.vy - primary.vy\\n dvz = p.vz - primary.vz\\n v = math.sqrt ( dvx*dvx + dvy*dvy + dvz*dvz )\\n \\n mu = G*(p.m+primary.m)\\n o.a = -mu/( v*v - 2.*mu/o.r ) # semi major axis\\n \\n h0 = (dy*dvz - dz*dvy) # angular momentum vector\\n h1 = (dz*dvx - dx*dvz)\\n h2 = (dx*dvy - dy*dvx)\\n o.h = math.sqrt ( h0*h0 + h1*h1 + h2*h2 ) # abs value of angular momentum\\n if o.h/o.r/v <= MIN_REL_ERROR:\\n if verbose is True:\\n print('Particle orbit is radial.')\\n return o\\n \\n vr = (dx*dvx + dy*dvy + dz*dvz)/o.r\\n e0 = 1./mu*( (v*v-mu/o.r)*dx - o.r*vr*dvx )\\n e1 = 1./mu*( (v*v-mu/o.r)*dy - o.r*vr*dvy )\\n e2 = 1./mu*( (v*v-mu/o.r)*dz - o.r*vr*dvz )\\n o.e = math.sqrt( e0*e0 + e1*e1 + e2*e2 ) # eccentricity\\n \\n o.P = math.copysign(2.*math.pi*math.sqrt( math.fabs(o.a*o.a*o.a/mu) ), o.a) # period\\n o.inc = math.acos( h2/o.h ) # inclination (wrt xy-plane)\\n # if pi/2<i<pi it's retrograde\\n n0 = -h1 # node vector\\n n1 = h0 # in xy plane => no z component\\n n = math.sqrt( n0*n0 + n1*n1 )\\n er = dx*e0 + dy*e1 + dz*e2\\n if n/o.r/v<=MIN_REL_ERROR or o.inc<=MIN_REL_ERROR:# we are in the xy plane\\n o.Omega=0.\\n if o.e <= MIN_REL_ERROR: # omega not defined for circular orbit\\n o.omega = 0.\\n else:\\n if e1>=0.:\\n o.omega=math.acos(e0/o.e)\\n else:\\n o.omega = 2.*math.pi-math.acos(e0/o.e)\\n else:\\n if o.e <= MIN_REL_ERROR:\\n o.omega = 0.\\n else:\\n if e2>=0.: # omega=0 if perictr at asc node\\n o.omega=math.acos(( n0*e0 + n1*e1 )/(n*o.e))\\n else:\\n o.omega=2.*math.pi-math.acos(( n0*e0 + n1*e1 )/(n*o.e))\\n if n1>=0.:\\n o.Omega = math.acos(n0/n)\\n else:\\n o.Omega=2.*math.pi-math.acos(n0/n)# Omega=longitude of asc node\\n # taken in xy plane from x axis\\n \\n if o.e<=MIN_REL_ERROR: # circular orbit\\n o.f=0. # f has no meaning\\n o.l=0.\\n else:\\n cosf = er/(o.e*o.r)\\n cosea = (1.-o.r/o.a)/o.e\\n \\n if -1.<=cosf and cosf<=1.: # failsafe\\n o.f = math.acos(cosf)\\n else:\\n o.f = math.pi/2.*(1.-cosf)\\n \\n if -1.<=cosea and cosea<=1.:\\n ea = math.acos(cosea)\\n else:\\n ea = math.pi/2.*(1.-cosea)\\n \\n if vr<0.:\\n o.f=2.*math.pi-o.f\\n ea =2.*math.pi-ea\\n \\n o.l = ea -o.e*math.sin(ea) + o.omega + o.Omega # mean longitude\\n \\n return o\",\n \"def to_init_position(self):\\n if self._pinit == None:\\n raise Exception('initial position for motor {} not known'.format(self._port))\\n self.change_position(self._pinit)\",\n \"def __init__(self, topology_proposal, direction=\\\"forward\\\"):\\n from simtk.openmm import app\\n\\n self._topology_proposal = topology_proposal\\n self._direction = direction\\n self._hydrogen = app.Element.getByAtomicNumber(1.0)\\n\\n # Set the direction\\n if direction == \\\"forward\\\":\\n self._destination_system = self._topology_proposal.new_system\\n self._new_atoms = self._topology_proposal.unique_new_atoms\\n self._destination_topology = self._topology_proposal.new_topology\\n self._atoms_with_positions = self._topology_proposal.new_to_old_atom_map.keys()\\n _nx_graph = self._topology_proposal._new_topology._get_networkx_molecule()\\n elif direction == \\\"reverse\\\":\\n self._destination_system = self._topology_proposal.old_system\\n self._new_atoms = self._topology_proposal.unique_old_atoms\\n self._destination_topology = self._topology_proposal.old_topology\\n self._atoms_with_positions = self._topology_proposal.old_to_new_atom_map.keys()\\n _nx_graph = self._topology_proposal._old_topology._get_networkx_molecule()\\n else:\\n raise ValueError(\\\"Direction must be either forward or reverse.\\\")\\n\\n self._new_atom_objects = list(self._destination_topology.atoms())\\n self._new_atoms_to_place = [atom for atom in self._destination_topology.atoms() if atom.index in self._new_atoms]\\n\\n self._atoms_with_positions_set = set(self._atoms_with_positions)\\n\\n self._hydrogens = []\\n self._heavy = []\\n\\n # Sort the new atoms into hydrogen and heavy atoms:\\n for atom in self._new_atoms_to_place:\\n if atom.element == self._hydrogen:\\n self._hydrogens.append(atom.index)\\n else:\\n self._heavy.append(atom.index)\\n\\n # Sanity check\\n if len(self._hydrogens)==0 and len(self._heavy)==0:\\n msg = 'NetworkXProposalOrder: No new atoms for direction {}\\\\n'.format(direction)\\n msg += str(topology_proposal)\\n raise Exception(msg)\\n\\n # Choose the first of the new atoms to find the corresponding residue:\\n #transforming_residue = self._new_atom_objects[self._new_atoms[0]].residue\\n\\n self._residue_graph = _nx_graph\\n self._reference_connectivity_graph = self._create_reference_connectivity_graph()\",\n \"def _set_init_pose(self):\\n cmd = np.zeros(16 * self.n)\\n self.move_joints(cmd)\",\n \"def alignMonoPlane(entry,prec=1E-4,seed_index=0,supercell=2,\\n c_mag=50,dist_from_plane=3):\\n\\n\\n # Keep original copy of structure\\n s = copy.deepcopy(entry[0])\\n\\n\\n new_latt,fit_fracs= getNewLattice(entry,dim=2,prec=prec,seed_index=seed_index,\\n supercell=supercell,c_mag=c_mag)\\n\\n\\n \\n\\n # Identify plane to translate atoms towards\\n\\n plane = Plane(Point3D(s.sites[seed_index].coords),\\n normal_vector=new_latt[2])\\n \\n # Create list of translationss\\n trans = list(itertools.product([1,-1,0],repeat=3))\\n\\n lat = np.array(s.lattice.as_dict()['matrix'])\\n final_sites = []\\n i=0\\n \\n # Ensure that the atoms are nearby each other\\n for site in [x.coords for x in s.sites]:\\n point = Point3D(site)\\n if 1==1:\\n\\n news = []\\n \\n # translate atomic sites to see which position is closest to plane\\n for t in trans:\\n point = Point3D(site+np.dot(np.transpose(lat),t))\\n news.append([float(plane.distance(point)),t])\\n news.sort(key = lambda x:x[0])\\n for new in news:\\n if not np.any([magni((site+np.dot(np.transpose(lat),new[1]))-x)<=prec for x in final_sites]):\\n final_sites.append(site+\\n np.dot(np.transpose(lat),new[1]))\\n break\\n i+=1\\n \\n # Create new lattice matricies\\n lat1 = np.array([new_latt[0],new_latt[1],new_latt[2]])\\n lat2 = np.array([new_latt[1],new_latt[0],new_latt[2]])\\n\\n # Generate atomic fractions\\n new_fracs1 = np.linalg.solve(lat1.T,np.array(final_sites).T).T\\n new_fracs2 = np.linalg.solve(lat2.T,np.array(final_sites).T).T\\n\\n species=fit_fracs[1]\\n\\n return([species,new_fracs1,lat1],[species,new_fracs2,lat2])\",\n \"def set_init_pose(self):\\n self.move_joints(self.init_cart_vel)\\n\\n return True\",\n \"def test_init_attr(self):\\n import itertools\\n\\n # K = 0\\n\\n s = space(curvature=0)\\n p = s.make_origin(0)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1]\\n ))))\\n p = s.make_origin(2)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1, 0, 0]\\n ))))\\n p = s.make_point((1, 0), 1)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1, 1, 0]\\n ))))\\n\\n # K = 1\\n\\n sn1_ref = 0.841470984807896506652502321630345\\n cn1_ref = 0.540302305868139717400936607442955\\n\\n s = space(curvature=1)\\n p = s.make_origin(0)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1]\\n ))))\\n p = s.make_origin(2)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1, 0, 0]\\n ))))\\n p = s.make_point((1, 0), 1)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [cn1_ref, sn1_ref, 0]\\n ))))\\n\\n # K = -1\\n\\n sh1_ref = 1.17520119364380145688238185059568\\n ch1_ref = 1.54308063481524377847790562075713\\n\\n s = space(curvature=-1)\\n p = s.make_origin(0)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1]\\n ))))\\n p = s.make_origin(2)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [1, 0, 0]\\n ))))\\n p = s.make_point((1, 0), 1)\\n self.assertTrue(all(itertools.starmap(isclose, zip(\\n p.x,\\n [ch1_ref, sh1_ref, 0]\\n ))))\",\n \"def simulate(\\n init_pos, init_en, model, pcas, desc_scalers, en_scaler, soap,\\n steps=100000, delta=0.04, T=100, dataset='zundel_100k'):\\n\\n hartree = 4.3597443419e-18\\n kb = 1.381e-23 / hartree\\n beta = 1 / (kb * T)\\n\\n n_atoms = data.get_n_atoms(dataset)\\n atoms = data.get_atoms_list(dataset)\\n symbols = data.get_symbols(dataset)\\n\\n acceptance = 0\\n cur_pos = np.copy(init_pos)\\n cur_en = init_en\\n\\n pos_history = np.empty((steps, n_atoms, 3))\\n en_history = np.empty(steps)\\n\\n for i in tqdm(range(steps)):\\n dr = np.random.random((n_atoms, 3)) * 2 * delta - delta\\n try_pos = np.copy(cur_pos) + dr\\n\\n molec = np.empty(1, dtype=object)\\n molec[0] = Atoms(symbols, positions=try_pos)\\n\\n desc = data.compute_desc(\\n molec, dataset=dataset, soap_params=soap\\n )\\n\\n desc = preprocessing.transform_set(\\n atoms=atoms, descriptors=desc, transformers=pcas\\n )\\n\\n desc = preprocessing.transform_set(\\n atoms=atoms, descriptors=desc, transformers=desc_scalers\\n )\\n\\n desc = preprocessing.convert_to_inputs(desc)\\n\\n try_en = model.predict(desc)\\n try_en = en_scaler.inverse_transform(try_en)[0, 0]\\n \\n if try_en < cur_en or exp(-beta * (try_en - cur_en)) >= random():\\n acceptance += 1\\n cur_pos, cur_en = try_pos, try_en\\n\\n pos_history[i] = cur_pos\\n en_history[i] = cur_en\\n\\n return pos_history, en_history, float(acceptance) / steps\",\n \"def standarization_ofPS(a2_data, num_dim, a2_tuple):\\n py_order = ['BURNUP', 'TEMPERATURE_COMBUSTIBLE',\\n 'CONCENTRATION_EN_BORE', 'DENSITE_MODERATEUR', 'PISCINE',\\n 'BURNUPstep', 'CONTROL_ROD', 'POWER_DENSITY', 'PHASE']\\n # interface is manege here to make functions as pure as possible\\n # a2_data['PS'] = efective_real_state_space(a2_data['PS'], num_dim)\\n temp = efective_real_state_space(a2_data, num_dim)\\n a2_data = OrderedDict()\\n a2_data['real'] = OrderedDict()\\n a2_data['real']['data'] = ordered_real_state_space(temp, py_order, a2_tuple)\\n a2_data['nmlz'] = OrderedDict()\\n a2_data['nmlz']['tau_gen'] = normalize_state_space(a2_data['real']['data'])\\n a2_data['nmlz']['N_tau'] = [len(vec) for vec in a2_data['nmlz']['tau_gen'].values()]\\n a2_data['nmlz']['N_prod'] = np.prod(a2_data['nmlz']['N_tau'])\\n a2_data['nmlz']['grid'] = to_pppack_style(a2_data['nmlz']['tau_gen'].values())\\n if len(a2_data['nmlz']['grid']) != a2_data['nmlz']['N_prod']:\\n raise RuntimeError('Generation of grid did not reproduce Cartesian construction %r != %r'\\n % (len(a2_data['nmlz']['grid']), a2_data['nmlz']['N_prod'])\\n )\\n a2_data['nmlz']['indx'] = OrderedDict()\\n a2_data['nmlz']['indx']['tau'] = [[idx for idx, _ in enumerate(vec)] for vec in a2_data[\\n 'nmlz']['tau_gen'].values()]\\n a2_data['nmlz']['indx']['grid'] = to_pppack_style(a2_data['nmlz']['indx']['tau'])\\n return a2_data\",\n \"def update_initial_pose(self, msg):\\n xy_theta = convert_pose_to_xy_and_theta(msg.pose.pose)\\n self.initialize_particle_cloud(xy_theta)\\n self.fix_map_to_odom_transform(msg)\",\n \"def _precession_matrix(oldequinox, newequinox):\\n return earth._precession_matrix_besselian(oldequinox.byear, newequinox.byear)\",\n \"def setup_layout_constants(self):\\n # determines the spacing between the edge and nmos (rail to active\\n # metal or poly_to_poly spacing)\\n half_gate_to_gate = 0.5 * (drc[\\\"poly_to_poly\\\"] - drc[\\\"minwidth_metal1\\\"])\\n edge_to_nmos = max(drc[\\\"metal1_to_metal1\\\"] - self.nmos.active_contact_positions[0].y,\\n half_gate_to_gate - self.nmos.poly_positions[0].y)\\n\\n # determine the position of the first transistor from the left\\n self.nmos_position1 = vector(0,\\n 0.5 * drc[\\\"minwidth_metal1\\\"] + edge_to_nmos)\\n offset = self.nmos_position1 + vector(0,self.nmos.height)\\n\\n x = vector(self.nmos.active_width - self.nmos.active_contact.width, 0)\\n self.nmos_position2 = x + self.nmos_position1.scale(0,1)\\n\\n # determines the spacing between the edge and pmos\\n edge_to_pmos = max(drc[\\\"metal1_to_metal1\\\"] - self.pmos.active_contact_positions[0].y,\\n half_gate_to_gate - self.pmos.poly_positions[0].y)\\n self.pmos_position1 = vector(0,\\n self.height - 0.5 * drc[\\\"minwidth_metal1\\\"]\\n - edge_to_pmos - self.pmos.height)\\n self.pmos_position2 = self.pmos_position1 + vector(self.pmos.width,0)\\n\\n self.well_width = max(self.pmos_position2.x + self.pmos.active_position.x\\n + self.pmos.active_width\\n + drc[\\\"active_to_body_active\\\"] + self.nwell_contact.width \\n + drc[\\\"well_enclosure_active\\\"],\\n self.nmos_position2.x + self.nmos.active_position.x \\n + self.nmos.active_width \\n + drc[\\\"active_to_body_active\\\"] + drc[\\\"well_enclosure_active\\\"])\\n self.width = self.well_width\",\n \"def align_resistors(self):\\n\\n if not self.been_solved:\\n self.solve()\\n for element in self.elements:\\n if is_resistor(element) and element.current < 0:\\n element.pos, element.neg = element.neg, element.pos\\n element.current = -1 * element.current\",\n \"def test_canonical_ordering_rdkit(self):\\n from openforcefield.utils.toolkits import RDKitToolkitWrapper\\n\\n rdkit = RDKitToolkitWrapper()\\n # get ethanol in canonical order\\n ethanol = create_ethanol()\\n # get reversed non canonical ethanol\\n reversed_ethanol = create_reversed_ethanol()\\n # get the canonical ordering\\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(rdkit)\\n # make sure the mapping between the ethanol and the rdkit ref canonical form is the same\\n assert (\\n True,\\n {0: 2, 1: 0, 2: 1, 3: 8, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7},\\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)\",\n \"def obInit(position, angle, center):\\n\\tif angle > 360.0:\\n\\t angle = angle - 360\\n\\tif angle < - 360:\\n\\t angle = -angle - 360\\n\\tif angle > -360 and angle < 0:\\n\\t angle = -angle\\n\\tadjPosition = position - center\\n\\tnewposition = adjPosition.rotate(angle) + center\\n\\treturn newposition\",\n \"def preferred_init_points(self):\\n if self._initial_state is None:\\n return None\\n else:\\n # If an initial state was set by the user, then we want to make sure that the VQE does\\n # not start from a random point. Thus, we return an all-zero initial point for the\\n # optimizer which is used (unless it gets overwritten by a higher-priority setting at\\n # runtime of the VQE).\\n # However, in order to determine the correct length, we must build the QuantumCircuit\\n # first, because otherwise the operators may not be set yet.\\n self._build()\\n return np.zeros(self.reps * len(self.operators), dtype=float)\",\n \"def test_left_canonize():\\n \\n for n in range(Nmin, Nmax+1):\\n random_state = new_random_state(d, n)\\n \\n rand_mps = []\\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\\n \\n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\\n rand_mps.append(np.random.rand(*shape)) \\n \\n MPS_leftcanonical = left_canonize(rand_mps)\\n \\n assert check_left_canonization(MPS_leftcanonical[:-1]), \\\"left_canonize error\\\"\",\n \"def fill_from_simbad (self, ident, debug=False):\\n import sys\\n info = get_simbad_astrometry_info (ident, debug=debug)\\n posref = 'unknown'\\n\\n for k, v in info.iteritems ():\\n if '~' in v:\\n continue # no info\\n\\n if k == 'COO(d;A)':\\n self.ra = float (v) * D2R\\n elif k == 'COO(d;D)':\\n self.dec = float (v) * D2R\\n elif k == 'COO(E)':\\n a = v.split ()\\n self.pos_u_maj = float (a[0]) * A2R * 1e-3 # mas -> rad\\n self.pos_u_min = float (a[1]) * A2R * 1e-3\\n self.pos_u_pa = float (a[2]) * D2R\\n elif k == 'COO(B)':\\n posref = v\\n elif k == 'PM(A)':\\n self.promo_ra = float (v) # mas/yr\\n elif k == 'PM(D)':\\n self.promo_dec = float (v) # mas/yr\\n elif k == 'PM(E)':\\n a = v.split ()\\n self.promo_u_maj = float (a[0]) # mas/yr\\n self.promo_u_min = float (a[1])\\n self.promo_u_pa = float (a[2]) * D2R # rad!\\n elif k == 'PLX(V)':\\n self.parallax = float (v) # mas\\n elif k == 'PLX(E)':\\n self.u_parallax = float (v) # mas\\n elif k == 'RV(V)':\\n self.vradial = float (v) # km/s\\n elif k == 'RV(E)':\\n self.u_vradial = float (v) #km/s\\n\\n if self.ra is None:\\n raise Exception ('no position returned by Simbad for \\\"%s\\\"' % ident)\\n if self.u_parallax == 0:\\n self.u_parallax = None\\n if self.u_vradial == 0:\\n self.u_vradial = None\\n\\n # Get the right epoch of position for 2MASS positions\\n\\n if posref == '2003yCat.2246....0C':\\n self.pos_epoch = get_2mass_epoch (self.ra, self.dec, debug)\\n\\n return self # eases chaining\",\n \"def test_canonical_ordering_rdkit(self):\\n from openff.toolkit.utils.toolkits import RDKitToolkitWrapper\\n\\n rdkit = RDKitToolkitWrapper()\\n # get ethanol in canonical order\\n ethanol = create_ethanol()\\n # get reversed non canonical ethanol\\n reversed_ethanol = create_reversed_ethanol()\\n # get the canonical ordering\\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(rdkit)\\n # make sure the mapping between the ethanol and the rdkit ref canonical form is the same\\n assert (\\n True,\\n {0: 2, 1: 0, 2: 1, 3: 8, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7},\\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)\",\n \"def _standardize_pose(self):\\n self.mesh_.center_vertices_bb()\\n vertex_array_cent = np.array(self.mesh_.vertices())\\n\\n # find principal axes\\n pca = sklearn.decomposition.PCA(n_components = 3)\\n pca.fit(vertex_array_cent)\\n\\n # count num vertices on side of origin wrt principal axes\\n comp_array = pca.components_\\n norm_proj = vertex_array_cent.dot(comp_array.T)\\n opposite_aligned = np.sum(norm_proj < 0, axis = 0)\\n same_aligned = np.sum(norm_proj >= 0, axis = 0)\\n pos_oriented = 1 * (same_aligned > opposite_aligned) # trick to turn logical to int\\n neg_oriented = 1 - pos_oriented\\n\\n # create rotation from principal axes to standard basis\\n target_array = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]]) # Z+, Y+, X+\\n target_array = target_array * pos_oriented + -1 * target_array * neg_oriented\\n R = np.linalg.solve(comp_array, target_array)\\n R = R.T\\n\\n # rotate vertices, normals and reassign to the mesh\\n vertex_array_rot = R.dot(vertex_array_cent.T)\\n vertex_array_rot = vertex_array_rot.T\\n self.mesh_.set_vertices(vertex_array_rot.tolist())\\n self.mesh_.center_vertices_bb()\\n\\n if self.mesh_.normals() is not None:\\n normals_array = np.array(self.mesh_.normals_)\\n normals_array_rot = R.dot(normals_array.T)\\n self.mesh_.set_normals(normals_array_rot.tolist())\",\n \"def reinit_pose(self, Xnew):\\n self.X = sym.Matrix([[Xnew[0]], [Xnew[1]], [Xnew[2]]])\",\n \"def test_diatomic_dummy_molecule_rotation_around_global_axis():\\n mol = Molecule()\\n mol.atoms = ['C'] * 2\\n mol.coordinates = np.array([[1, 0, 0], [0, 1, 0]])\\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi / 2, center=False)\\n assert np.allclose(mol.coordinates, [[0, 1, 0], [-1, 0, 0]])\\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi, center=False)\\n assert np.allclose(mol.coordinates, [[0, -1, 0], [1, 0, 0]])\",\n \"def set_radicals_correctly_from_xyz(self):\\n self.assertEqual(self.spc1.multiplicity, 1) # NH(S), a nitrene\\n self.assertTrue(all([atom.radical_electrons == 0 for atom in self.spc1.mol.atoms]))\\n self.assertEqual(self.spc2.multiplicity, 1) # NH(S), a nitrene\\n self.assertTrue(all([atom.radical_electrons == 0 for atom in self.spc2.mol.atoms]))\\n self.assertEqual(self.spc3.multiplicity, 1) # NCN(S), a singlet birad\\n self.assertTrue(all([atom.radical_electrons == 1 for atom in self.spc3.mol.atoms if atom.is_nitrogen()]))\\n self.assertEqual(self.spc3.multiplicity, 3) # NCN(T)\\n self.assertTrue(all([atom.radical_electrons == 1 for atom in self.spc3.mol.atoms if atom.is_nitrogen()]))\",\n \"def test_leading_order_convergence(self):\\n # Create models\\n leading_order_model = pybamm.lead_acid.LOQS()\\n composite_model = pybamm.lead_acid.Composite()\\n full_model = pybamm.lead_acid.Full()\\n\\n # Same parameters, same geometry\\n parameter_values = full_model.default_parameter_values\\n parameter_values[\\\"Current function [A]\\\"] = \\\"[input]\\\"\\n parameter_values.process_model(leading_order_model)\\n parameter_values.process_model(composite_model)\\n parameter_values.process_model(full_model)\\n geometry = full_model.default_geometry\\n parameter_values.process_geometry(geometry)\\n\\n # Discretise (same mesh, create different discretisations)\\n var = pybamm.standard_spatial_vars\\n var_pts = {var.x_n: 3, var.x_s: 3, var.x_p: 3}\\n mesh = pybamm.Mesh(geometry, full_model.default_submesh_types, var_pts)\\n\\n method_options = {\\\"extrapolation\\\": {\\\"order\\\": \\\"linear\\\", \\\"use bcs\\\": False}}\\n spatial_methods = {\\n \\\"macroscale\\\": pybamm.FiniteVolume(method_options),\\n \\\"current collector\\\": pybamm.ZeroDimensionalSpatialMethod(method_options),\\n }\\n loqs_disc = pybamm.Discretisation(mesh, spatial_methods)\\n loqs_disc.process_model(leading_order_model)\\n comp_disc = pybamm.Discretisation(mesh, spatial_methods)\\n comp_disc.process_model(composite_model)\\n full_disc = pybamm.Discretisation(mesh, spatial_methods)\\n full_disc.process_model(full_model)\\n\\n def get_max_error(current):\\n pybamm.logger.info(\\\"current = {}\\\".format(current))\\n # Solve, make sure times are the same and use tight tolerances\\n t_eval = np.linspace(0, 3600 * 17 / current)\\n solver = pybamm.CasadiSolver()\\n solver.rtol = 1e-8\\n solver.atol = 1e-8\\n solution_loqs = solver.solve(\\n leading_order_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n solution_comp = solver.solve(\\n composite_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n solution_full = solver.solve(\\n full_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n\\n # Post-process variables\\n voltage_loqs = solution_loqs[\\\"Terminal voltage\\\"]\\n voltage_comp = solution_comp[\\\"Terminal voltage\\\"]\\n voltage_full = solution_full[\\\"Terminal voltage\\\"]\\n\\n # Compare\\n t_loqs = solution_loqs.t\\n t_comp = solution_comp.t\\n t_full = solution_full.t\\n t = t_full[: np.min([len(t_loqs), len(t_comp), len(t_full)])]\\n loqs_error = np.max(np.abs(voltage_loqs(t) - voltage_full(t)))\\n comp_error = np.max(np.abs(voltage_comp(t) - voltage_full(t)))\\n return (loqs_error, comp_error)\\n\\n # Get errors\\n currents = 0.5 / (2 ** np.arange(3))\\n errs = np.array([get_max_error(current) for current in currents])\\n loqs_errs, comp_errs = [np.array(err) for err in zip(*errs)]\\n # Get rates: expect linear convergence for loqs, quadratic for composite\\n loqs_rates = np.log2(loqs_errs[:-1] / loqs_errs[1:])\\n\\n np.testing.assert_array_less(0.99 * np.ones_like(loqs_rates), loqs_rates)\\n # Composite not converging as expected\\n comp_rates = np.log2(comp_errs[:-1] / comp_errs[1:])\\n np.testing.assert_array_less(0.99 * np.ones_like(comp_rates), comp_rates)\\n # Check composite more accurate than loqs\\n np.testing.assert_array_less(comp_errs, loqs_errs)\",\n \"def test_canonical_ordering_openeye(self):\\n from openforcefield.utils.toolkits import OpenEyeToolkitWrapper\\n\\n openeye = OpenEyeToolkitWrapper()\\n # get ethanol in canonical order\\n ethanol = create_ethanol()\\n # get reversed non canonical ethanol\\n reversed_ethanol = create_reversed_ethanol()\\n # get the canonical ordering\\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(openeye)\\n # make sure the mapping between the ethanol and the openeye ref canonical form is the same\\n assert (\\n True,\\n {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8},\\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)\",\n \"def propagator_testprep():\\n import mdtraj as md\\n from coddiwomple.particles import Particle\\n from coddiwomple.openmm.states import OpenMMParticleState\\n from qmlify.utils import generate_propagator_inputs\\n\\n vac_sys_pos_top, sol_sys_pos_top = generate_testsystem()\\n vac_system, vac_positions, vac_topology = vac_sys_pos_top\\n sol_system, sol_positions, sol_topology = sol_sys_pos_top\\n\\n md_topology = md.Topology.from_openmm(sol_topology)\\n md_subset_topology = md.Topology.from_openmm(vac_topology)\\n pdf_state, pdf_state_subset, integrator, ani_handler, atom_map = generate_propagator_inputs(system = sol_system,\\n system_subset = vac_system,\\n md_topology = md_topology,\\n md_subset_topology = md_subset_topology)\\n particle = Particle(0)\\n box_vectors = sol_system.getDefaultPeriodicBoxVectors()\\n particle_state = OpenMMParticleState(positions = sol_positions, box_vectors = box_vectors)\\n particle.update_state(particle_state)\\n\\n return pdf_state, pdf_state_subset, integrator, ani_handler, atom_map, particle\",\n \"def propositional_skeleton(self):\\n # Task 9.5\\n return Formula.skel_helper(self, {}) # use skel_helper with an empty dict to solve\",\n \"def update_initial_pose(self, msg):\\n xy_theta = \\\\\\n self.tf_helper.convert_pose_to_xy_and_theta(msg.pose.pose)\\n\\n self.tf_helper.fix_map_to_odom_transform(msg.pose.pose,\\n msg.header.stamp)\\n self.tf_helper.send_last_map_to_odom_transform()\\n # initialize your particle filter based on the xy_theta tuple\",\n \"def test_canonical_ordering_openeye(self):\\n from openff.toolkit.utils.toolkits import OpenEyeToolkitWrapper\\n\\n openeye = OpenEyeToolkitWrapper()\\n # get ethanol in canonical order\\n ethanol = create_ethanol()\\n # get reversed non canonical ethanol\\n reversed_ethanol = create_reversed_ethanol()\\n # get the canonical ordering\\n canonical_ethanol = reversed_ethanol.canonical_order_atoms(openeye)\\n # make sure the mapping between the ethanol and the openeye ref canonical form is the same\\n assert (\\n True,\\n {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8},\\n ) == Molecule.are_isomorphic(canonical_ethanol, ethanol, True)\",\n \"def move_three_atoms(poscar,iat,icoord,ih,jat,jcoord,jh,kat,kcoord,kh):\\n nruter=copy.deepcopy(poscar)\\n disp=np.zeros(3)\\n disp[icoord]=ih\\n nruter[\\\"positions\\\"][:,iat]+=scipy.linalg.solve(nruter[\\\"lattvec\\\"],\\n disp)\\n disp[:]=0.\\n disp[jcoord]=jh\\n nruter[\\\"positions\\\"][:,jat]+=scipy.linalg.solve(nruter[\\\"lattvec\\\"],\\n disp)\\n disp[:]=0.\\n disp[kcoord]=kh\\n nruter[\\\"positions\\\"][:,kat]+=scipy.linalg.solve(nruter[\\\"lattvec\\\"],\\n disp)\\n return nruter\",\n \"def supress_atomPosition_singulrarities(self) -> None:\\n\\n if (\\\"POSITION\\\" in dir(self)):\\n for ind, atom in enumerate(self.POSITION.content):\\n atom.xp = atom.xp + 10 ** (-7) * ind\\n atom.yp = atom.yp - 10 ** (-7) * ind\\n atom.zp = atom.zp - 10 ** (-7) * ind\",\n \"def assert_stored_sp_rel_pos(self):\\n# ## Temporal\\n# if self.sp_relative_pos is not None:\\n# if self._constant_neighs:\\n# if self.staticneighs:\\n# assert(len(np.array(self.sp_relative_pos).shape) == 3)\\n# else:\\n# assert(len(np.array(self.sp_relative_pos).shape) == 4)\\n# #################\\n array_types = [list, np.ndarray]\\n if self.sp_relative_pos is not None:\\n assert(type(self.sp_relative_pos) in [list, np.ndarray])\\n# if type(self.sp_relative_pos) in [float, int, np.int32, np.int64]:\\n# ### Probably redundant\\n# # it is needed or possible this situation?\\n# pass\\n assert(type(self.sp_relative_pos) in [list, np.ndarray])\\n# if self.ks is None:\\n# assert(self.staticneighs)\\n# assert(len(self.sp_relative_pos) == len(self.iss))\\n if self.staticneighs:\\n assert(len(self.sp_relative_pos) == len(self.iss))\\n ## Assert deep 3\\n if len(self.iss):\\n assert(type(self.sp_relative_pos[0]) in array_types)\\n else:\\n assert(self.ks is not None)\\n assert(len(self.sp_relative_pos) == len(self.ks))\\n if type(self.sp_relative_pos[0]) in array_types:\\n if not self.staticneighs:\\n assert(len(self.sp_relative_pos[0]) == len(self.iss))\\n if len(self.sp_relative_pos[0]) > 0:\\n assert(type(self.sp_relative_pos[0][0]) in array_types)\",\n \"def test_zero_modes(self):\\n # make random numbers reproducible\\n torch.manual_seed(0)\\n \\n n = 5\\n # draw random numbers for positive definite, symmetric n x n matrix of width parameters\\n Gi = 5.0 * 2.0*(torch.rand(n,n) - 0.5)\\n # symmetrize\\n Gi = 0.5*(Gi + Gi.T)\\n # random numbers for position and momentum\\n qi,pi = torch.rand(n,1), torch.rand(n,1)\\n qj,pj = qi,pi #torch.rand(n,1), torch.rand(n,1)\\n # check <qi,pi,Gi|qi,pi,Gi> = 1 \\n cso = CoherentStatesOverlap(Gi,Gi)\\n olap = cso(qi,pi, qj,pj)\\n\\n # turn Gi into a singular matrix by embedding it into a larger space\\n Gi_ = torch.zeros((n+1,n+1))\\n Gi_[:n,:n] = Gi\\n qi_, pi_, qj_, pj_ = (torch.cat((x, torch.zeros(1,1)), 0) for x in (qi,pi,qj,pj))\\n # The zero dimension should have no effect on the overlaps\\n cso_ = CoherentStatesOverlap(Gi_,Gi_)\\n olap_ = cso_(qi_,pi_, qj_,pj_)\\n\\n self.assertEqual(olap.squeeze().item(), olap_.squeeze().item())\",\n \"def InitPositions(N, L):\\n #make the position array\\n Pos = np.zeros((N,3), float)\\n #compute integer grid # of locations for cubic lattice\\n NLat = int(N**(1./3.) + 1.)\\n LatSpac = float(L) / float(NLat)\\n #make an array of lattice sites\\n r = LatSpac * np.arange(NLat, dtype=float) - 0.5*L\\n #loop through x, y, z positions in lattice until done\\n #for every atom in the system\\n i = 0\\n for x in r:\\n for y in r:\\n for z in r:\\n Pos[i] = np.array([x,y,z], float)\\n #add a random offset to help initial minimization\\n Offset = 0.1 * LatSpac * (np.random.rand(3) - 0.5)\\n Pos[i] = Pos[i] + Offset\\n i += 1\\n #if done placing atoms, return\\n if i >= N:\\n return Pos\\n return Pos\",\n \"def init_morphed(self, init_from: dict):\\n for k1 in self.m_ops.keys():\\n f = init_from.get(k1, -1) # where the op is originating from\\n if f not in self.m_ops:\\n continue\\n self.m_ops[k1][0].init_from(self.m_ops[f][0])\",\n \"def model_prem_iso(r):\\n\\n\\t#- normalised radius\\n\\tx = r / 6371000.0\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\t#- upper crust\\n\\tif (r >= 6356000.0):\\n\\t\\trho = 2.6\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- lower crust\\n\\telif (r >= 6346000.6) & (r < 6356000.0):\\n\\t\\trho = 2.9\\n\\t\\tvpv = 6.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.9\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- LID\\n\\telif (r >= 6291000.0) & (r < 6346000.6):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 4.1875 + 3.9382 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.1519 + 2.3481 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- LVZ\\n\\telif (r >= 6151000.0) & (r < 6291000.0):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 4.1875 + 3.9382 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 2.1519 + 2.3481 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- Transition zone 1\\n\\telif (r >= 5971000.0) & (r < 6151000.0):\\n\\t\\trho = 7.1089 - 3.8045 * x\\n\\t\\tvpv = 20.3926 - 12.2569 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 8.9496 - 4.4597 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 2\\n\\telif (r >= 5771000.0) & (r < 5971000.0):\\n\\t\\trho = 11.2494 - 8.0298 * x\\n\\t\\tvpv = 39.7027 - 32.6166 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3512 - 18.5856 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 3\\n\\telif (r >= 5701000.0) & (r < 5771000.0):\\n\\t\\trho = 5.3197 - 1.4836 * x\\n\\t\\tvpv = 19.0957 - 9.8672 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 9.9839 - 4.9324 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 1\\n\\telif (r >= 5600000.0) & (r < 5701000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- Lower mantle 2\\n\\telif (r >= 3630000.0) & (r < 5600000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 3\\n\\telif (r >= 3480000.0) & (r < 3630000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Outer core\\n\\telif (r >= 1221000.5) & (r < 3480000.0):\\n\\t\\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\\n\\t\\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 0.0\\n\\t\\tvsh = 0.0\\n\\t\\teta = 1.0\\n\\n\\t#- Inner Core\\n\\telif (r >= 0.0) & (r < 1221000.5):\\n\\t\\trho = 13.0885 - 8.8381 * x**2\\n\\t\\tvpv = 11.2622 - 6.3640 * x**2\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.6678 - 4.4475 * x**2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def assign_electrons(molecule, electrons):\\n # Assign electrons based upon unperturbed atoms and ignore impact of\\n # fractional nuclear charge.\\n nuclei = [int(round(atom.charge)) for atom in molecule]\\n total_charge = sum(nuclei) - sum(electrons)\\n # Construct a dummy iso-electronic neutral system.\\n neutral_molecule = [copy.copy(atom) for atom in molecule]\\n if total_charge != 0:\\n logging.warning(\\n 'Charged system. Using heuristics to set initial electron positions')\\n charge = 1 if total_charge > 0 else -1\\n while total_charge != 0:\\n # Poor proxy for electronegativity.\\n atom_index = nuclei.index(max(nuclei) if total_charge < 0 else min(nuclei))\\n atom = neutral_molecule[atom_index]\\n atom.charge -= charge\\n atom.atomic_number = int(round(atom.charge))\\n if int(round(atom.charge)) == 0:\\n neutral_molecule.pop(atom_index)\\n else:\\n atom.symbol = elements.ATOMIC_NUMS[atom.atomic_number].symbol\\n total_charge -= charge\\n nuclei = [int(round(atom.charge)) for atom in neutral_molecule]\\n\\n spin_pol = lambda electrons: electrons[0] - electrons[1]\\n abs_spin_pol = abs(spin_pol(electrons))\\n if len(neutral_molecule) == 1:\\n elecs_atom = [electrons]\\n else:\\n elecs_atom = []\\n spin_pol_assigned = 0\\n for ion in neutral_molecule:\\n # Greedily assign up and down electrons based upon the ground state spin\\n # configuration of an isolated atom.\\n atom_spin_pol = elements.ATOMIC_NUMS[ion.atomic_number].spin_config\\n nelec = ion.atomic_number\\n na = (nelec + atom_spin_pol) // 2\\n nb = nelec - na\\n # Attempt to keep spin polarisation as close to 0 as possible.\\n if (spin_pol_assigned > 0 and\\n spin_pol_assigned + atom_spin_pol > abs_spin_pol):\\n elec_atom = [nb, na]\\n else:\\n elec_atom = [na, nb]\\n spin_pol_assigned += spin_pol(elec_atom)\\n elecs_atom.append(elec_atom)\\n\\n electrons_assigned = [sum(e) for e in zip(*elecs_atom)]\\n spin_pol_assigned = spin_pol(electrons_assigned)\\n if np.sign(spin_pol_assigned) == -np.sign(abs_spin_pol):\\n # Started with the wrong guess for spin-up vs spin-down.\\n elecs_atom = [e[::-1] for e in elecs_atom]\\n spin_pol_assigned = -spin_pol_assigned\\n\\n if spin_pol_assigned != abs_spin_pol:\\n logging.info('Spin polarisation does not match isolated atoms. '\\n 'Using heuristics to set initial electron positions.')\\n while spin_pol_assigned != abs_spin_pol:\\n atom_spin_pols = [abs(spin_pol(e)) for e in elecs_atom]\\n atom_index = atom_spin_pols.index(max(atom_spin_pols))\\n elec_atom = elecs_atom[atom_index]\\n if spin_pol_assigned < abs_spin_pol and elec_atom[0] <= elec_atom[1]:\\n elec_atom[0] += 1\\n elec_atom[1] -= 1\\n spin_pol_assigned += 2\\n elif spin_pol_assigned < abs_spin_pol and elec_atom[0] > elec_atom[1]:\\n elec_atom[0] -= 1\\n elec_atom[1] += 1\\n spin_pol_assigned += 2\\n elif spin_pol_assigned > abs_spin_pol and elec_atom[0] > elec_atom[1]:\\n elec_atom[0] -= 1\\n elec_atom[1] += 1\\n spin_pol_assigned -= 2\\n else:\\n elec_atom[0] += 1\\n elec_atom[1] -= 1\\n spin_pol_assigned -= 2\\n\\n electrons_assigned = [sum(e) for e in zip(*elecs_atom)]\\n if spin_pol(electrons_assigned) == -spin_pol(electrons):\\n elecs_atom = [e[::-1] for e in elecs_atom]\\n electrons_assigned = electrons_assigned[::-1]\\n\\n logging.info(\\n 'Electrons assigned %s.', ', '.join([\\n '{}: {}'.format(atom.symbol, elec_atom)\\n for atom, elec_atom in zip(molecule, elecs_atom)\\n ]))\\n if any(e != e_assign for e, e_assign in zip(electrons, electrons_assigned)):\\n raise RuntimeError(\\n 'Assigned incorrect number of electrons ([%s instead of %s]' %\\n (electrons_assigned, electrons))\\n if any(min(ne) < 0 for ne in zip(*elecs_atom)):\\n raise RuntimeError('Assigned negative number of electrons!')\\n electron_positions = np.concatenate([\\n np.tile(atom.coords, e[0])\\n for atom, e in zip(neutral_molecule, elecs_atom)\\n ] + [\\n np.tile(atom.coords, e[1])\\n for atom, e in zip(neutral_molecule, elecs_atom)\\n ])\\n return electron_positions\",\n \"def init_joints_pose(self, init_pos):\\n self.current_joint_pose =[]\\n self.current_joint_pose = copy.deepcopy(init_pos)\\n#\\tprint(\\\"[current_joint_pose]:\\\", self.current_joint_pose, type(self.current_joint_pose))\\n return self.current_joint_pose\",\n \"def test_library_charges_to_three_ethanols_different_atom_ordering(self):\\n # Define a library charge parameter for ethanol (C1-C2-O3) where C1 has charge -0.2, and its Hs have -0.02,\\n # C2 has charge -0.1 and its Hs have -0.01, and O3 has charge 0.3, and its H has charge 0.08\\n\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_ff,\\n )\\n\\n # ethanol.sdf\\n # H5 H8\\n # | |\\n # H6 - C1 - C2 - O3 - H4\\n # | |\\n # H7 H9\\n #\\n # ethanol_reordered.sdf (The middle C and O switch indices)\\n # H5 H8\\n # | |\\n # H6 - C1 - C3 - O2 - H4\\n # | |\\n # H7 H9\\n #\\n # create_reversed_ethanol()\\n # H5 H2\\n # | |\\n # H4 - C8 - C7 - O6 - H0\\n # | |\\n # H3 H1\\n\\n molecules = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\")),\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\")),\\n create_reversed_ethanol(),\\n ]\\n top = Topology.from_molecules(molecules)\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n expected_charges = [\\n -0.2,\\n -0.1,\\n 0.3,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n -0.2,\\n 0.3,\\n -0.1,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n 0.08,\\n -0.01,\\n -0.01,\\n -0.02,\\n -0.02,\\n -0.02,\\n 0.3,\\n -0.1,\\n -0.2,\\n ] * openmm_unit.elementary_charge\\n for particle_index, expected_charge in enumerate(expected_charges):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q == expected_charge\",\n \"def _reset_internal(self):\\n super()._reset_internal()\\n\\n # Reset all object positions using initializer sampler if we're not directly loading from an xml\\n if not self.deterministic_reset:\\n\\n # Sample from the placement initializer for all objects\\n obj_pos, obj_quat = self.placement_initializer.sample()\\n\\n # Loop through all objects and reset their positions\\n for i, (obj_name, _) in enumerate(self.mujoco_objects.items()):\\n self.sim.data.set_joint_qpos(obj_name, np.concatenate([np.array(obj_pos[i]), np.array(obj_quat[i])]))\",\n \"def generate_pure_initial_state(state0, dimensions, states):\\n\\n cluster_state = 1\\n\\n for i, s in enumerate(states):\\n d = dimensions[i]\\n n = int(round((d - 1) / 2 - s))\\n\\n state = np.zeros(d)\\n state[n] = 1\\n cluster_state = np.kron(cluster_state, state)\\n\\n with_central_spin = np.kron(cluster_state, state0)\\n\\n return with_central_spin\",\n \"def reset_position(self):\\n self.translate_to_point_O()\\n\\n # inverse rotation:\\n rotation_matrix = np.stack(\\n (self.pcs.i_hat, self.pcs.j_hat, self.pcs.k_hat), axis=0\\n )\\n\\n self.rotate(rotation_matrix)\",\n \"def solvate(self):\\n\\n pass\",\n \"def _get_quad_initial_pos(self, msg):\\n \\n self._quad_initial_pos, dummy = self._odometry_to_pos_vel(msg)\\n self._sub.unregister()\\n self._got_quad_initial_pos_flag = True\",\n \"def add_initial_side_chains_from_propensities(\\n self, G, raw_or_rank, test=False, input_num={}\\n ):\\n\\n # Initialises dictionary of starting sequences\\n initial_networks = OrderedDict()\\n ids_list = []\\n for num in range(2*self.pop_size):\\n unique_id = ''.join(\\n [random.choice(string.ascii_letters + string.digits)\\n for i in range(10)]\\n )\\n initial_networks[unique_id] = copy.deepcopy(G)\\n ids_list.append(unique_id)\\n\\n # Extracts individual amino acid propensity scales for the surface\\n intext_index = self.dict_name_indices['intorext']\\n eoc_index = self.dict_name_indices['edgeorcent']\\n prop_index = self.dict_name_indices['prop1']\\n pairindv_index = self.dict_name_indices['pairorindv']\\n discorcont_index = self.dict_name_indices['discorcont']\\n proporfreq_index = self.dict_name_indices['proporfreq']\\n dicts = OrderedDict({\\n dict_label: scale_dict for dict_label, scale_dict in\\n {**self.propensity_dicts, **self.frequency_dicts}.items()\\n if dict_label.split('_')[pairindv_index] == 'indv'\\n })\\n\\n for node_index, node in enumerate(list(G.nodes())):\\n if G.nodes()[node]['type'] == 'loop':\\n continue\\n\\n int_ext = G.nodes()[node]['int_ext']\\n sub_dicts = OrderedDict(\\n {dict_label: scale_dict for dict_label, scale_dict in dicts.items()\\n if dict_label.split('_')[intext_index] in [int_ext, '-']}\\n )\\n if self.barrel_or_sandwich == '2.60':\\n # Filters propensity and frequency scales depending upon\\n # whether the node is in an edge or a central strand\\n eoc = G.nodes()[node]['eoc']\\n sub_dicts = OrderedDict(\\n {dict_label: scale_dict for dict_label, scale_dict in sub_dicts.items()\\n if dict_label.split('_')[eoc_index] in [eoc, '-']}\\n )\\n\\n if sub_dicts == {}:\\n if test is True: # Avoids code crashing if e.g. there are no\\n # dicts for ext residues\\n continue\\n else:\\n raise ValueError('No propensity or scoring metrics '\\n 'available for node {}'.format(node))\\n\\n # Calculates summed propensity for each amino acid across all\\n # structural features considered in the design process\\n node_indv_propensities = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\\n node_indv_frequencies = np.full((len(sub_dicts), len(self.aa_list)), np.nan)\\n\\n for dict_index, dict_label in enumerate(list(sub_dicts.keys())):\\n scale_dict = sub_dicts[dict_label]\\n dict_weight = self.dict_weights[dict_label]\\n node_prop = dict_label.split('_')[prop_index]\\n node_val = np.nan\\n\\n if node_prop != '-':\\n try:\\n node_val = G.nodes()[node][node_prop]\\n except KeyError:\\n raise KeyError('{} not defined for node {}'.format(node_prop, node))\\n # Converts non-float values into np.nan\\n if node_val in ['', 'nan', 'NaN', np.nan]:\\n node_val = np.nan\\n\\n value = np.nan\\n if dict_label.split('_')[discorcont_index] == 'cont' and not np.isnan(node_val):\\n if dict_label.split('_')[proporfreq_index] != 'propensity':\\n raise Exception(\\n 'Unexpected dictionary {} - expect only continuous '\\n 'propensity dictionaries'.format(dict_label)\\n )\\n\\n # Interpolate dictionary\\n for aa, aa_scale in scale_dict.items():\\n aa_index = self.aa_list.index(aa)\\n value = linear_interpolation(node_val, aa_scale, dict_label)\\n\\n if value <= 0:\\n raise ValueError(\\n '{} returned after interpolation of {} for node'\\n ' {}'.format(value, dict_label, node)\\n )\\n\\n if np.isnan(value):\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n value = 0.0001 # Since dataset used to generate\\n # prop and freq dicts is ~10,000 aas => smallest\\n # propensity could be is ((1/5000)/(5001/10000)\\n # = 0.0004 (for a discrete propensity))\\n\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n node_indv_propensities[dict_index][aa_index] = (\\n dict_weight*np.negative(np.log(value))\\n )\\n\\n elif dict_label.split('_')[discorcont_index] == 'disc':\\n # Filter dataframe\\n scale_dict_copy = copy.deepcopy(scale_dict).set_index('FASTA', drop=True)\\n for aa_index, aa in enumerate(self.aa_list):\\n if node_prop == '-':\\n try:\\n value = scale_dict_copy.iloc[:,0][aa]\\n except KeyError:\\n raise Exception('{} not defined in {}'.format(aa, dict_label))\\n elif node_prop == 'phipsi':\\n if not np.isnan(node_val):\\n try:\\n value = scale_dict_copy[node_val][aa]\\n except KeyError:\\n raise Exception('{},{} not defined in {}'.format(\\n node_val, aa, dict_label\\n ))\\n\\n if value <= 0:\\n raise ValueError(\\n '{} returned after interpolation of {} for node'\\n ' {}'.format(value, dict_label, node)\\n )\\n\\n if np.isnan(value):\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n value = 0.0001 # Since dataset used to generate\\n # prop and freq dicts is ~10,000 aas => smallest\\n # propensity could be is ((1/5000)/(5001/10000)\\n # = 0.0004 (for a discrete propensity))\\n else:\\n value = 0\\n\\n if dict_label.split('_')[proporfreq_index] == 'propensity':\\n node_indv_propensities[dict_index][aa_index] = (\\n dict_weight*np.negative(np.log(value))\\n )\\n elif dict_label.split('_')[proporfreq_index] == 'frequency':\\n node_indv_frequencies[dict_index][aa_index] = dict_weight*value\\n\\n # Sums propensity and frequency values, then filters to remove amino\\n # acids with a propensity / frequency of 0\\n node_indv_propensities = np.nansum(node_indv_propensities, axis=0)\\n node_indv_frequencies = np.nansum(node_indv_frequencies, axis=0)\\n\\n if (\\n set(node_indv_propensities) == {0}\\n or (self.frequency_dicts != {} and set(node_indv_frequencies) == {0})\\n ):\\n raise Exception('Cannot select side chain identity for node '\\n '{}'.format(node))\\n\\n # Removes aas for which all propensity and/or frequency readings (as\\n # appropriate) are np.nan\\n filt_aa_list = []\\n filt_node_prop = []\\n filt_node_freq = []\\n for aa_index, aa in enumerate(self.aa_list):\\n prop = node_indv_propensities[aa_index]\\n freq = node_indv_frequencies[aa_index]\\n if (\\n (self.frequency_dicts == {} and prop == 0)\\n or (self.frequency_dicts != {} and prop == 0 and freq == 0)\\n ):\\n continue\\n filt_aa_list.append(aa)\\n filt_node_prop.append(prop)\\n filt_node_freq.append(freq)\\n filt_aa_list = np.array(filt_aa_list)\\n filt_node_prop = np.array(filt_node_prop)\\n filt_node_freq = np.array(filt_node_freq)\\n\\n # Converts propensities and frequencies into probability\\n # distributions\\n (node_prop_index, node_prop, node_prop_probabilities\\n ) = calc_probability_distribution(\\n node_indv_propensities, 'propensity', raw_or_rank, test\\n )\\n node_prop_index = node_prop_index.astype(int)\\n if self.frequency_dicts != {}:\\n (node_freq_index, node_freq, node_freq_probabilities\\n ) = calc_probability_distribution(\\n filt_node_freq, 'frequency', raw_or_rank, test\\n )\\n else:\\n node_freq_index = copy.deepcopy(node_prop_index)\\n node_freq = np.full(filt_node_freq.shape, 0)\\n node_freq_probabilities = np.full(filt_node_freq.shape, 0)\\n node_freq_index = node_freq_index.astype(int)\\n\\n node_probabilities = np.full(node_prop_probabilities.shape, np.nan)\\n for index_prop, aa in np.ndenumerate(copy.deepcopy(node_prop_index)):\\n index_freq = np.where(node_freq_index == aa)[0][0]\\n propensity = node_prop_probabilities[index_prop]\\n frequency = node_freq_probabilities[index_freq]\\n\\n # Since propensity_weight is a hyperparameter to be optimised\\n # with hyperopt, for initial sequence generation the propensity\\n # and frequency scales are weighted equally (unless not\\n # performing hyperparameter optimisation, in which case use the\\n # propensity_weight specified in the input file)\\n try:\\n prop_weight = self.propensity_weight\\n freq_weight = 1 - self.propensity_weight\\n except AttributeError:\\n prop_weight = 0.5\\n freq_weight = 0.5\\n probability = (prop_weight*propensity) + (freq_weight*frequency)\\n node_probabilities[index_prop] = probability\\n filt_aa_list = filt_aa_list[node_prop_index]\\n node_cumulative_probabilities = gen_cumulative_probabilities(\\n node_probabilities, node\\n )\\n\\n # Selects amino acid weighted by its probability\\n for unique_id in ids_list:\\n if test is False:\\n random_number = random.uniform(0, 1)\\n elif test is True:\\n random_number = input_num[node]\\n nearest_index = (np.abs(node_cumulative_probabilities-random_number)).argmin()\\n\\n if node_cumulative_probabilities[nearest_index] >= random_number:\\n selected_aa = filt_aa_list[nearest_index]\\n else:\\n selected_aa = filt_aa_list[nearest_index+1]\\n\\n nx.set_node_attributes(\\n initial_networks[unique_id],\\n values={'{}'.format(node): {'aa_id': '{}'.format(selected_aa)}}\\n )\\n\\n return initial_networks\",\n \"def update_initial_pose(self, msg):\\n xy_theta = \\\\\\n self.transform_helper.convert_pose_to_xy_and_theta(msg.pose.pose)\\n\\n # TODO this should be deleted before posting\\n self.transform_helper.fix_map_to_odom_transform(msg.pose.pose,\\n msg.header.stamp)\\n # initialize your particle filter based on the xy_theta tuple\",\n \"def setup_nonlinear_model_p(M, C, K, sx='x,y,th', \\n rho=1.225, chord=0.2, polarFilename='tjaere11_ds.csv', drag=False, # Aero options\\n y_AQ=0, y_AT=None, x_AQ=0, x_AT=0,\\n ds='oye', tau=0.08, # tau: used for Oye, but should be taken from Polar!\\n di=None):\\n # \\n p = defaultParams(chord=chord, rho=rho, sx=sx, ds=ds, di=di,\\n M=M, C=C, K=K)\\n\\n # --- Aerodynamic parameters\\n if y_AQ>0: \\n print('[WARN] y_AQ positive is unconventional')\\n p['y_AQ'] = y_AQ\\n if y_AT is None:\\n p['y_AT'] = y_AQ+chord/2 # default is approximatively half a chord behind\\n else:\\n p['y_AT'] = y_AT\\n p['x_AQ'] = x_AQ\\n p['x_AT'] = x_AT\\n\\n # Read polar\\n pol = Polar(polarFilename, fformat=None, radians=True, compute_params=True) # compute_params for DS\\n ppol = polarParams(pol, chord=p['chord'], tau=tau)\\n p.update(ppol)\\n\\n# # --- Dictionary\\n# p.update({'linModel':False, 'drag':drag})\\n return p\",\n \"def gen_SPOSCAR(poscar,na,nb,nc):\\n nruter=dict()\\n nruter[\\\"na\\\"]=na\\n nruter[\\\"nb\\\"]=nb\\n nruter[\\\"nc\\\"]=nc\\n nruter[\\\"lattvec\\\"]=np.array(poscar[\\\"lattvec\\\"])\\n nruter[\\\"lattvec\\\"][:,0]*=na\\n nruter[\\\"lattvec\\\"][:,1]*=nb\\n nruter[\\\"lattvec\\\"][:,2]*=nc\\n nruter[\\\"elements\\\"]=copy.copy(poscar[\\\"elements\\\"])\\n nruter[\\\"numbers\\\"]=na*nb*nc*poscar[\\\"numbers\\\"]\\n nruter[\\\"positions\\\"]=np.empty((3,poscar[\\\"positions\\\"].shape[1]*na*nb*nc))\\n pos=0\\n for pos,(k,j,i,iat) in enumerate(itertools.product(xrange(nc),\\n xrange(nb),\\n xrange(na),\\n xrange(\\n poscar[\\\"positions\\\"].shape[1]))):\\n nruter[\\\"positions\\\"][:,pos]=(poscar[\\\"positions\\\"][:,iat]+[i,j,k])/[\\n na,nb,nc]\\n nruter[\\\"types\\\"]=[]\\n for i in xrange(na*nb*nc):\\n nruter[\\\"types\\\"].extend(poscar[\\\"types\\\"])\\n return nruter\",\n \"def swapProchiralResonance(resonance, makeAmbiguous=False):\\n \\n from ccpnmr.analysis.core.MoleculeBasic import areAtomsBound\\n\\n if resonance.resonanceSet and (len(resonance.resonanceSet.atomSets) == 1):\\n atomSet = resonance.resonanceSet.findFirstAtomSet()\\n atom = atomSet.findFirstAtom()\\n chemAtom = atom.chemAtom\\n chemAtomSet = chemAtom.chemAtomSet\\n chemAtom0 = None\\n \\n if chemAtomSet:\\n if chemAtomSet.isEquivalent:\\n for chemAtomSet0 in chemAtom.chemComp.findAllChemAtomSets(isProchiral=True):\\n chemAtomSets = list(chemAtomSet0.chemAtomSets)\\n if chemAtomSet in chemAtomSet0.chemAtomSets:\\n chemAtomSets.remove(chemAtomSet)\\n chemAtom0 = chemAtomSets[0].findFirstChemAtom()\\n break\\n \\n elif chemAtomSet.isProchiral:\\n for chemAtom1 in chemAtomSet.chemAtoms:\\n if chemAtom1 is not chemAtom:\\n chemAtom0 = chemAtom1\\n break\\n\\n if chemAtom0:\\n atom0 = atom.residue.findFirstAtom(name=chemAtom0.name)\\n if atom0 and atom0.atomSet:\\n \\n resonances0 = list(resonance.resonanceSet.resonances)\\n resonances1 = []\\n \\n for resonanceSet in atom0.atomSet.resonanceSets:\\n if len(resonanceSet.atomSets) == 1:\\n resonances1 = list(resonanceSet.resonances)\\n break\\n \\n resonance.resonanceSet.delete()\\n if resonances1:\\n resonances1[0].resonanceSet.delete()\\n \\n if makeAmbiguous:\\n for resonance1 in resonances1:\\n assignAtomsToRes([atomSet,atom0.atomSet],resonance1)\\n\\n for resonance0 in resonances0:\\n assignAtomsToRes([atomSet,atom0.atomSet],resonance0)\\n\\n else:\\n \\n for resonance1 in resonances1:\\n assignAtomsToRes([atomSet, ],resonance1)\\n\\n for resonance0 in resonances0:\\n assignAtomsToRes([atom0.atomSet, ],resonance0)\\n \\n if chemAtomSet.isEquivalent:\\n for resonance0 in resonances0:\\n resonancesX = getBoundResonances(resonance0, recalculate=True)\\n \\n for bound in resonancesX:\\n if bound.resonanceSet:\\n atomB = bound.resonanceSet.findFirstAtomSet().findFirstAtom()\\n \\n if areAtomsBound(atom, atomB):\\n swapProchiralResonance(bound, makeAmbiguous)\\n \\n break\\n \\n else:\\n for resonance1 in resonances1:\\n resonancesX = getBoundResonances(resonance0, recalculate=True)\\n \\n for bound in resonancesX:\\n if bound.resonanceSet:\\n atomB = bound.resonanceSet.findFirstAtomSet().findFirstAtom()\\n \\n if areAtomsBound(atom0, atomB):\\n swapProchiralResonance(bound, makeAmbiguous)\\n \\n break\",\n \"def reset_mocap2body_xpos(sim):\\n\\n if (sim.model.eq_type is None or\\n sim.model.eq_obj1id is None or\\n sim.model.eq_obj2id is None):\\n return\\n for eq_type, obj1_id, obj2_id in zip(sim.model.eq_type,\\n sim.model.eq_obj1id,\\n sim.model.eq_obj2id):\\n if eq_type != mujoco_py.const.EQ_WELD:\\n continue\\n\\n mocap_id = sim.model.body_mocapid[obj1_id]\\n if mocap_id != -1:\\n # obj1 is the mocap, obj2 is the welded body\\n body_idx = obj2_id\\n else:\\n # obj2 is the mocap, obj1 is the welded body\\n mocap_id = sim.model.body_mocapid[obj2_id]\\n body_idx = obj1_id\\n\\n assert (mocap_id != -1)\\n sim.data.mocap_pos[mocap_id][:] = sim.data.body_xpos[body_idx]\\n # sim.data.mocap_quat[mocap_id][:] = sim.data.body_xquat[body_idx]\",\n \"def get_pi1(mol, atom, coord):\\n\\n omega = np.identity(2)\\n spin_j = np.einsum(\\\"ij,kl->ikjl\\\", omega, omega)\\n\\n pi_py = -mol.intor(\\\"int2e_ip1\\\")[coord] #minus sign due to pyscf definition\\n\\n j1_spatial = np.zeros((pi_py.shape[0],pi_py.shape[0],pi_py.shape[0],\\n pi_py.shape[0]))\\n\\n for i in range(pi_py.shape[0]):\\n\\n lambda_i = int(i in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for j in range(pi_py.shape[0]):\\n\\n lambda_j = int(j in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for k in range(pi_py.shape[0]):\\n\\n lambda_k = int(k in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n for l in range(pi_py.shape[0]):\\n\\n lambda_l = int(l in range(mol.aoslice_by_atom()[atom][2],\\n mol.aoslice_by_atom()[atom][3]))\\n\\n j1_spatial[i][j][k][l] += (pi_py[i][j][k][l] * lambda_i\\n + pi_py[j][i][k][l] * lambda_j\\n + pi_py[k][l][i][j] * lambda_k\\n + pi_py[l][k][i][j] * lambda_l)\\n\\n j1_spatial = np.einsum(\\\"abcd->acbd\\\", j1_spatial,\\n optimize='optimal') #convert to physicists\\n j1 = np.kron(spin_j, j1_spatial)\\n k1 = np.einsum(\\\"ijkl->ijlk\\\", j1,\\n optimize='optimal') #physicists notation\\n\\n pi1 = j1 - k1\\n\\n return pi1\",\n \"def test_parameterize_ethanol_different_reference_ordering_openeye(\\n self, force_field\\n ):\\n toolkit_registry = ToolkitRegistry(toolkit_precedence=[OpenEyeToolkitWrapper])\\n pdbfile = app.PDBFile(get_data_file_path(\\\"systems/test_systems/1_ethanol.pdb\\\"))\\n # Load the unique molecules with one atom ordering\\n molecules1 = [Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\"))]\\n topology1 = Topology.from_openmm(\\n pdbfile.topology,\\n unique_molecules=molecules1,\\n )\\n\\n omm_system1 = force_field.create_openmm_system(\\n topology1,\\n toolkit_registry=toolkit_registry,\\n )\\n # Load the unique molecules with a different atom ordering\\n molecules2 = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\"))\\n ]\\n topology2 = Topology.from_openmm(\\n pdbfile.topology,\\n unique_molecules=molecules2,\\n )\\n omm_system2 = force_field.create_openmm_system(\\n topology2,\\n toolkit_registry=toolkit_registry,\\n )\\n\\n serialized_1 = XmlSerializer.serialize(omm_system1)\\n serialized_2 = XmlSerializer.serialize(omm_system2)\\n\\n serialized_1 = round_charge(serialized_1)\\n serialized_2 = round_charge(serialized_2)\\n\\n assert serialized_1 == serialized_2\",\n \"def _set_boron_ppm_positions(self):\\n \\n #################################################################################################################################################\\n # Sets the boron impurity values in the active fuel region in each autofilled element position\\n self.fuel_ppm_positions ={\\n 'C___1':'7.6 ppm', 'B___1':'7.6 ppm', 'A___1':'7.6 ppm',\\n 'C___2':'7.6 ppm', 'B___2':'7.6 ppm', 'A___2':'7.6 ppm',\\n 'C___3':'7.6 ppm', 'B___3':'7.6 ppm', 'A___3':'7.6 ppm',\\n }\",\n \"def test_PRP(initial):\\n return plan_route((initial[0],initial[1]), initial[2],\\n # Goals:\\n [(2,3),(3,2)],\\n # Allowed locations:\\n [(0,0),(0,1),(0,2),(0,3),\\n (1,0),(1,1),(1,2),(1,3),\\n (2,0), (2,3),\\n (3,0),(3,1),(3,2),(3,3)])\",\n \"def test_same_results_on_fixed_random_state_pca_init(self):\\n tsne1 = TSNE(random_state=1, initialization='pca')\\n embedding1 = tsne1.fit(self.x)\\n\\n tsne2 = TSNE(random_state=1, initialization='pca')\\n embedding2 = tsne2.fit(self.x)\\n\\n np.testing.assert_array_equal(embedding1, embedding2,\\n 'Same random state produced different initial embeddings')\",\n \"def __init__(self):\\n self.__deviceselected__ = \\\"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\\\"\\n self.__source__ = \\\"SR-DMS4AP{LOCALBUMP}S-SP\\\"\\n self.__plane__ = \\\"SR-DMS4AP{LOCALBUMP}PLANE-SP\\\"\\n #self.__xshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\\\"\\n #self.__yshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\\\"\\n #self.__xangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\\\"\\n #self.__yangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\\\"\\n self.__shift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT-SP\\\"\\n self.__angle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-SP\\\"\\n # with all offsets\\n self.__anglerb__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-I\\\"\\n self.__positionrb__ = \\\"SR-DMS4AP{LOCALBUMP}POS-I\\\"\\n # with BBA offset only\\n self.__anglerb0__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\\\"\\n self.__positionrb0__ = \\\"SR-DMS4AP{LOCALBUMP}POS:BBA-I\\\"\\n\\n self.__bpmposition__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\\\"\\n self.__bpmorbitx__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\\\"\\n self.__bpmorbity__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\\\"\\n self.__bpmorbitx0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\\\"\\n self.__bpmorbity0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\\\"\\n\\n self.__correctorposition__ = \\\"SR-DMS4AP{LOCALBUMP:COR}Pos-I\\\"\\n self.__hcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\\\"\\n self.__hcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\\\"\\n self.__vcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\\\"\\n self.__vcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\\\"\\n\\n self.__undo__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\\\"\\n self.__apply__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\\\"\\n self.__status__ = \\\"SR-DMS4AP{LOCALBUMP}TS-I\\\"\\n self.__idposinfo__ = \\\"SR-DMS4AP{LOCALBUMP}S-I\\\"\\n self.__srcposition__ = \\\"SR-DMS4AP{LOCALBUMP}SRC-SP\\\"\",\n \"def test_order_atoms(self):\\n mol1 = converter.s_bonds_mol_from_xyz(self.xyz10['dict'])\\n mol2 = converter.s_bonds_mol_from_xyz(self.xyz10['dict_diff_order1'])\\n mol3 = converter.s_bonds_mol_from_xyz(self.xyz10['dict_diff_order2'])\\n converter.order_atoms(ref_mol=mol1, mol=mol2)\\n for atom1, atom2 in zip(mol1.atoms, mol2.atoms):\\n self.assertEqual(atom1.symbol, atom2.symbol)\\n converter.order_atoms(ref_mol=mol3, mol=mol1)\\n for atom1, atom2 in zip(mol3.atoms, mol1.atoms):\\n self.assertEqual(atom1.symbol, atom2.symbol)\\n\\n ref_mol = Molecule(smiles='[CH](CC[CH]c1ccccc1)c1ccccc1')\\n mol_list = ref_mol.copy(deep=True).generate_resonance_structures(keep_isomorphic=False, filter_structures=True)\\n for mol in mol_list:\\n converter.order_atoms(ref_mol=ref_mol, mol=mol)\\n bond_dict = dict()\\n for index1, atom1 in enumerate(ref_mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = ref_mol.atoms.index(atom2)\\n if index1 < index2:\\n if index1 not in bond_dict:\\n bond_dict[index1] = [index2]\\n else:\\n bond_dict[index1].append(index2)\\n for index1, atom1 in enumerate(mol.atoms):\\n for atom2 in atom1.edges.keys():\\n index2 = mol.atoms.index(atom2)\\n if index1 < index2:\\n self.assertIn(index2, bond_dict[index1]) # check that these atoms are connected in all mols\",\n \"def sort_poscar(by, key=None, reverse=False, poscar_filename=\\\"POSCAR\\\", cal_loc=\\\".\\\"):\\n available_by_list = [\\\"atomic_species\\\", \\\"cart_coords\\\", \\\"frac_coords\\\", \\\"selective_dynamics_mode\\\", \\\"lattice_matrix\\\"]\\n assert by in available_by_list, 'Input argument \\\"by\\\" of fuction sort_poscar must be \\\"atomic_species\\\", \\\"cart_coords\\\", \\\"frac_coords\\\", \\\"selective_dynamics_mode\\\" or \\\"lattice_matrix\\\"'\\n poscar_dict = read_poscar(poscar_filename=poscar_filename, cal_loc=cal_loc)\\n \\n sorted_index_list = [ind_value_pair[0] for ind_value_pair in sorted(enumerate(poscar_dict[by]), key=key, reverse=reverse)]\\n if by in [\\\"atomic_species\\\", \\\"cart_coords\\\", \\\"frac_coords\\\", \\\"selective_dynamics_mode\\\"]:\\n for quantity in [\\\"atomic_species\\\", \\\"cart_coords\\\", \\\"frac_coords\\\", \\\"selective_dynamics_mode\\\"]:\\n poscar_dict[quantity] = [poscar_dict[quantity][ind] for ind in sorted_index_list]\\n elif by == \\\"lattice_matrix\\\":\\n new_lattice_matrix = [poscar_dict[\\\"lattice_matrix\\\"][ind] for ind in sorted_index_list]\\n poscar_dict[\\\"lattice_matrix\\\"] = new_lattice_matrix\\n poscar_dict.update(get_lattice_properties(new_lattice_matrix))\\n for quantity in [\\\"cart_coords\\\", \\\"frac_coords\\\", \\\"selective_dynamics_mode\\\"]:\\n for atom_ind, atom_quantity in enumerate(poscar_dict[quantity]):\\n new_atom_quantity = [atom_quantity[ind] for ind in sorted_index_list]\\n poscar_dict[quantity][atom_ind] = new_atom_quantity\\n else:\\n raise Exception(\\\"You should not arrive here!\\\")\\n \\n return poscar_dict\",\n \"def set_init_pose(self, init_pose):\\n \\tself.check_publishers_connection()\\n \\tself.move_joints(init_pose)\",\n \"def Mol_SO(Nat, multip, charge, sym, SO_3rdrow_mols_val): # number of atoms, multiplicity, charge, array of atoms in molecule, value of SO_3rdrow_mols (from orca.inp file)\\n\\n Mol_SO = 0\\n \\n # Special Case - Acetleyne - S\\n if Nat == 4 and multip == 2 and charge == 1:\\n countH_temp =0\\n countC_temp =0\\n for tmp in range(len(sym)):\\n if sym[tmp] == \\\"H\\\":\\n countH_temp= countH_temp +1\\n if sym[tmp] == \\\"C\\\":\\n countC_temp = countC_temp +1\\n if countH_temp == 2 and countC_temp == 2:\\n Mol_SO = -0.07 #-0.07d0\\n \\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"DETECTED A C2H2+ SYSTEM: Using SO parameters for acetylene cation\\\\n\\\")\\n ther_chem.write(\\\"Ref: JCP 114, 9287, 2001\\\\n\\\\n\\\")\\n # Special Case - Acetleyne - E\\n \\n # For diatomics with multip = 2\\n if Nat == 2 and multip == 2 :\\n sort_sym = sorted(sym, reverse=True)\\n if SO_3rdrow_mols_val == \\\"true\\\": # for 3rd_row elements\\n \\n if charge == 0:\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Br': Mol_SO=-2.20\\n \\n # COMMMENT: paper has it for cation, but it looks like it is for neutral\\n if sort_sym[0] == 'Se' and sort_sym[1] == 'H': Mol_SO=-4.21\\n \\n if charge == +1: ### RECHECK what the values of charge is!!!!!!!!!!!!!!!!!!!!!IMPORTANT\\n if sort_sym[0] == 'K' and sort_sym[1] == 'Br': Mol_SO=-2.99\\n if sort_sym[0] == 'H' and sort_sym[1] == 'As': Mol_SO=-3.54\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Br': Mol_SO=-6.26\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Br': Mol_SO=-6.10\\n if sort_sym[0] == 'Na' and sort_sym[1] == 'Br': Mol_SO=-3.93\\n if sort_sym[0] == 'Br' and sort_sym[1] == 'Br': Mol_SO=-6.55\\n \\n else: # for non 3rd row elements, first and second rows\\n if charge == 0:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'C': Mol_SO=-0.07\\n if sort_sym[0] == 'O' and sort_sym[1] == 'H': Mol_SO=-0.30\\n if sort_sym[0] == 'O' and sort_sym[1] == 'N': Mol_SO=-0.27\\n if sort_sym[0] == 'O' and sort_sym[1] == 'Cl': Mol_SO=-0.61\\n if sort_sym[0] == 'S' and sort_sym[1] == 'H': Mol_SO=-1.01\\n if sort_sym[0] == 'P' and sort_sym[1] == 'O': Mol_SO=-0.53\\n if sort_sym[0] == 'Si' and sort_sym[1] == 'H': Mol_SO=-0.34\\n \\n if charge == -1:\\n if sort_sym[0] == 'N' and sort_sym[1] == 'H': Mol_SO=-0.12\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.45\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.34\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.12\\n \\n if charge == +1:\\n if sort_sym[0] == 'H' and sort_sym[1] == 'F': Mol_SO=-0.62\\n if sort_sym[0] == 'P' and sort_sym[1] == 'H': Mol_SO=-0.67\\n if sort_sym[0] == 'H' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n if sort_sym[0] == 'N' and sort_sym[1] == 'N': Mol_SO=-0.17\\n if sort_sym[0] == 'O' and sort_sym[1] == 'O': Mol_SO=-0.43\\n if sort_sym[0] == 'P' and sort_sym[1] == 'P': Mol_SO=-0.57\\n if sort_sym[0] == 'S' and sort_sym[1] == 'S': Mol_SO=-1.25\\n if sort_sym[0] == 'Cl' and sort_sym[1] == 'Cl': Mol_SO=-1.77\\n if sort_sym[0] == 'F' and sort_sym[1] == 'Cl': Mol_SO=-1.60\\n \\n return(Mol_SO)\",\n \"def standarization_ofPScodomain(a2_data, PS):\\n\\n if 'grid' not in PS['nmlz']['indx'].keys():\\n raise RuntimeError('py-user indexed grid required for mapping codomain')\\n\\n # generating mapping from a2 to py in FP style\\n # ATTENTION: \\\"-1\\\" is substracted from the return a2 tuple due to a2 starting indexing with 1\\n # while this info is not present in the incoming data this has to be hardcoded in the mapping\\n map_a2_2_py = []\\n for dimi in PS['real']['data'].keys():\\n if dimi.dim_name.lower() == \\\"burnup\\\":\\n if dimi.a2_idx is not None:\\n raise RuntimeError('assumed indexation g(iota,bu) is false')\\n else:\\n map_a2_2_py.append(lambda x, i_bound=dimi.a2_idx: x[i_bound] - 1)\\n\\n # print map_a2_2_py\\n # sys.exit()\\n # flatting a2 data as x_{py-grid-point}, g(x)\\n gx_unordered = []\\n for a2_tuple in a2_data:\\n if type(a2_tuple) != tuple:\\n raise RuntimeError('cant understand codomain')\\n for bu_idx, val in enumerate(a2_data[a2_tuple]):\\n gx_unordered.append([tuple([bu_idx] + [f(a2_tuple) for f in map_a2_2_py]), val])\\n\\n grid_len = len(PS['nmlz']['indx']['grid'])\\n if len(gx_unordered) != grid_len:\\n print PS['nmlz']['indx']['grid']\\n print gx_unordered\\n raise RuntimeError('Mismatch between the length of a2 data and corresponding grid points')\\n\\n # ordering the calc points according to the py-grid (ppack order)\\n gx_pygridindex_unordered = []\\n for x, gx in gx_unordered:\\n try:\\n # stored as [required position, value]\\n gx_pygridindex_unordered.append([PS['nmlz']['indx']['grid'].index(x), gx])\\n except ValueError:\\n print 'a2 point could not be found in grid'\\n sys.exit()\\n\\n if len(gx_pygridindex_unordered) != grid_len: # this should be Order(1)\\n raise RuntimeError('Mismatch between the length of a2 data and corresponding grid points')\\n gx_ordered = np.array([gx[1] for gx in sorted(\\n gx_pygridindex_unordered, key=lambda x:x[0])], order='F')\\n gx_ordered.setflags(write=False)\\n return gx_ordered\",\n \"def initial(self):\\n return zero\",\n \"def test_mixed_canonize():\\n \\n for n in range(Nmin, Nmax+1):\\n random_state = new_random_state(d, n)\\n rand_mps = []\\n MPS_full = to_full_MPS(random_state, n, d) #just for the shapes\\n \\n for shape in [a.shape for a in MPS_full]: #Generate an unnormalized mps (since MPS_full would be already in left-canonical form by construction)\\n rand_mps.append(np.random.rand(*shape)) \\n \\n MPS_mixedcanonical = rand_mps\\n for pos in range(n): \\n #set the site at pos as center of orthogonality\\n if pos > 0:\\n MPS_mixedcanonical = left_canonize(MPS_mixedcanonical[:pos+1]) + MPS_mixedcanonical[pos+1:]\\n if pos < n-1:\\n MPS_mixedcanonical = MPS_mixedcanonical[:pos] + right_canonize(MPS_mixedcanonical[pos:])\\n\\n if pos > 0:\\n assert check_left_canonization(MPS_mixedcanonical[:pos+1]), \\\"Error in mixed left\\\"\\n if pos < n-1:\\n assert check_right_canonization(MPS_mixedcanonical[pos:]), \\\"Error in mixed right\\\"\",\n \"def move(self):\\n \\\"\\\"\\\" Responsible for transformations \\\"\\\"\\\"\\n pos, com, success = self.perception \\n if self.destination is None:\\n return array([0,0])\\n\\n if not self.awake:\\n return array([0,0])\\n\\n\\n if self.phase == 4 and self.proper_formation is not None:\\n no_go = []\\n for i in range(0,len(self.proper_formation)):\\n if i != self.order and self.proper_formation[i][0] == self.proper_formation[self.order][0]:\\n no_go.append(self.transform(self.proper_formation[i][1] - self.position))\\n pos = merge_array_lists(pos, no_go)\\n\\n if self.phase == 2:\\n point = self.destination.copy() - self.position\\n elif self.phase > 2:\\n point = self.transform(self.destination.copy() - self.position)\\n else:\\n point = self.destination.copy()\\n\\n if not array_equal(point, array([0,0])):\\n reachable, path = findpathtoclosest(array([0,0]), point, pos)\\n \\n if len(path) == 0:\\n move = array([0,0]) \\n else:\\n move = path[0]\\n if not reachable and not array_equal(move,array([0,0])):\\n if self.phase == 2:\\n self.closest_i_could_get = path[-1] + self.position\\n elif self.phase > 2:\\n self.closest_i_could_get = self.transform2(path[-1]) + self.position\\n else:\\n self.closest_i_could_get = path[-1]\\n elif not reachable:\\n if self.phase > 1:\\n self.closest_i_could_get = self.position\\n else:\\n self.closest_i_could_get = array([0,0])\\n else:\\n self.closest_i_could_get = None\\n\\n if reachable and self.phase == 4 and array_equal(move,array([0,0])):\\n move = self.randomStep()\\n self.closest_i_could_get = None\\n\\n else:\\n move = array([0,0])\\n self.closest_i_could_get = None\\n\\n return move\",\n \"def __init__(self, slipPlane, slipDir, crystalStructure, cOverA=None):\\n self.crystalStructure = crystalStructure\\n\\n # Stored as Miller indices (Miller-Bravais for hexagonal)\\n self.planeIdc = tuple(slipPlane)\\n self.dirIdc = tuple(slipDir)\\n\\n # Stored as vectors in a cartesian basis\\n if self.crystalStructure.name == \\\"cubic\\\":\\n self.slipPlane = slipPlane / norm(slipPlane)\\n self.slipDir = slipDir / norm(slipDir)\\n self.cOverA = None\\n elif self.crystalStructure.name == \\\"hexagonal\\\":\\n if cOverA is None:\\n raise Exception(\\\"No c over a ratio given\\\")\\n self.cOverA = cOverA\\n\\n # Convert plane and dir from Miller-Bravais to Miller\\n slipPlaneM = convertIdc('mb', plane=slipPlane)\\n slipDirM = convertIdc('mb', dir=slipDir)\\n\\n # Transformation from crystal to orthonormal coords\\n lMatrix = CrystalStructure.lMatrix(\\n 1, 1, cOverA, np.pi / 2, np.pi / 2, np.pi * 2 / 3\\n )\\n # Q matrix for transforming planes\\n qMatrix = CrystalStructure.qMatrix(lMatrix)\\n\\n # Transform into orthonormal basis and then normalise\\n self.slipPlane = np.matmul(qMatrix, slipPlaneM)\\n self.slipPlane /= norm(self.slipPlane)\\n self.slipDir = np.matmul(lMatrix, slipDirM)\\n self.slipDir /= norm(self.slipDir)\\n else:\\n raise Exception(\\\"Only cubic and hexagonal currently supported.\\\")\",\n \"def init_m(pos):\\n x, y, z = pos\\n\\n k = 0.1\\n nx = k * (x - 0.5)\\n\\n return (0, np.sin(nx), np.cos(nx))\",\n \"def align_c_axis_along_001(structure):\\n\\n c = structure.lattice._matrix[2]\\n z = [0, 0, 1]\\n axis = np.cross(c, z)\\n if not(axis[0] == 0 and axis[1] == 0):\\n theta = (np.arccos(np.dot(c, z) / (np.linalg.norm(c) * np.linalg.norm(z))))\\n R = get_rotation_matrix(axis, theta)\\n rotation = SymmOp.from_rotation_and_translation(rotation_matrix=R)\\n structure.apply_operation(rotation)\\n return structure\",\n \"def rip1_to_parp():\\n Monomer('MLKL', ['bRHIM', 'state'], {'state':['unmod', 'active', 'inactive']})\\n Parameter('MLKL_0' , 1.0e6) # molecules per cell\\n alias_model_components()\\n Initial(MLKL(bRHIM = None, state = 'unmod'), MLKL_0) # MLKL\\n \\n Rule('Rip_PO4lation', RIP1(bRHIM=ANY, state = 'unmod')%RIP3(bRHIM=ANY, state='unmod') >> RIP1(bRHIM=ANY, state = 'po4')%RIP3(bRHIM=ANY, state = 'po4'), Parameter('k19', 1e-1))\\n Rule('Rip_PO4lation_alt', RIP1(bRHIM=ANY, state = 'deub')%RIP3(bRHIM=ANY, state='unmod') >> RIP1(bRHIM=ANY, state = 'po4')%RIP3(bRHIM=ANY, state = 'po4'), Parameter('k19a', 1e-1))\\n \\n catalyze_state(RIP1(state='po4'), 'bPARP', MLKL(), 'bRHIM', 'state', 'unmod', 'active', [1e-6,1e-3, 1e-1])\\n catalyze_state(MLKL(state='active'), 'bRHIM', MLKL(), 'bRHIM', 'state', 'unmod', 'active', [1e-7, 0.2, 0.01])\",\n \"def metropolis_step(self, positions):\\n \\\"\\\"\\\"with brute-force sampling of new positions.\\\"\\\"\\\"\\n\\n # r = random.random()*random.choice((-1, 1))\\n # r is a random number drawn from the uniform prob. dist. in [0,1]\\n r = np.zeros(self.num_d)\\n for i in range(self.num_d):\\n r[i] = np.random.uniform(-1, 1)\\n # Pick a random particle\\n random_index = np.random.randint(0, high=len(positions))\\n new_positions = np.array(positions)\\n new_random_position = new_positions[random_index, :]\\n # Suggest a new move\\n new_positions[random_index, :] = new_random_position + r*self.delta_R\\n # Old system and wavefunction\\n wavefunction = self.w.wavefunction(positions)\\n old_wavefunction_squared = wavefunction**2\\n\\n # Test the new position with a new system and wavefunction\\n # sys_test = System(self.num_p, self.num_d)\\n # sys_test.positions_distances(new_positions)\\n # alpha = self.w.alpha\\n # beta = self.w.beta\\n # a = self.w.a\\n # wave_test = Wavefunction(self.num_p, self.num_d, alpha, beta, a, sys_test)\\n # test_wavefunction = wave_test.wavefunction(new_positions)\\n test_wavefunction = self.w.wavefunction(new_positions)\\n\\n new_wavefunction_squared = test_wavefunction**2\\n # print ('Old = ', positions)\\n\\n if new_wavefunction_squared <= 1e-14:\\n pass\\n else:\\n # acceptance_ratio = self.w.wavefunction_ratio(positions,\\n # new_positions)\\n acceptance_ratio = new_wavefunction_squared/old_wavefunction_squared\\n epsilon = np.random.sample()\\n\\n if acceptance_ratio > epsilon:\\n positions = new_positions\\n # print ('New = ', positions)\\n # self.s.distances_update(positions, random_index)\\n # self.s.positions_distances(new_positions)\\n self.c += 1.0\\n\\n else:\\n pass\\n\\n return positions\",\n \"def initialize_from_ramp(self):\\n self.center_position = self.ramp_object.top_center\",\n \"def test_phase_damping_error_full_canonical(self):\\n error = phase_damping_error(1, canonical_kraus=True)\\n circ, p = error.error_term(0)\\n targets = [np.diag([1, 0]), np.diag([0, 1])]\\n self.assertEqual(p, 1, msg=\\\"Kraus probability\\\")\\n self.assertEqual(circ[0][\\\"qubits\\\"], [0])\\n for op in circ[0]['params']:\\n self.remove_if_found(op, targets)\\n self.assertEqual(targets, [], msg=\\\"Incorrect kraus matrices\\\")\",\n \"def firstpass(data, pbc, symbols, units):\\n # Get units information\\n units_dict = style.unit(units)\\n \\n # Initialize parameter values\\n atomsstart = None\\n velocitiesstart = None\\n natoms = None\\n natypes = None\\n firstatoms = False\\n atomscolumns = 0\\n masses = None\\n num_masses_to_read = 0\\n xlo = xhi = ylo = yhi = zlo = zhi = None\\n xy = 0.0\\n xz = 0.0\\n yz = 0.0\\n i = 0\\n \\n # Read str and files in the same way\\n with uber_open_rmode(data) as fp:\\n \\n # Loop over all lines in fp\\n for i, fullline in enumerate(fp):\\n try:\\n fullline = fullline.decode('UTF-8')\\n except:\\n pass\\n \\n # Remove comments after '#'\\n try:\\n comment_index = fullline.index('#')\\n except:\\n line = fullline\\n else:\\n line = fullline[:comment_index]\\n \\n terms = line.split()\\n\\n # Skip blank lines\\n if len(terms)>0:\\n \\n # Read number of atoms \\n if len(terms) == 2 and terms[1] == 'atoms':\\n natoms = int(terms[0])\\n\\n # Read number of atom types\\n elif len(terms) == 3 and terms[1] == 'atom' and terms[2] == 'types': \\n natypes = int(terms[0])\\n \\n # Read boundary info\\n elif len(terms) == 4 and terms[2] == 'xlo' and terms[3] == 'xhi':\\n xlo = uc.set_in_units(float(terms[0]), units_dict['length'])\\n xhi = uc.set_in_units(float(terms[1]), units_dict['length'])\\n\\n elif len(terms) == 4 and terms[2] == 'ylo' and terms[3] == 'yhi':\\n ylo = uc.set_in_units(float(terms[0]), units_dict['length'])\\n yhi = uc.set_in_units(float(terms[1]), units_dict['length'])\\n\\n elif len(terms) == 4 and terms[2] == 'zlo' and terms[3] == 'zhi':\\n zlo = uc.set_in_units(float(terms[0]), units_dict['length'])\\n zhi = uc.set_in_units(float(terms[1]), units_dict['length'])\\n\\n elif len(terms) == 6 and terms[3] == 'xy' and terms[4] == 'xz' and terms[5] == 'yz':\\n xy = uc.set_in_units(float(terms[0]), units_dict['length'])\\n xz = uc.set_in_units(float(terms[1]), units_dict['length'])\\n yz = uc.set_in_units(float(terms[2]), units_dict['length'])\\n \\n # Identify starting line number for Atoms data\\n elif len(terms) == 1 and terms[0] == 'Atoms':\\n atomsstart = i + 1\\n firstatoms = True\\n\\n # Check for atom_style comment\\n try: \\n comment_index = fullline.index('#')\\n except:\\n atom_style = None\\n else:\\n atom_style = fullline[comment_index + 1:].strip()\\n \\n # Count number of columns in Atoms table\\n elif firstatoms:\\n atomscolumns = len(terms)\\n firstatoms = False\\n \\n # Identify starting line for Masses data\\n elif len(terms) == 1 and terms[0] == 'Masses':\\n if natypes is None:\\n raise FileFormatError('# atom types must appear before Masses list')\\n masses = [None for i in range(natypes)]\\n num_masses_to_read = natypes\\n \\n # Read masses\\n elif num_masses_to_read > 0:\\n read_mass(terms, masses)\\n num_masses_to_read -= 1\\n\\n # Identify starting line number for Velocity data\\n elif len(terms) == 1 and terms[0] == 'Velocities':\\n velocitiesstart = i + 1\\n \\n if i == 0:\\n raise FileNotFoundError(f'File {data} not found')\\n\\n if natoms is None:\\n raise FileFormatError('# atoms not found')\\n\\n if xlo is None or xhi is None:\\n raise FileFormatError('xlo, xhi box dimensions missing')\\n\\n if ylo is None or yhi is None:\\n raise FileFormatError('ylo, yhi box dimensions missing')\\n\\n if zlo is None or zhi is None:\\n raise FileFormatError('zlo, zhi box dimensions missing')\\n\\n if atomsstart is None:\\n raise FileFormatError('Atoms section missing')\\n\\n # Create system with natoms\\n box = Box(xlo=xlo, xhi=xhi,\\n ylo=ylo, yhi=yhi,\\n zlo=zlo, zhi=zhi,\\n xy=xy, xz=xz, yz=yz)\\n atoms = Atoms(natoms=natoms)\\n system = System(box=box, atoms=atoms, pbc=pbc, symbols=symbols,\\n masses=masses)\\n\\n # Compile dict of params\\n params = {}\\n params['atomsstart'] = atomsstart\\n params['velocitiesstart'] = velocitiesstart\\n params['atomscolumns'] = atomscolumns\\n params['atom_style'] = atom_style\\n\\n return system, params\",\n \"def generate_POSCAR(formu,mat_list,my_ordered_elements,my_ordered_numbers,revise_dos):\\n out_name='POSCAR.'+formu\\n out_name='POSCAR_files/'+out_name.replace(' ','')\\n openfile = open(out_name,'wt')\\n openfile.write(formu+'\\\\n')\\n openfile.write(str(1.0)+'\\\\n')\\n for str_lines in mat_list:\\n openfile.write(str_lines+'\\\\n')\\n openfile.write(my_ordered_elements+'\\\\n')\\n openfile.write(my_ordered_numbers+'\\\\n')\\n openfile.write('direct'+'\\\\n')\\n for string_lines in revise_dos:\\n openfile.write(string_lines+'\\\\n')\\n openfile.close()\",\n \"def initial_setup(N,L,dim):\\r\\n r = np.zeros((3,N))\\r\\n #n = int(np.rint((N/3)**(1/dim)))\\r\\n #nz = int(n+n)\\r\\n x1 = np.linspace(0+L/n/2,L-L/n/2,n)\\r\\n d0 = 1.0e-10 #intial distance between hydrogen and oxygen\\r\\n x2 = x1 + d0\\r\\n x3 = x1 - d0/np.sqrt(2)\\r\\n z = np.zeros(3*n)\\r\\n xy = np.zeros(3*n)\\r\\n for ii in range(n):\\r\\n z[ii*3+1] = x1[ii]\\r\\n z[ii*3+2] = x2[ii]\\r\\n z[ii*3] = x3[ii]\\r\\n xy[ii*3] = x1[ii]\\r\\n xy[ii*3+1] = x1[ii]\\r\\n xy[ii*3+2] = x1[ii]\\r\\n rx, ry,rz = np.meshgrid(x1,x1,z)\\r\\n r[0,:] = np.reshape(rx,N)\\r\\n r[1,:] = np.reshape(ry,N)\\r\\n r[2,:] = np.reshape(rz,N)\\r\\n r[0,0::3] += d0/np.sqrt(2) #add additional offset to one Oxygen\\r\\n return r\",\n \"def init_position(self):\\n if self.invert_init_angle is False:\\n self.theta_i_top = -self.theta_s_top\\n self.theta_i_bot = -self.theta_s_bot\\n else:\\n self.theta_i_top = self.theta_s_top\\n self.theta_i_bot = self.theta_s_bot\\n\\n self.move_mid_block(theta=self.theta_i_bot)\\n self.move_top_block(theta=self.theta_i_top)\\n\\n # Variables used to motion\\n self.x_offset = self.block_top.center.x\\n self.d_top = np.sin(self.theta_s_top) * self.bars_top.length * 2\\n self.d_bot = np.sin(self.theta_s_bot) * self.bars_bot.length * 2\",\n \"def initial_coordinates(mof, energy_map, atom_list, energy_limit):\\n reference_atom = 'C'\\n ref_atom_index = atom_list['atom'].index(reference_atom) + 3\\n initial_coors = []\\n energy_count = 0\\n pbc_count = 0\\n for emap_line in energy_map:\\n emap_coor = Coor([emap_line[0], emap_line[1], emap_line[2]])\\n pbc_coor = emap_coor.pbc(mof.uc_size, mof.uc_angle, mof.frac_ucv)\\n pbc_x = round(pbc_coor.x, 1)\\n pbc_y = round(pbc_coor.y, 1)\\n pbc_z = round(pbc_coor.z, 1)\\n # print(emap_coor.x, pbc_x)\\n if pbc_x == emap_coor.x and pbc_y == emap_coor.y and pbc_z == emap_coor.z:\\n if emap_line[ref_atom_index] < energy_limit:\\n initial_coors.append(Coor([emap_line[0], emap_line[1], emap_line[2]]))\\n else:\\n energy_count += 1\\n else:\\n pbc_count += 1\\n\\n # print('Ommited PBC: ', pbc_count, ' Energy: ', energy_count)\\n return initial_coors\",\n \"def get_construction_order(self) -> int:\\n return 0\",\n \"def __init__(self, phase, lc, err, airmass, crpa, common_mode_array, \\\\\\n psf_width, psf_width_ratio, psf_yposition, shift_position,\\n x1_array, prior_string, priorsigmas):\\n self.phase = phase\\n self.lc = lc\\n self.err= err\\n self.airmass = airmass\\n self.crpa = crpa\\n self.common_mode_array = common_mode_array\\n self.psf_width = psf_width\\n self.psf_width_ratio = psf_width_ratio\\n self.psf_yposition = psf_yposition\\n self.shift_position = shift_position\\n self.x1_array = x1_array ## generic additional correction.\\n self.prior_string = prior_string ## prior shape, 'gaus', 'tophat'\\n self.priorsigmas = priorsigmas\",\n \"def _initialize_default_start(self, state):\\n state.tau = self.rng.gamma(0.5, 1 / self.fixed.tau_rate)\\n eta = self.rng.standard_normal(self.fixed.n)\\n eta = eta - eta.mean()\\n state.eta = eta\\n state.spatial = self.state.eta\\n state.alpha = self.rng.multivariate_normal(\\n self.fixed.a_mu, 100 * self.fixed.a_prec, method='cholesky'\\n )\\n state.beta = self.rng.multivariate_normal(\\n self.fixed.b_mu, 100 * self.fixed.b_prec, method='cholesky'\\n )\\n return state\",\n \"def sequence_rr_legacy(mol):\\n F = Filters()\\n Cleanup(mol)\\n SanitizeMol(mol, sanitizeOps=SanitizeFlags.SANITIZE_ALL, catchErrors=False)\\n AssignStereochemistry(mol, cleanIt=True, force=True, flagPossibleStereoCenters=True) # Fix bug TD201904.01\\n mol = F.remove_isotope(mol)\\n mol = F.neutralise_charge(mol)\\n SanitizeMol(mol, sanitizeOps=SanitizeFlags.SANITIZE_ALL, catchErrors=False)\\n mol = F.keep_biggest(mol)\\n mol = F.add_hydrogen(mol, addCoords=True)\\n mol = F.kekulize(mol)\\n return mol\",\n \"def _set_init_pose(self):\\n raise NotImplementedError()\",\n \"def _set_init_pose(self):\\n raise NotImplementedError()\",\n \"def _set_init_pose(self):\\n raise NotImplementedError()\",\n \"def restorePositionsOfUnownedAntennas() :\\n if ( s.getInitializationFlag() == True ): return\\n unownedAnts = subarrayAntSetup( True )\\n progress(\\\"Setting positions of unowned and uninitialized antennas %s\\\" % helpers.formatAsRanges( unownedAnts) )\\n progress(\\\"....Pads\\\")\\n restoreAntCommand(pad, unownedAnts, subarray=DEFAULT)\\n progress( \\\"....Pad Offsets\\\" )\\n restoreAntCommand( padOffset, unownedAnts, subarray=DEFAULT )\\n progress(\\\"....Antenna positional offset and axis non-intersection\\\")\\n restoreAntCommand( antennaOffset, unownedAnts, subarray=DEFAULT )\\n restoreAntCommand( axisNonIntersection, unownedAnts, subarray=DEFAULT )\",\n \"def __init__(self, init_pose=None, init_velocities=None, \\n init_angle_velocities=None, runtime=5., target_pos=None):\\n \\n # initial state\\n self.state_scale = 1\\n \\n self.init_pose = np.concatenate((truncnorm.rvs(-1,1,0,1./3.,3), truncnorm.rvs(-0.021,0.021,0,0.007,3)))\\n self.init_pose[2] += 10\\n self.init_velocities = np.array([0.,0.,0.])\\n self.init_angle_velocities = np.array([0.,0.,0.])\\n\\n self.runtime = runtime\\n \\n # Simulation\\n self.sim = PhysicsSim(self.init_pose, self.init_velocities, self.init_angle_velocities, self.runtime) \\n self.action_repeat = 1\\n\\n self.init_state = np.concatenate((self.init_pose,self.init_velocities,self.init_angle_velocities),axis=0)\\n self.state_size = self.action_repeat * self.init_state.shape[0]\\n \\n self.action_low = 0 #-1\\n self.action_high = 2*450 #1\\n self.action_size = 4\\n\\n self.action_scale = 1 #450 # 1/2 max of the action \\n #self.state_scale = 150 # 1/2 size of the state space\\n \\n # Goal\\n self.target_pose = np.array([0.,0.,150.0])\\n\\n # The previous position\\n self.prev_pose = self.init_pose\",\n \"def test_known_commutators():\\n fock = LocalSpace(\\\"0\\\")\\n spin = SpinSpace(\\\"0\\\", spin=1)\\n a = Destroy(hs=fock)\\n a_dag = Create(hs=fock)\\n assert Commutator.create(a, a_dag) == IdentityOperator\\n assert Commutator.create(a_dag, a) == -IdentityOperator\\n\\n assert Commutator.create(\\n LocalSigma(1, 0, hs=fock), LocalSigma(0, 1, hs=fock)\\n ) == LocalProjector(1, hs=fock) - LocalProjector(0, hs=fock)\\n assert Commutator.create(\\n LocalSigma(1, 0, hs=fock), LocalProjector(1, hs=fock)\\n ) == (-1 * LocalSigma(1, 0, hs=fock))\\n assert Commutator.create(\\n LocalSigma(1, 0, hs=fock), LocalProjector(0, hs=fock)\\n ) == LocalSigma(1, 0, hs=fock)\\n assert Commutator.create(LocalSigma(1, 0, hs=fock), Create(hs=fock)) == (\\n -sqrt(2) * LocalSigma(2, 0, hs=fock)\\n )\\n assert Commutator.create(Jplus(hs=spin), Jz(hs=spin)) == -Jplus(hs=spin)\",\n \"def robot6_sphericalwrist_invkin(robot, desired_pose, last_joints = None):\\n \\n \\n \\n R06 = desired_pose.R\\n p0T = desired_pose.p\\n \\n if robot.R_tool is not None and robot.p_tool is not None:\\n R06 = R06.dot(np.transpose(robot.R_tool))\\n p0T = p0T - R06.dot(robot.p_tool)\\n \\n H = robot.H\\n P = robot.P\\n \\n theta_v = []\\n \\n #Correct for spherical joint position vectors\\n if not np.all(P[:,4] == 0):\\n P4_d = P[:,4].dot(H[:,3])\\n assert np.all(P[:,4] - P4_d*H[:,3] == 0)\\n P[:,3] += P[:,4]\\n P[:,4] = np.zeros(3)\\n \\n if not np.all(P[:,5] == 0):\\n P5_d = P[:,5].dot(H[:,5])\\n assert np.all(P[:,5] - P5_d*H[:,5] == 0)\\n P[:,6] += P[:,5]\\n P[:,5] = np.zeros(3) \\n \\n d1 = np.dot(ey, P[:,1] + P[:,2] + P[:,3])\\n v1 = p0T - R06.dot(P[:,6]) \\n p1 = ey\\n \\n Q1 = rox.subproblem4(p1, v1, -H[:,0], d1)\\n \\n normalize = normalize_joints(robot, last_joints)\\n \\n for q1 in normalize(0, Q1):\\n \\n R01=rox.rot(H[:,0], q1)\\n \\n p26_q1 = R01.T.dot(p0T - R06.dot(P[:,6])) - (P[:,0] + P[:,1])\\n \\n d3 = np.linalg.norm(p26_q1)\\n v3 = P[:,2] \\n p3 = P[:,3]\\n Q3 = rox.subproblem3(p3, v3, H[:,2], d3)\\n \\n for q3 in normalize(2,Q3):\\n \\n R23=rox.rot(H[:,2],q3)\\n \\n v2 = p26_q1 \\n p2 = P[:,2] + R23.dot(P[:,3])\\n q2 = rox.subproblem1(p2, v2, H[:,1])\\n \\n q2 = normalize(1, [q2])\\n if len(q2) == 0:\\n continue\\n q2 = q2[0] \\n \\n R12 = rox.rot(H[:,1], q2)\\n \\n R03 = R01.dot(R12).dot(R23)\\n \\n R36 = R03.T.dot(R06)\\n \\n v4 = R36.dot(H[:,5]) \\n p4 = H[:,5]\\n \\n Q4_Q5 = rox.subproblem2(p4, v4, H[:,3], H[:,4])\\n \\n for q4, q5 in normalize((3,4), Q4_Q5):\\n \\n R35 = rox.rot(H[:,3], q4).dot(rox.rot(H[:,4], q5))\\n R05 = R03.dot(R35)\\n R56 = R05.T.dot(R06)\\n \\n p6 = H[:,4]\\n v6 = R56.dot(H[:,4])\\n \\n q6 = rox.subproblem1(p6, v6, H[:,5])\\n \\n q6 = normalize(5, [q6])\\n if len(q6) == 0:\\n continue\\n q6 = q6[0]\\n \\n theta_v.append(np.array([q1, q2, q3, q4, q5, q6])) \\n if last_joints is not None:\\n theta_dist = np.linalg.norm(np.subtract(theta_v,last_joints), axis=1)\\n return [theta_v[i] for i in list(np.argsort(theta_dist))]\\n else:\\n return theta_v\",\n \"def model_prem(r):\\n\\n\\t#- normalised radius\\n\\tx = r / 6371000.0\\n\\n\\t#- march through the various depth levels -----------------------------------------------------\\n\\n\\t#- upper crust\\n\\tif (r >= 6356000.0):\\n\\t\\trho = 2.6\\n\\t\\tvpv = 5.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- lower crust\\n\\telif (r >= 6346000.6) & (r < 6356000.0):\\n\\t\\trho = 2.9\\n\\t\\tvpv = 6.8\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.9\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- LID\\n\\telif (r >= 6291000.0) & (r < 6346000.6):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 0.8317 + 7.2180 * x\\n\\t\\tvph = 3.5908 + 4.6172 * x\\n\\t\\tvsv = 5.8582 - 1.4678 * x\\n\\t\\tvsh = -1.0839 + 5.7176 * x\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- LVZ\\n\\telif (r >= 6151000.0) & (r < 6291000.0):\\n\\t\\trho = 2.6910 + 0.6924 * x\\n\\t\\tvpv = 0.8317 + 7.2180 * x\\n\\t\\tvph = 3.5908 + 4.6172 * x\\n\\t\\tvsv = 5.8582 - 1.4678 * x\\n\\t\\tvsh = -1.0839 + 5.7176 * x\\n\\t\\teta = 3.3687 - 2.4778 * x\\n\\n\\t#- Transition zone 1\\n\\telif (r >= 5971000.0) & (r < 6151000.0):\\n\\t\\trho = 7.1089 - 3.8045 * x\\n\\t\\tvpv = 20.3926 - 12.2569 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 8.9496 - 4.4597 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 2\\n\\telif (r >= 5771000.0) & (r < 5971000.0):\\n\\t\\trho = 11.2494 - 8.0298 * x\\n\\t\\tvpv = 39.7027 - 32.6166 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3512 - 18.5856 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Transition zone 3\\n\\telif (r >= 5701000.0) & (r < 5771000.0):\\n\\t\\trho = 5.3197 - 1.4836 * x\\n\\t\\tvpv = 19.0957 - 9.8672 * x\\n\\t\\tvph = vpv\\n\\t\\tvsv = 9.9839 - 4.9324 * x\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 1\\n\\telif (r >= 5600000.0) & (r < 5701000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 29.2766 - 23.6027 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 22.3459 - 17.2473 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- Lower mantle 2\\n\\telif (r >= 3630000.0) & (r < 5600000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 24.9520 - 40.4673 * x + 51.4832 * x**2 - 26.6419 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 11.1671 - 13.7818 * x + 17.4575 * x**2 - 9.2777 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Lower mantle 3\\n\\telif (r >= 3480000.0) & (r < 3630000.0):\\n\\t\\trho = 7.9565 - 6.4761 * x + 5.5283 * x**2 - 3.0807 * x**3\\n\\t\\tvpv = 15.3891 - 5.3181 * x + 5.5242 * x**2 - 2.5514 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 6.9254 + 1.4672 * x - 2.0834 * x**2 + 0.9783 * x**3\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0\\n\\n\\t#- Outer core\\n\\telif (r >= 1221000.5) & (r < 3480000.0):\\n\\t\\trho = 12.5815 - 1.2638 * x - 3.6426 * x**2 - 5.5281 * x**3\\n\\t\\tvpv = 11.0487 - 4.0362 * x + 4.8023 * x**2 - 13.5732 * x**3\\n\\t\\tvph = vpv\\n\\t\\tvsv = 0.0\\n\\t\\tvsh = 0.0\\n\\t\\teta = 1.0\\n\\n\\t#- Inner Core\\n\\telif (r >= 0.0) & (r < 1221000.5):\\n\\t\\trho = 13.0885 - 8.8381 * x**2\\n\\t\\tvpv = 11.2622 - 6.3640 * x**2\\n\\t\\tvph = vpv\\n\\t\\tvsv = 3.6678 - 4.4475 * x**2\\n\\t\\tvsh = vsv\\n\\t\\teta = 1.0 \\n\\n\\t#- convert to elastic parameters --------------------------------------------------------------\\n\\n\\trho = 1000.0 * rho\\n\\tvpv = 1000.0 * vpv\\n\\tvph = 1000.0 * vph\\n\\tvsv = 1000.0 * vsv\\n\\tvsh = 1000.0 * vsh\\n\\n\\tA = rho * vph**2\\n\\tC = rho * vpv**2\\n\\tN = rho * vsh**2\\n\\tL = rho * vsv**2\\n\\tF = eta * (A - 2 * L)\\n\\n\\treturn rho, A, C, F, L, N\",\n \"def _initialise(self):\\n if self._running:\\n raise RuntimeError('Already initialised.')\\n\\n # Propose x0 as first points\\n # Note proposal is multiple points this time!\\n self._current = None\\n self._current_log_pdfs = None\\n self._proposed = self._x0\\n self._proposed.setflags(write=False)\\n\\n # Number of chains left to update in this cycle\\n self._remaining = np.arange(self._n_chains)\\n\\n # Update sampler state\\n self._running = True\",\n \"def initial_importer(initials, initialZMT=True):\\n from .functions import cosd, lna\\n ###filling the running variables with values depending on the systemconfiguration in rk4input###\\n\\n if Base.spatial_resolution == 0:\\n dim = 0\\n print('0D')\\n Vars.T = initials['zmt']\\n else:\\n dim = 1\\n # NS==True corresponds to southpole to northpole representation (180 Degrees)\\n if Base.both_hemispheres == True:\\n Latrange = 180\\n\\n # Checking if Temperature and Latitude is set on a latitudal circle (0°,10°,..if step=10)\\n # or on a latitudinal belt and therefore between the boundaries (5°,15°,..if step=10)\\n\\n # circle==True and belt==False says on the latitudinal circle\\n if Base.latitudinal_circle == True and Base.latitudinal_belt == False:\\n Vars.Lat = np.linspace(-90 + Base.spatial_resolution, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution - 1))\\n Vars.Lat2 = np.linspace(-90, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\\n if initialZMT == True:\\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution - 1))\\n # Checking if the Temperature for each latitude starts with the same value or a\\n # cosine shifted value range\\n if initials['initial_temperature_cosine'] == True:\\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\\n\\n # circle==False and belt==True say on the latitudinal belt\\n if Base.latitudinal_circle == False and Base.latitudinal_belt == True:\\n Vars.Lat2 = np.linspace(-90 + Base.spatial_resolution, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution - 1))\\n Vars.Lat = np.linspace(-90, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\\n if initialZMT == True:\\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\\n if initials['initial_temperature_cosine'] == True:\\n if initials['initial_temperature_noise'] == True:\\n z = [0] * len(Vars.Lat)\\n for k in range(len(Vars.Lat)):\\n z[k] = np.random.normal(0, initials['initial_temperature_noise_amplitude'])\\n else:\\n z = 0\\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1) + lna(z)\\n\\n # Not from southpole to northpole rather equator to pole\\n else:\\n Latrange = 90\\n if Base.latitudinal_circle == True and Base.latitudinal_belt == False:\\n Vars.Lat = np.linspace(0, 90 - Base.spatial_resolution, int(Latrange / Base.spatial_resolution))\\n Vars.Lat2 = np.linspace(0, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\\n if initialZMT == True:\\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\\n if initials['initial_temperature_cosine'] == True:\\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\\n if Base.latitudinal_circle == False and Base.latitudinal_belt == True:\\n Vars.Lat2 = np.linspace(0, 90 - Base.spatial_resolution, int(Latrange / Base.spatial_resolution))\\n Vars.Lat = np.linspace(0, 90 - Base.spatial_resolution,\\n int(Latrange / Base.spatial_resolution)) + Base.spatial_resolution / 2\\n if initialZMT == True:\\n Vars.T = np.array([initials['zmt']] * int(Latrange / Base.spatial_resolution))\\n if initials['initial_temperature_cosine'] == True:\\n Vars.T = Vars.T + initials['initial_temperature_amplitude'] * (cosd(Vars.Lat) - 1)\\n\\n Vars.t = initials['time']\\n if Base.parallelization == True:\\n if initialZMT == True:\\n Vars.T = np.array([Vars.T] * Base.number_of_parallels)\\n Vars.T_global = np.array([initials['gmt']] * Base.number_of_parallels)\\n else:\\n Vars.T_global = initials['gmt']\",\n \"def neutral_molecule(force_field):\\n nodes = [\\n (1, {'charge_group': 1, 'resid': 1, 'resname': 'ALA', 'atomname': 'BB',\\n 'charge': 0, 'atype': 'P5',\\n 'modification': force_field.modifications['N-ter'],\\n 'mapping_weights': {0: 1, 5: 1, 1: 1, 4: 1.0, 2: 1, 3: 1, 6: 1, 7: 1},\\n 'chain': 'A', 'position': [0.12170435, 0.06658551, -0.0208]}),\\n (2, {'charge_group': 2, 'resid': 2, 'resname': 'ALA', 'atomname': 'BB',\\n 'charge': 0.0, 'atype': 'P4',\\n 'mapping_weights': {12: 1.0, 17: 1.0, 13: 1.0, 16: 1.0, 14: 1.0, 15: 1.0},\\n 'chain': 'A', 'position': [0.45269104, 0.23552239, 0.0214209]}),\\n (3, {'charge_group': 3, 'resid': 3, 'resname': 'ALA', 'atomname': 'BB',\\n 'charge': 0.0, 'atype': 'P4',\\n 'mapping_weights': {22: 1.0, 27: 1.0, 23: 1.0, 26: 1.0, 24: 1.0, 25: 1.0},\\n 'chain': 'A', 'position': [0.74704179, 0.45218955, -0.0214209]}),\\n (4, {'charge_group': 4, 'resid': 4, 'resname': 'ALA', 'atomname': 'BB',\\n 'charge': 0.0, 'atype': 'P4',\\n 'mapping_weights': {32: 1.0, 37: 1.0, 33: 1.0, 36: 1.0, 34: 1.0, 35: 1.0},\\n 'chain': 'A', 'position': [1.07289104, 0.61778657, 0.0214209]}),\\n (5, {'charge_group': 5, 'resid': 5, 'resname': 'ALA', 'atomname': 'BB',\\n 'charge': 0, 'atype': 'P5',\\n 'modification': force_field.modifications['C-ter'],\\n 'mapping_weights': {42: 1.0, 48: 1.0, 43: 1, 47: 1.0, 44: 1, 45: 1, 46: 1},\\n 'chain': 'A', 'position': [1.40449639, 0.85126265, -0.01729157]})\\n ]\\n mol = Molecule()\\n mol.add_nodes_from(nodes)\\n mol.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 5)])\\n return mol\",\n \"def test_center_of_coordinates_shift():\\n # print sys._getframe().f_code.co_name\\n # c = commons()\\n\\n pdb_inp = iotbx.pdb.input(source_info=None, lines=test_pdb_str_2)\\n ncs_obj_phil = ncs.input(\\n hierarchy=pdb_inp.construct_hierarchy())\\n ncs_restraints_group_list = ncs_obj_phil.get_ncs_restraints_group_list()\\n\\n # ncs_restraints_group_list = c.ncs_restraints_group_list\\n xrs = pdb_inp.xray_structure_simple()\\n shifts = ncs_restraints_group_list.get_ncs_groups_centers(\\n sites_cart = xrs.sites_cart())\\n\\n xyz = pdb_inp.atoms().extract_xyz()\\n center_of_coor = (flex.vec3_double([xyz.sum()]) * (1/xyz.size())).round(8)\\n # test shifts\\n t1 = shifts[0].round(8)\\n t2 = shifts[1].round(8)\\n d1 = flex.sqrt((center_of_coor-t1).dot()).min_max_mean().as_tuple()\\n d2 = flex.sqrt((center_of_coor-t2).dot()).min_max_mean().as_tuple()\\n assert (d1 == d2)\\n\\n # test shift to center\\n new_nrg = ncs_restraints_group_list.shift_translation_to_center(shifts = shifts)\\n expected = (22.63275, 5.54625, 2.9375)\\n assert (new_nrg[0].copies[0].t.round(5)).elems == expected\\n # back to original coordinates system\\n old_nrg = new_nrg.shift_translation_back_to_place(shifts=shifts)\\n expected = (old_nrg[0].copies[0].t.round(5)).elems\\n result = (ncs_restraints_group_list[0].copies[0].t.round(5)).elems\\n assert result == expected\",\n \"def preprocess(self):\\n\\n mm_magcoord.add_aacgm_coordinates(self)\\n mm_magcoord.add_quasi_dipole_coordinates(self)\\n mm_sc.calculate_ecef_velocity(self)\\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\\n\\n return\",\n \"def test_pair() -> None:\\n ra = pybundle.ReconstructionAlignment()\\n ra.add_shot(\\\"1\\\", 0, 0, 0, 0, 0, 0, False)\\n ra.add_shot(\\\"2\\\", 0, 0, 0, 0, 0, 0, False)\\n ra.add_reconstruction(\\\"a\\\", 0, 0, 0, 0, 0, 0, 4, False)\\n ra.add_relative_motion_constraint(\\n pybundle.RARelativeMotionConstraint(\\\"a\\\", \\\"1\\\", 0, 0, 0, 0, 0, 0)\\n )\\n ra.add_relative_motion_constraint(\\n pybundle.RARelativeMotionConstraint(\\\"a\\\", \\\"2\\\", 0, 0, 0, -1, 0, 0)\\n )\\n ra.add_absolute_position_constraint(\\\"1\\\", 1, 0, 0, 1)\\n ra.add_absolute_position_constraint(\\\"2\\\", 3, 0, 0, 1)\\n\\n ra.run()\\n s1 = ra.get_shot(\\\"1\\\")\\n s2 = ra.get_shot(\\\"2\\\")\\n rec_a = ra.get_reconstruction(\\\"a\\\")\\n\\n assert np.allclose(get_shot_origin(s1), [1, 0, 0], atol=1e-6)\\n assert np.allclose(get_shot_origin(s2), [3, 0, 0], atol=1e-6)\\n assert np.allclose(get_reconstruction_origin(rec_a), [1, 0, 0], atol=1e-6)\\n assert np.allclose(rec_a.scale, 0.5)\",\n \"def test_remove_translational_rotational_dof(positions):\\n class DummyTimeStep:\\n def __init__(self, positions):\\n self.positions = positions\\n self.n_atoms = len(positions)\\n ts = DummyTimeStep(positions=positions)\\n\\n transform = RemoveTransRotDOF(\\n center_atom_idx=0,\\n axis_atom_idx=2,\\n plane_atom_idx=3,\\n axis='z',\\n plane='xz'\\n )\\n ts = transform(ts)\\n\\n # The center atom is at the origin.\\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\\n\\n # The axis atom is on the expected axis.\\n expected_axis_atom_position = transform.axis * np.linalg.norm(\\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\\n\\n # The plane atom is orthogonal to the plane normal.\\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\\n\\n # The constrained atom indices is correct.\\n expected = np.array([0, 1, 2, 6, 7, 10])\\n assert np.all(transform.constrained_dof_indices == expected)\",\n \"def series_partial_order_representation(self, node=None):\\n try:\\n # Regard sp_order_list as a stack.\\n sp_order_stack = list(nx.dfs_preorder_nodes(self.tree, node))\\n sp_order_stack.reverse()\\n\\n # # New a stack to store the lower operation priority element.\\n # temp_stack = []\\n #\\n # # New a list to store the series-parallel partial order formula\\n # sp_order_list = []\\n #\\n # # New a stack to store the completed operations\\n # operations_stack = []\\n #\\n # while len(sp_order_stack) + len(temp_stack) >= 2:\\n # # ecah round we check whether the root of the first element is match the third element.\\n # # if len(sp_order_stack) >= 3:\\n # # the_first_element = sp_order_stack.pop()\\n # # else:\\n # # the_first_element = temp_stack.pop()\\n # # the_second_element = sp_order_stack.pop()\\n # # the_third_element = sp_order_stack.pop()\\n #\\n # current_elements = []\\n #\\n # while len(current_elements) < 3:\\n # if sp_order_stack:\\n # current_elements.append(sp_order_stack.pop())\\n # else:\\n # current_elements.append(temp_stack.pop())\\n # current_elements.reverse()\\n #\\n # print current_elements\\n #\\n # print \\\"Current: {} {} {} {}\\\".format(current_elements[0], current_elements[1], current_elements[2],\\n # sp_order_stack)\\n # # if match then move the first two elements to sp_order_list\\n # if self.tree.predecessors(current_elements[0])[0] == current_elements[2]:\\n #\\n # if not sp_order_list or self.tree.predecessors(sp_order_list[-1])[0] != current_elements[0]:\\n # sp_order_list.append(current_elements[1])\\n # # if self.tree.out_degree(the_first_element) > 0 and len(sp_order_stack) == 0:\\n # # the_temp_operation_final_element = [[i, j, k] for i, j, k in operations_stack if\\n # # k == the_first_element]\\n # # i, j = the_temp_operation_final_element[0][0], the_temp_operation_final_element[0][1]\\n # #\\n # # sp_order_list.append(i)\\n # # sp_order_list.append(j)\\n # sp_order_list.append(current_elements[0])\\n #\\n # else:\\n # if self.tree.out_degree(current_elements[0]) > 0 and len(sp_order_stack) == 0:\\n # the_temp_operation_final_element = [[i, j, k] for i, j, k in operations_stack if\\n # k == current_elements[0]]\\n # i, j = the_temp_operation_final_element[0][0], the_temp_operation_final_element[0][1]\\n #\\n # sp_order_list.append(i)\\n # sp_order_list.append(j)\\n #\\n # sp_order_list.append(current_elements[0])\\n # sp_order_list.append(current_elements[1])\\n # sp_order_stack.append(current_elements[2])\\n #\\n # else:\\n # if self.tree.out_degree(current_elements[0]) > 0 and self.tree.successors(current_elements[0])[\\n # 0] in sp_order_list and self.tree.successors(current_elements[0])[1] in sp_order_list:\\n # # if the_first_element is the sub-tree that was already searched than\\n # # push to operations_stack and put the operator as a stamp to Temp_stack.\\n #\\n # # else:\\n # the_first_operation_element = sp_order_list.pop()\\n # the_second_operation_element = sp_order_list.pop()\\n # operations_stack.append(\\n # [the_second_operation_element, the_first_operation_element, current_elements[0]])\\n # temp_stack.append(current_elements[0])\\n #\\n # stamps_in_operations_stack = [k for i, j, k in operations_stack]\\n # if stamps_in_operations_stack and current_elements[0] in stamps_in_operations_stack:\\n #\\n # # if stamps_in_operations_stack is not null then temp_stack can not be null\\n # the_recover_element = temp_stack.pop()\\n #\\n # # in case of duplicate of the_first_element.\\n # if temp_stack and the_recover_element == current_elements[0]:\\n # the_recover_element = temp_stack.pop()\\n #\\n # # Recover the sp_order_stack to process next search.\\n # sp_order_stack.append(current_elements[2])\\n # sp_order_stack.append(current_elements[1])\\n # if the_recover_element:\\n # sp_order_stack.append(current_elements[0])\\n # sp_order_stack.append(the_recover_element)\\n # sp_order_stack.append(current_elements[0])\\n #\\n # else:\\n # if len(temp_stack) <= 0:\\n # # if temp_stack is null then store the first element to temp_stack\\n # # and put the other two back to sp_order_stack.\\n #\\n # temp_stack.append(current_elements[0])\\n # else:\\n # # get a element from temp_stack to check if match\\n # # No need to check if sp_order_list is null as at the final round,\\n # # they must share the same parent(root).\\n #\\n # the_temp_element = temp_stack.pop()\\n # the_temp_operation_element = [[i, j, k] for i, j, k in operations_stack if\\n # k == the_temp_element]\\n #\\n # # To check the checked node is already a tree that was search.\\n # if self.tree.predecessors(the_temp_element)[\\n # 0] == current_elements[1] and the_temp_operation_element:\\n #\\n #\\n # # To check if the node shared the same parent is a tree\\n # # if so, then add its children before it.\\n # # otherwise add itself after the output list.\\n # the_temp_operation_second_element = [[i, j, k] for i, j, k in operations_stack if\\n # k == current_elements[0]]\\n #\\n # if the_temp_operation_second_element:\\n # i, j = the_temp_operation_second_element[0][0], \\\\\\n # the_temp_operation_second_element[0][1]\\n # sp_order_list.append(i)\\n # sp_order_list.append(j)\\n # operations_stack.remove(the_temp_operation_second_element[0])\\n # sp_order_list.append(current_elements[0])\\n #\\n # i, j, k = the_temp_operation_element[0][0], the_temp_operation_element[0][1], \\\\\\n # the_temp_operation_element[0][2]\\n #\\n # sp_order_list.append(i)\\n # sp_order_list.append(j)\\n # sp_order_list.append(k)\\n # operations_stack.remove(the_temp_operation_element[0])\\n #\\n # # if the checked node match its parent\\n # elif self.tree.predecessors(the_temp_element)[0] == current_elements[1]:\\n # sp_order_list.append(current_elements[0])\\n # sp_order_list.append(the_temp_element)\\n #\\n # # otherwise, put the_temp_element and the_first_element to temp_stack,\\n # # as they all are not matched the parent searched so far\\n # else:\\n # temp_stack.append(the_temp_element)\\n # temp_stack.append(current_elements[0])\\n #\\n # # Recover the sp_order_stack to process next search.\\n # sp_order_stack.append(current_elements[2])\\n # sp_order_stack.append(current_elements[1])\\n #\\n #\\n # print \\\"Temp_stack: {}\\\".format(temp_stack)\\n # print \\\"operations_stack: {}\\\".format(operations_stack)\\n # print \\\"Output: {}\\\".format(sp_order_list)\\n # print\\n #\\n # # current_elements.remove(current_elements[0])\\n # # current_elements.remove(current_elements[1])\\n # # current_elements.remove(current_elements[2])\\n #\\n # sp_root = sp_order_stack.pop()\\n # sp_order_list.append(sp_root)\\n #\\n # while operations_stack:\\n # i, j, k = operations_stack.pop()\\n # sp_order_list.insert(sp_order_list.index(k), i)\\n # sp_order_list.insert(sp_order_list.index(k), j)\\n\\n except Exception:\\n raise TypeError(\\\"There is no {} in the binary construction tree\\\".format(node))\\n return sp_order_stack\",\n \"def test_diatomic_dummy_molecule_rotation_around_molecule_axis():\\n mol = Molecule()\\n mol.atoms = ['C'] * 2\\n mol.coordinates = np.array([[1, 0, 0], [0, 1, 0]])\\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi / 2, center=True)\\n assert np.allclose(mol.coordinates, [[1, 1, 0], [0, 0, 0]])\\n mol.rotate(([0, 0, 0], [0, 0, 1]), np.pi, center=True)\\n assert np.allclose(mol.coordinates, [[0, 0, 0], [1, 1, 0]])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6103005","0.59019697","0.5630828","0.55407274","0.55275506","0.54735744","0.54610157","0.54103494","0.53193635","0.53148454","0.5281034","0.5277508","0.5273492","0.5247259","0.52436775","0.5241989","0.52053905","0.5181437","0.5178617","0.51722807","0.5165432","0.5154125","0.51536185","0.5153231","0.5141262","0.5109453","0.5104935","0.5102926","0.5097231","0.5080843","0.50757796","0.50562173","0.50494295","0.503909","0.502894","0.50276065","0.5020745","0.50201684","0.50109726","0.49929953","0.49927226","0.49925318","0.4986967","0.49818787","0.49752352","0.49732706","0.49670386","0.49592933","0.49465057","0.4940567","0.49371022","0.49263468","0.4922511","0.49198923","0.49190384","0.48951262","0.48925188","0.4890741","0.48867106","0.48857757","0.4885483","0.48843944","0.4884036","0.48819768","0.48767465","0.4875545","0.4865405","0.48622912","0.48615035","0.4858336","0.4852959","0.4852406","0.4837227","0.48347104","0.48344523","0.48313728","0.48291847","0.48280075","0.4824358","0.48195928","0.48183313","0.48137707","0.48122907","0.4807643","0.4807643","0.4807643","0.4803546","0.47996423","0.47993252","0.47982717","0.47947812","0.47917533","0.47916013","0.47889665","0.47881564","0.47846207","0.47799504","0.4777087","0.47748417","0.47701457"],"string":"[\n \"0.6103005\",\n \"0.59019697\",\n \"0.5630828\",\n \"0.55407274\",\n \"0.55275506\",\n \"0.54735744\",\n \"0.54610157\",\n \"0.54103494\",\n \"0.53193635\",\n \"0.53148454\",\n \"0.5281034\",\n \"0.5277508\",\n \"0.5273492\",\n \"0.5247259\",\n \"0.52436775\",\n \"0.5241989\",\n \"0.52053905\",\n \"0.5181437\",\n \"0.5178617\",\n \"0.51722807\",\n \"0.5165432\",\n \"0.5154125\",\n \"0.51536185\",\n \"0.5153231\",\n \"0.5141262\",\n \"0.5109453\",\n \"0.5104935\",\n \"0.5102926\",\n \"0.5097231\",\n \"0.5080843\",\n \"0.50757796\",\n \"0.50562173\",\n \"0.50494295\",\n \"0.503909\",\n \"0.502894\",\n \"0.50276065\",\n \"0.5020745\",\n \"0.50201684\",\n \"0.50109726\",\n \"0.49929953\",\n \"0.49927226\",\n \"0.49925318\",\n \"0.4986967\",\n \"0.49818787\",\n \"0.49752352\",\n \"0.49732706\",\n \"0.49670386\",\n \"0.49592933\",\n \"0.49465057\",\n \"0.4940567\",\n \"0.49371022\",\n \"0.49263468\",\n \"0.4922511\",\n \"0.49198923\",\n \"0.49190384\",\n \"0.48951262\",\n \"0.48925188\",\n \"0.4890741\",\n \"0.48867106\",\n \"0.48857757\",\n \"0.4885483\",\n \"0.48843944\",\n \"0.4884036\",\n \"0.48819768\",\n \"0.48767465\",\n \"0.4875545\",\n \"0.4865405\",\n \"0.48622912\",\n \"0.48615035\",\n \"0.4858336\",\n \"0.4852959\",\n \"0.4852406\",\n \"0.4837227\",\n \"0.48347104\",\n \"0.48344523\",\n \"0.48313728\",\n \"0.48291847\",\n \"0.48280075\",\n \"0.4824358\",\n \"0.48195928\",\n \"0.48183313\",\n \"0.48137707\",\n \"0.48122907\",\n \"0.4807643\",\n \"0.4807643\",\n \"0.4807643\",\n \"0.4803546\",\n \"0.47996423\",\n \"0.47993252\",\n \"0.47982717\",\n \"0.47947812\",\n \"0.47917533\",\n \"0.47916013\",\n \"0.47889665\",\n \"0.47881564\",\n \"0.47846207\",\n \"0.47799504\",\n \"0.4777087\",\n \"0.47748417\",\n \"0.47701457\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5067868"},"document_rank":{"kind":"string","value":"31"}}},{"rowIdx":19799,"cells":{"query":{"kind":"string","value":"Rank points in a cluster based on their distance to the cluster centroid/medoid"},"document":{"kind":"string","value":"def __init__(self, points, clusterer, metric='euclidean', selection_method='centroid'):\n self.clusterer = clusterer\n self.metric = metric\n \n allowed_methods = ['centroid', 'medoid']\n if selection_method not in allowed_methods:\n raise ValueError(f'Selection method must be one of {allowed_methods}')\n \n if selection_method == 'centroid' and metric != 'euclidean':\n raise ValueError(f'Metric must be euclidian when using selection_method centroid. '\n f'Current metric is {metric}')\n \n self.selection_method = selection_method\n \n self._embedding_cols = [str(i) for i in range(points.shape[1])]\n self.embedding_df = pd.DataFrame(points, columns=self._embedding_cols)\n self.embedding_df['cluster'] = clusterer.labels_"},"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 rank_cluster_points_by_distance(self, cluster_id):\n cluster_of_interest = self.embedding_df[self.embedding_df['cluster'] == cluster_id].copy()\n \n if cluster_of_interest.empty:\n raise ValueError(f'Cluster id {cluster_id} not found')\n \n if 'dist_to_rep_point' not in self.embedding_df.columns:\n distance_df = self.calculate_distances_for_cluster(cluster_id)\n cluster_of_interest = cluster_of_interest.merge(distance_df, left_index=True, right_index=True)\n \n cluster_of_interest.sort_values('dist_to_rep_point', inplace=True)\n return cluster_of_interest","def get_all_cluster_rankings(self):\n if 'dist_to_rep_point' not in self.embedding_df.columns:\n self.calculate_all_distances_to_center()\n\n self.embedding_df['rank_in_cluster'] = self.embedding_df.groupby('cluster')['dist_to_rep_point'].rank(method='min')","def rankNeighbors(Data):\r\n strokeDist = []\r\n for i in range(len(Data)):\r\n strokeDist.append([])\r\n index = 0\r\n for point1 in Data:\r\n dist = []\r\n index1=0\r\n for point2 in Data:\r\n #dist.append(math.sqrt((center1[0]-center2[0])**2+(center1[1]-center2[1])**2))\r\n dist.append((index1,math.sqrt((point1[0]-point2[0])**2+(point1[1]-point2[1])**2+(point1[2]-point2[2])**2)))\r\n index1+=1\r\n #x = copy.deepcopy(dist)\r\n #print(x)\r\n dist.sort(key= lambda x:x[1])\r\n #print(x)\r\n # Get rank for each element\r\n idx1 =0\r\n for e in dist:\r\n #i = x.index(e)\r\n strokeDist[index].append(e)\r\n idx1 +=1\r\n index+=1\r\n return strokeDist","def _assign_clusters(self):\n\n dist = np.zeros((self.k, ))\n distortion = 0\n\n for index in range(0, self.data.shape[0]):\n for i in range(0, self.k):\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\n\n self.assigned_clusters[index] = np.argmin(dist)\n distortion += np.min(dist)\n\n return distortion","def distance(point, cluster):\n return np.sqrt((point[0] - cluster[0])**2 + (point[1] - cluster[1])**2)","def cluster_spatial_positioning(data):\n \n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\n if n_clusters <2:\n #Setting cluster angluar features to default\n cdist=[Cluster_Relative_Distances()]\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n elif n_clusters >=2:\n # Here we implement two approaches for measuring distances between clustes:\n # (1) border-boder distances and (2) centroid-centroid distances. \n # We compute dispersion measures for the distances obtained. \n \n d = dict(tuple(data.groupby('clusters')))\n d.pop(-1, None)\n\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\n\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\n\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\n\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\n\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\n \n cdist = pd.DataFrame([o.__dict__ for o in cdist])\n\n \n return cdist","def cluster(self):\n center_index = np.random.choice(range(100), self.K, replace=False)\n self.centers = np.array([self.X[i] for i in center_index])\n self.cluster_sizes = np.zeros(self.K)\n member_of = np.zeros(100, dtype=int)\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\n self.cluster_sizes[0] = 100\n flag = True\n while flag:\n flag = False\n for i, point in enumerate(self.X):\n for j, center in enumerate(self.centers):\n if member_of[i] != j:\n dist = distance.euclidean(point, center)\n if dist < min_dist[i]:\n flag = True\n current = member_of[i]\n self.cluster_sizes[current] -= 1\n self.cluster_sizes[j] += 1\n member_of[i] = j\n min_dist[i] = dist\n if np.count_nonzero(self.cluster_sizes) != self.K:\n return self.cluster()\n self.centers = np.zeros((self.K, 2), dtype='d')\n for i, point in enumerate(self.X):\n center = member_of[i]\n self.centers[center] += point\n for i, center in enumerate(self.centers):\n center /= self.cluster_sizes[i]","def cluster(self):\n\n result_nominatim = self.nominatim()\n try:\n coord = [(float( i['lat'] ), float( i['lon'] )) for i in result_nominatim]\n except:\n return None\n #print( \"coord\", coord )\n kms_per_radian = 6371.0088\n # Augmenter cette valeur augmente le nombre d'éléments dans un cluster et change les résultats\n epsilon = 2 / kms_per_radian\n # Adapter le nombre de clusters (min_sample) au nombre d'entités dans array ?\n db = DBSCAN( eps=epsilon, min_samples=1, algorithm='ball_tree',\n metric='haversine' ).fit( np.radians( coord ) )\n cluster_labels = db.labels_\n #print( \"cluster\", cluster_labels )\n num_clusters = len( set( cluster_labels ) )\n #print( \"num clusters\", num_clusters )\n counts = np.bincount( cluster_labels )\n #print( \"count\", counts )\n maxi = np.argmax( counts )\n #print( \"maxi\", maxi )\n itemindex = np.where( cluster_labels == maxi )[0]\n #print( \"itemindex\", itemindex )\n\n lat: List[float] = [float( result_nominatim[index]['lat'] ) for index in itemindex]\n lon: List[float] = [float( result_nominatim[index]['lon'] ) for index in itemindex]\n\n # on récupère la moyenne des coordonnées du plus gros cluster. Cette moyenne équivaut au centroide :\n # https://gis.stackexchange.com/questions/12120/calculate-midpoint-from-a-series-of-latitude-and-longitude-coordinates\n\n average = {\"lat\": sum( lat ) / len( lat ), \"lon\": sum( lon ) / len( lon )}\n\n #print( list( zip( cluster_labels, [x['display_name'] for x in results] ) ) )\n #print( \"plus proche de moyenne\", closest( results, average ) )\n return closest( result_nominatim, average )","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n points = cluster_list[:]\n \n # n <-- |p|;\n len_points_list = len(points)\n\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \n cluster_centers = []\n temp_cl = points[:]\n \n temp_cl.sort(key=lambda cluster: cluster.total_population())\n for cluster in reversed(temp_cl):\n if len(cluster_centers) < num_clusters:\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\n\n # For number of iterations\n for dummy_var in range(num_iterations):\n # initialize k (num_clusters) empty sets C1, ... Ck;\n cluster_groupings = []\n for index in range(len(cluster_centers)):\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\n # # For each county\n # for j = 0 to n - 1 do\n for index in range(len_points_list):\n # Find the old cluster center that is closest \n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \n min_dist = float('inf')\n nearest_cluster_index = None\n\n for idx, cluster in enumerate(cluster_centers):\n if points[index].distance(cluster) < min_dist:\n min_dist = points[index].distance(cluster)\n nearest_cluster_index = idx\n\n # Add the county to the corresponding new cluster\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\n # Set old clusters equal to new clusters \n # for f = 1 to k do\n for index in range(len(cluster_centers)):\n # muf = center (Cf) // handled with Cluster class built-in method(s)\n cluster_centers[index] = cluster_groupings[index].copy()\n\n # return {C1, C2, ..., Ck}; \n return cluster_groupings","def nearest_cluster_center(point, cluster_centers):\n def sqr_distance_2D(a, b):\n return abs(a.x - b.x) *abs(a.x - b.x) + abs(a.y - b.y) *abs(a.x - b.x) + abs(a.z-b.z)*abs(a.x - b.x)\n min_index = point.group\n min_dist = FLOAT_MAX\n \n for i, cc in enumerate(cluster_centers):\n d = sqr_distance_2D(cc, point)\n if min_dist > d:\n min_dist = d\n min_index = i\n \n return (min_index, min_dist)","def closestCluster(p, centers):\n\tbestIndex = 0\n closest = float(\"+inf\")\n for i in range(len(centers)):\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\n if distance < closest:\n closest = distance\n bestIndex = i\n\treturn bestIndex","def in_xi(self, sample, cluster, cluster_size):\n sum_distance = 0\n for cur_sample in cluster.get_samples():\n if sample.get_s_id() != cur_sample.get_s_id():\n if cur_sample.get_s_id() < sample.get_s_id():\n sum_distance += self.distance_dict[(cur_sample.get_s_id(), sample.get_s_id())]\n elif cur_sample.get_s_id() > sample.get_s_id():\n sum_distance += self.distance_dict[(sample.get_s_id(), cur_sample.get_s_id())]\n return sum_distance / (cluster_size - 1)","def cluster_dpc_knn(token_dict, cluster_num, k=5, token_mask=None):\n with torch.no_grad():\n x = token_dict['x']\n B, N, C = x.shape\n dist_matrix = torch.cdist(x, x) / C ** 0.5\n if token_mask is not None:\n token_mask = token_mask > 0\n dist_matrix = dist_matrix * token_mask[:, None, :] + (dist_matrix.max() + 1) * ~token_mask[:, None, :]\n dist_nearest, index_nearest = torch.topk(dist_matrix, k=k, dim=-1, largest=False)\n density = (-(dist_nearest ** 2).mean(dim=-1)).exp()\n density = density + torch.rand(density.shape, device=density.device, dtype=density.dtype) * 1e-06\n if token_mask is not None:\n density = density * token_mask\n mask = density[:, None, :] > density[:, :, None]\n mask = mask.type(x.dtype)\n dist_max = dist_matrix.flatten(1).max(dim=-1)[0][:, None, None]\n dist, index_parent = (dist_matrix * mask + dist_max * (1 - mask)).min(dim=-1)\n score = dist * density\n _, index_down = torch.topk(score, k=cluster_num, dim=-1)\n dist_matrix = index_points(dist_matrix, index_down)\n idx_cluster = dist_matrix.argmin(dim=1)\n idx_batch = torch.arange(B, device=x.device)[:, None].expand(B, cluster_num)\n idx_tmp = torch.arange(cluster_num, device=x.device)[None, :].expand(B, cluster_num)\n idx_cluster[idx_batch.reshape(-1), index_down.reshape(-1)] = idx_tmp.reshape(-1)\n return idx_cluster, cluster_num","def k_means_clustering(rows, distance=pearson_distance, k=4):\n # Determine the min and max values for each point\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\n\n # Create k RANDOMLY placed centroids\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\n range(k)]\n distances_from_centroids = {}\n last_matches = None\n best_matches = None\n for t in range(100):\n print ('Iteration {}'.format(t))\n best_matches = [[] for i in range(k)]\n\n # Find the centroid that is the closest for each row\n for j in range(len(rows)):\n row = rows[j]\n best_match = 0\n for i in range(k):\n d = distance(clusters[i], row)\n if d < distance(clusters[best_match], row):\n best_match = i\n best_matches[best_match].append(j)\n\n # if the results are the same as last time, then this is complete\n if best_matches == last_matches:\n break\n last_matches = best_matches\n\n # Move the centroids to the average of their members\n for i in range(k):\n avgs = [0.0] * len(rows[0])\n if len(best_matches[i]) > 0:\n for row_id in best_matches[i]:\n for m in range(len(rows[row_id])):\n avgs[m] += rows[row_id][m]\n for j in range(len(avgs)):\n avgs[j] /= len(best_matches[i])\n clusters[i] = avgs\n\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\n # and their respective centroids\n for i in range(k):\n for j in range(len(best_matches[i])):\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\n return best_matches, distances_from_centroids","def iterative_cluster(clusters, points, distance_function, max_iterations=1000):\n point_assignments = {p: 0 for p in points}\n\n for p in points:\n if p not in symmetric_distances:\n print p\n\n for n in range(max_iterations):\n assignment_change = False\n new_clusters = [set() for c in clusters]\n\n for p in points:\n (score, i) = min_argmin(\n lambda i: distance_function(set([p]), clusters[i]),\n range(len(clusters)))\n if point_assignments[p] != i:\n point_assignments[p] = i\n assignment_change = True\n new_clusters[i].add(p)\n\n clusters = new_clusters\n if not assignment_change: break\n\n return sorted_clusters(clusters, distance_function)","def nearest_cluster(X,c):\n K = np.size(c,0)\n idx = np.zeros((np.size(X,0),1))\n arr = np.empty((np.size(X,0),1))\n for i in range(0,K):\n y = c[i]\n temp = np.ones((np.size(X,0),1))*y\n b = np.power(np.subtract(X,temp),2)\n a = np.sum(b,axis = 1)\n a.resize((np.size(X,0),1))\n arr = np.append(arr, a, axis=1)\n arr = np.delete(arr,0,axis=1)\n idx = np.argmin(arr, axis=1)\n return idx","def closestClusterAndDistance(p, centers):\n\tbestIndex = 0\n closest = float(\"+inf\")\n for i in range(len(centers)):\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\n if distance < closest:\n closest = distance\n bestIndex = i\n return (bestIndex, closest)","def clusterAndDistance(self, data):\n\t\treturn closestClusterAndDistance(data, self.centers)","def distance_scipy_spatial(z, k=4, metric='euclidean'):\n d = scipy.spatial.distance.pdist(z, metric)\n d = scipy.spatial.distance.squareform(d)\n # k-NN graph.\n idx = np.argsort(d)[:, 1:k + 1]\n d.sort()\n d = d[:, 1:k + 1]\n return d, idx","def __find_nearest_centroids(self, data):\n \n self.clusters = np.array([]) \n for i, d in enumerate(data):\n min_dist = np.inf\n self.clusters = np.concatenate((self.clusters, np.array([-1])))\n for j, c in enumerate(self.centroids):\n dist = self.__compute_distance(d, c)\n if min_dist > dist:\n min_dist = dist\n self.clusters[i] = j","def clustering(cluster_list):\n while len(cluster_list) > 1:\n x = 0\n y = 0\n distance_min = 10\n\n for i in range(0,len(cluster_list)):\n\n for j in range(0,len(cluster_list)):\n\n if i != j:\n distance = cluster_list[i].linkage(cluster_list[j])\n if distance < distance_min:\n x = i\n y = j\n distance_min = distance\n \n \n clusX = cluster_list[x]\n clusY = cluster_list[y]\n cluster_list.pop(cluster_list.index(clusX))\n cluster_list.pop(cluster_list.index(clusY))\n\n cluster_list.append(Cluster(clusX,clusY))\n return cluster_list[0]","def move_centroids(centroids, x, assigned_clusters):\n\n return np.array([1 / np.sum(assigned_clusters == k) * np.sum(x[assigned_clusters == k], axis=0)\n for k in range(centroids.shape[0])])","def get_ranked_points(zpoints, dsq):\n pos_map = calc_positions(zpoints, dsq)\n rpoints = calc_ranked_points(pos_map, dsq)\n return rpoints","def out_xi(self, sample, cluster):\n min_distance = 0\n first = True\n for cur_cluster in self.cluster_lst:\n sum_distance = 0\n if cur_cluster.get_c_id() != cluster.get_c_id():\n for cur_sample in cur_cluster.get_samples():\n if cur_sample.get_s_id() < sample.get_s_id():\n sum_distance += self.distance_dict[(cur_sample.get_s_id(), sample.get_s_id())]\n elif cur_sample.get_s_id() > sample.get_s_id():\n sum_distance += self.distance_dict[(sample.get_s_id(), cur_sample.get_s_id())]\n cluster_size = len(cur_cluster.get_samples())\n temp_distance = sum_distance / cluster_size\n if first:\n min_distance = temp_distance\n first = False\n min_distance = min(temp_distance, min_distance)\n return min_distance","def find_centroid_for_each(self):","def knn_classify_point(point, data, k, distance_metric):\n k_closest_points = get_k_closest_points(point, data, k, distance_metric)\n classification_counts = {}\n for item in k_closest_points:\n classification_type = item.classification\n if classification_type not in classification_counts:\n classification_counts[classification_type] = 0\n else:\n classification_counts[classification_type] += 1\n classification_counts = sorted(classification_counts, key = classification_counts.get)\n return classification_counts[-1]","def kmeans(boxes, k, dist=np.median,seed=1):\n rows = boxes.shape[0]\n distances = np.empty((rows, k)) ## N row x N cluster\n last_clusters = np.zeros((rows,))\n np.random.seed(seed)\n # initialize the cluster centers to be k items\n clusters = boxes[np.random.choice(rows, k, replace=False)]\n aveIOU=0.0\n while True:\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\n for icluster in range(k):\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n nearest_clusters = np.argmin(distances, axis=1)\n\n for i in range(rows ):\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\n aveIOU=aveIOU/rows\n\n\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\n if (last_clusters == nearest_clusters).all():\n break\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters,nearest_clusters,distances,aveIOU","def rank() -> int:\n return dist.get_rank() if dist.is_initialized() else 0","def kmeans_clustering(cluster_list, num_clusters, num_iterations):\n\n # position initial clusters at the location of clusters with largest populations\n \n cluster_n = len(cluster_list)\n\n miu_k = sorted(cluster_list,\n key=lambda c: c.total_population())[-num_clusters:]\n miu_k = [c.copy() for c in miu_k]\n\n # n: cluster_n\n # q: num_iterations\n for _ in xrange(num_iterations):\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\n # put the node into closet center node\n\n for jjj in xrange(cluster_n):\n min_num_k = 0\n min_dist_k = float('inf')\n for num_k in xrange(len(miu_k)):\n dist = cluster_list[jjj].distance(miu_k[num_k])\n if dist < min_dist_k:\n min_dist_k = dist\n min_num_k = num_k\n\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\n\n # re-computer its center node\n for kkk in xrange(len(miu_k)):\n miu_k[kkk] = cluster_result[kkk]\n\n return cluster_result","def find_nearest_neighbors(p, points, k=5):\n dist = np.zeros(points.shape[0])\n for i in range(len(dist)):\n dist[i] = distance(p, points[i])\n ind = np.argsort(dist)\n return ind[0:k]","def _calculate_nearest_cluster(self, pixels, cluster_labels):\n\n # assign pixel (RGB) to nearest cluster label (index)\n for index, rgb in pixels:\n rgb_vector = np.tile(rgb, (self.k, 1))\n self._labels[index] = np.argmin(\n self._euclid_distance(rgb_vector, self._clusters), axis=0)\n\n if cluster_labels[self._labels[index]] is None:\n cluster_labels[self._labels[index]] = list()\n\n cluster_labels[self._labels[index]].append(rgb)\n\n return cluster_labels","def predict_cluster(point):\n # assuming point belongs to clusters that were computed by fit functions\n return cluster[tuple(point)]","def get_k_closest_points(point, data, k, distance_metric):\n points_and_scores = []\n k_closest_points = []\n for item in data:\n item_score = distance_metric(point, item)\n points_and_scores.append([item, item_score])\n points_and_scores = sorted(points_and_scores, key = lambda item:(item[1], item[0].coords))\n for i in range(k):\n k_closest_points.append(points_and_scores[i][0])\n return k_closest_points","def makeCluster(self):\n for i in range(self.k):\n #vector of length total users, pick random number 1-5\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\n memberList = []\n self.membership.append(memberList)\n self.centroids = np.round(self.centroids)\n\n for movie in self.dictionary.keys():\n #Finds the index of the closest centroid\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\n newVector = []\n newVector.append(movie)\n #Add the movie to the list of members of the closest centroid\n self.membership[closest].append(newVector)\n self.recalculateCentroid(self.membership[closest], closest)","def get_k_neighbors(self, point):\n nn = []\n nnl = []\n for p,l in zip(self.train_features,self.train_labels):\n d = self.distance_function(p,point)\n dl_pair = (d,l)\n nn.append(dl_pair)\n nn = sorted(nn, key = lambda x: x[0])\n for i in range(0,self.k):\n nnl.append(nn[i][1])\n return nnl\n raise NotImplementedError","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def calc_ranked_points(pos_map, dsq_list):\n\n rpoints = {}\n\n for pos, zones in pos_map.items():\n # remove any that are dsqaulified\n # note that we do this before working out the ties, so that any\n # dsq tie members are removed from contention\n zones = [ z for z in zones if z not in dsq_list ]\n if len(zones) == 0:\n continue\n\n # max points is 4, add one because pos is 1-indexed\n points = (4 + 1) - pos\n # Now that we have the value for this position if it were not a tie,\n # we need to allow for ties. In case of a tie, the available points\n # for all the places used are shared by all those thus placed.\n # Eg: three first places get 3pts each (4+3+2)/3.\n # Rather than generate a list and average it, it's quicker to just\n # do some maths using the max value and the length of the list\n points = points - ( (len(zones) - 1) / 2.0 )\n for z in zones:\n rpoints[z] = points\n\n # those that were dsq get 0\n for z in dsq_list:\n rpoints[z] = 0.0\n\n return rpoints","def kmeans(matrix, k) :\n clusters = [0 for i in range(k)]\n lastcluster=[0 for i in range(k)]\n min_=0\n max_=matrix.__len__()\n print \"len\",max_\n cluster = [0 for i in range(k)]\n for i in range(k) :\n\n cluster[i]=int(random.random() * (max_ - min_) + min_)\n clusters[i]=matrix[cluster[i]]\n lastcluster[i]=matrix[cluster[i]]\n #print cluster[i],clusters[i]\n\n lastmatchs = [ [] for i in range(k)]\n\n \"\"\" initial the round is 100\"\"\"\n rounds = 100\n while rounds > 0 :\n matchs = [ [] for i in range(k)]\n print 'round \\t',rounds\n for i in range(len(matrix)) :\n bestmatch_cluster = None\n\n min_distance = 100000\n for j in range(k) :\n dis = pearson_distance(clusters[j], matrix[i])\n if dis < min_distance :\n min_distance = dis\n bestmatch_cluster = j\n matchs[bestmatch_cluster].append(i)\n\n print_matchs(matchs)\n #print_matchs(lastmatchs)\n\n\n\n if matchs == lastmatchs : break\n #if cluster== lastcluster :break\n lastmatchs = [[ item for item in matchs[i] ] for i in range(k)]\n\n #move the centroids to the average of their members\n for j in range(k) :\n avg = [0.0 for i in range(len(matrix[0])) ]\n for m in matchs[j] :\n vec = matrix[m]\n for i in range(len(matrix[0])) :\n avg[i] += vec[i]\n avg = [ item / len(matrix[0]) for item in avg]\n clusters[j] = avg\n lastcluster=clusters\n\n\n rounds -= 1\n print \"rounds:\",100-rounds\n print \"result:\"\n for i in matchs:\n print i","def calOffsetOfCluster(color_cluster, cluster):\n offset = 0\n for cc in color_cluster:\n l = len(cluster)\n for i in range(l):\n offset_temp = math.pow( (cc[1][i] - cluster[i]), 2 )\n offset += offset_temp\n return offset","def addToTheCluster(pointIdx,AllPoints,Allneighbors,DistanceRanks,cluster,visited,eps,minPts):\r\n point = AllPoints[pointIdx]\r\n cluster.addToCluster(point)\r\n point.clusterId = 1\r\n\r\n temp = Allneighbors[pointIdx]\r\n count = 0\r\n for points in temp:\r\n if visited[points] == 0:\r\n visited[points] =1\r\n neighbors = findNeighbors(AllPoints[points],DistanceRanks,eps)\r\n Allneighbors[points] = neighbors\r\n if len(neighbors) >= minPts:\r\n temp += neighbors\r\n\r\n if AllPoints[points].clusterId == -1:\r\n AllPoints[points].clusterId = 1\r\n cluster.addToCluster(AllPoints[points])\r\n count+=1","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def kmeans(boxes, k, dist=numpy.median, seed=1):\n rows = boxes.shape[0]\n distances = numpy.empty((rows, k)) ## N row x N cluster\n last_clusters = numpy.zeros((rows,))\n\n numpy.random.seed(seed)\n\n # initialize the cluster centers to be k items\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\n\n while True:\n # Step 1: allocate each item to the closest cluster centers\n for icluster in range(k): # I made change to lars76's code here to make the code faster\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\n\n nearest_clusters = numpy.argmin(distances, axis=1)\n\n if (last_clusters == nearest_clusters).all():\n break\n\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\n for cluster in range(k):\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\n last_clusters = nearest_clusters\n\n return clusters, nearest_clusters, distances","def cluster_feature(feature_mat, k):\n whitened = whiten(feature_mat.transpose())\n centroid, distortion = kmeans(whitened, k)\n\n return centroid, distortion","def cluster_index_2(X):\n \n global_mean = X.mean(axis=0)\n\n sum_squared_distances = (((X - global_mean)**2).sum(axis = 1)).sum()\n #Sum of squared distances of each sample from the global mean\n \n centroids, labels, inertia = k_means(X, 2)\n\n ci = inertia / sum_squared_distances\n\n return ci , labels","def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\n\n # Your code here. You should also change the return value.\n\n def _initiate_random_centroids(all_features, vocab_size):\n \"\"\"\n Initiate random centroids in the range of input\n\n :param all_features:\n :param vocab_size:\n :return:\n \"\"\"\n centroids = []\n # 1) Genereate points for initial centroids\n\n min_feat = np.ones(all_features[0].size)*np.inf\n max_feat = np.zeros(all_features[0].size)\n\n for a in all_features:\n for p in range(len(a)):\n if a[p] < min_feat[p]:\n min_feat[p] = a[p]\n else:\n if a[p] > max_feat[p]:\n max_feat[p] = a[p]\n\n\n for _ in range(vocab_size):\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\n max_feat-min_feat) + min_feat\n centroids.append(random_vector.flatten())\n\n return np.array(centroids)\n\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\n \"\"\"\n Assign vectors to nearest centroids\n\n :param all_features:\n :param centroid:\n :return:\n \"\"\"\n #TODO: sprawdz co lepiej dziala\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\n #new_centroid_coor = centroid\n new_centroid_counter = np.zeros(len(centroid))\n\n dist = pdist(centroid, all_features)\n #min_dist = dist.min(axis=0)\n min_dist_index = dist.argmin(axis=0)\n\n for x in range(len(min_dist_index)):\n id = min_dist_index[x]\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\n all_features[x])\n new_centroid_counter[id] += 1\n\n new_centroid_coor_out = []\n for i in range(len(new_centroid_coor)):\n if new_centroid_counter[i] == 0:\n new_centroid_coor_out.append(centroid[i])\n else:\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\n\n return np.array(new_centroid_coor_out), new_centroid_counter\n\n\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\n \"\"\"\n Check convergence confition\n\n :param old_centroids:\n :param new_centroids:\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\n :return:\n \"\"\"\n for i in range(len(old_centroids)):\n dist = euclidean(old_centroids[i], new_centroids[i])\n if dist > epsilon:\n return False\n\n return True\n\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\n \"\"\"\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\n\n :param new_centroids:\n :param centroid_counter:\n :param threshold:\n :return:\n \"\"\"\n\n out_centroids = []\n for n in range(len(new_centroids)):\n if centroid_counter[n] > threshold:\n out_centroids.append(new_centroids[n])\n out_centroids = np.array(out_centroids)\n return out_centroids\n\n #MAIN\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\n\n for _ in range(max_iter):\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\n\n if if_convergenced == True:\n # return centroids if algorithm is converged\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids\n old_centroids = new_centroids\n\n # return centroids if reached max_iter\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\n return new_centroids","def initiateCentroid(data_points, centroids, k):\n #Create empty list in list (amount is k)\n AvgCentroids = [[] for i in range(k)]\n\n #For each datapoint in all datapoints\n for dp in data_points:\n dis = []\n #For each centroid in centroids\n for c in range(len(centroids)):\n #Calculate the euclidean distance between those points and append\n #to distance list\n dis.append(calcEuclideanDistance(dp, centroids[c]))\n \n #Get the smallest value of the list and the index\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\n\n #The index of the smallest value is the index where it will be added\n #to the avgCentroids list. So it represents the number of the cluster\n AvgCentroids[idx].append(dp)\n \n return AvgCentroids","def classify_point(self, point):\n mindistance = float(\"inf\")\n for (label, centroid) in self.labelled_centroids:\n distance = np.linalg.norm(centroid - point)\n if distance < mindistance:\n mindistance = distance\n closest_centroid_label = label\n return closest_centroid_label","def _kneighbors_reduce_func(self, dist, start, n_neighbors, return_distance):\n sample_range = np.arange(dist.shape[0])[:, None]\n neigh_ind = np.argpartition(dist, n_neighbors - 1, axis=1)\n neigh_ind = neigh_ind[:, :n_neighbors]\n # argpartition doesn't guarantee sorted order, so we sort again\n neigh_ind = neigh_ind[sample_range, np.argsort(dist[sample_range, neigh_ind])]\n if return_distance:\n if self.effective_metric_ == \"euclidean\":\n result = np.sqrt(dist[sample_range, neigh_ind]), neigh_ind\n else:\n result = dist[sample_range, neigh_ind], neigh_ind\n else:\n result = neigh_ind\n return result","def _compute_dist(self, K, dist, within_distances, update_within):\r\n\r\n sw = self.sample_weight_\r\n\r\n for j in xrange(self.n_clusters):\r\n mask = self.labels_ == j\r\n if np.sum(mask) == 0:\r\n raise ValueError(\"Empty cluster found, try smaller n_cluster.\")\r\n\r\n denom = sw[mask].sum()\r\n denomsq = denom * denom\r\n if update_within:\r\n KK = K[mask][:, mask] \r\n dist_j = np.sum(np.outer(sw[mask], sw[mask]) * KK / denomsq)\r\n within_distances[j] = dist_j\r\n dist[:, j] += dist_j\r\n else:\r\n dist[:, j] += within_distances[j]\r\n\r\n dist[:, j] -= 2 * np.sum(sw[mask] * K[:, mask], axis=1) / denom #calculating distance of each point from centroid of cluster j by finding \r\n #diff. b/w centroid of cluster j & similarity of it with points in cluster j\r","def computeKMeans(self, points, k):\n centroids = self.init_centroids(points,k)\n \n for i in range(5):\n closest = self.closestCentroids(points,centroids)\n centroids = self.updateCentroids(points, closest ,centroids)\n\n return centroids","def __move_centroids(self, data):\n \n for i in range(len(self.centroids)):\n members_cluster = data[self.clusters == i]\n self.centroids[i] = np.sum(members_cluster, axis=0) / (len(members_cluster) + self.epsilon)","def kmean(X,initial_centroids,max_iters):\n m = np.size(X,0)\n K = np.size(initial_centroids,0)\n centroids = initial_centroids\n idx = np.zeros((m,1))\n for i in range(1,max_iters):\n idx = nearest_cluster(X,centroids)\n centroids = update_centroids(X,idx,K)\n return centroids,idx","def findClusters(data):\n\tcentroids = data[0, None]\n\tmin_R = 0.1\n\n\tfor _ in range(8):\n\t\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\t\tpotentials = (1 / dists).sum(axis=1)\n\n\t\tnew_c_idx = np.argmin(potentials)\n\n\t\tif np.min(dists[new_c_idx]) < min_R:\n\t\t\t# if this is close to an existing centroid, stop finding centroids\n\t\t\tbreak\n\n\t\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\n\n\tax.scatter(*centroids.T, color='tab:orange')\n\n\t# run a single k-means to find the centroid of each cluster\n\tk = centroids.shape[0]\n\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\n\tclosest_centroid = np.argmin(dists, axis=-1)\n\n\tfor n in range(k):\n\t\tnew_centroid = data[closest_centroid == n].mean(axis=0)\n\t\tcentroids[n] = new_centroid\n\tprint(centroids)\n\tax.scatter(*centroids.T, color='tab:blue')","def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\n # Get initial centers\n n_samples, n_features = len(X), 2\n init_ids = _get_init_centers(n_clusters, X)\n if verbose:\n print('Initial centers are: {}'.format(init_ids))\n centers = init_ids\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\n cc, swapped = 0, True\n while True:\n swapped = False\n for i in range(n_samples):\n if i not in centers:\n for j in range(len(centers)):\n centers_ = deepcopy(centers)\n centers_[j] = i\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\n if tot_cost_ < tot_cost:\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\n centers = centers_\n swapped = True\n if verbose:\n print('Change centers to {}'.format(centers))\n if cc > max_iter:\n if verbose:\n print('End Searching by reaching maximum iteration')\n break\n if not swapped:\n if verbose:\n print('End Searching by no swaps')\n break\n cc += 1\n return centers, members, costs, tot_cost, dist_mat","def k_neighbors(self, unknown, dataset, k):\n distances = []\n for title in dataset:\n point = dataset[title]\n distance_to_point = distance.euclidean_distance(point, unknown)\n distances.append([distance_to_point, title])\n distances.sort()\n neighbors = distances[0:k]\n return neighbors","def run(self, points, K):\n # Get size\n D, N = points.shape\n\n # DxK array initialiezd with random points\n centroids = points[:, np.random.permutation(N)[:K]]\n\n # Assigments 1xN array\n labels = np.zeros(N)\n\n for it in np.arange(self.niter):\n # 1. Compute distance to all cluster\n #v1 dirty\n distances = np.zeros([K, N])\n for n in np.arange(N):\n for k in np.arange(K):\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \n\n # 2. Update assigments\n # v1 dirty\n for n in np.arange(N):\n kmin = 0\n for k in np.arange(1, K):\n if distances[k, n] <= distances[kmin, n]:\n kmin = k\n labels[n] = kmin\n # v2 quicker\n #labels = np.argmin(distances, axis=1)\n\n # 3. Update mean\n for k in np.arange(K):\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\n\n return centroids, labels","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def __update_clusters(self, medoids):\r\n\r\n self.__belong = [0] * len(self.__pointer_data)\r\n self.__clusters = [[] for i in range(len(medoids))]\r\n for index_point in range(len(self.__pointer_data)):\r\n index_optim = -1\r\n dist_optim = 0.0\r\n\r\n for index in range(len(medoids)):\r\n dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])\r\n\r\n if (dist < dist_optim) or (index is 0):\r\n index_optim = index\r\n dist_optim = dist\r\n\r\n self.__clusters[index_optim].append(index_point)\r\n self.__belong[index_point] = index_optim\r\n\r\n # If cluster is not able to capture object it should be removed\r\n self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]","def kmeans(points, clusters, threshold=1e-10):\n diff = threshold + 1.0\n while diff > threshold:\n _empty_clusters(clusters)\n for pt in points:\n min_dis = sys.maxint\n min_cls = None\n for clst in clusters:\n dis = pt.distance(clst.centroid)\n if min_dis > dis:\n min_dis = dis\n min_cls = clst\n min_cls.add_point(pt)\n diff = 0.0\n\n for clst in clusters:\n diff += clst.update()","def rmsd_cluster(input, ref, output, clusters):\n ifs = oemolistream()\n if not ifs.open(input):\n OEThrow.Fatal(\"Unable to open %s for reading\" % input)\n poses = list()\n mol = OEMol()\n while OEReadMolecule(ifs, mol):\n mol_copy = OEMol(mol)\n #print(dir(mol_copy))\n #print(mol_copy.NumConfs())\n for conf in mol_copy.GetConfs():\n poses.append(conf)\n ifs.close()\n print(\"%d poses read\" % len(poses))\n\n # Create a list of centroids, starting with first molecule.\n centroids = list()\n\n # Make first pose our first centroid.\n centroids.append(poses.pop(0))\n if int(clusters) < len(poses):\n print(\"Will return %s poses...\" % clusters)\n else:\n print(\"Will return %s poses...\" % (len(poses)+1))\n while len(centroids) < int(clusters) and len(poses)>0:\n print(len(centroids))\n # Compute distance from all poses to closest centroid.\n min_rmsd = numpy.zeros([len(poses)])\n for (pose_index, pose) in enumerate(poses):\n centroids_rmsds = [OERMSD(pose, centroid) for centroid in centroids]\n min_rmsd[pose_index] = min(centroids_rmsds)\n # Find pose that is farthest away from all current centroids.\n farthest_pose_index = min_rmsd.argmax()\n print(\"Farthest pose is %d at %f A away from centroids\" % (farthest_pose_index, min_rmsd[farthest_pose_index]))\n # Move farthest pose to centroids.\n centroids.append(poses.pop(farthest_pose_index))\n # Write out all centroids.\n ofs=oemolostream()\n if not ofs.open(output):\n OEThrow.Fatal(\"Unable to open %s for writing\" % itf.GetString(\"-o\"))\n for mol in centroids:\n #OEWritePDBFile(ofs, mol)\n OEWriteMolecule(ofs, mol)\n\n print(\"Done!\")\n\n return 0","def calculate_medoids(self, distances, k=6):\n m = distances.shape[0] # number of points\n\n # Pick k random medoids.\n curr_medoids = np.array([-1] * k)\n while not len(np.unique(curr_medoids)) == k:\n curr_medoids = np.array([random.randint(0, m - 1)\n for _ in range(k)])\n # Doesn't matter what we initialize these to.\n old_medoids = np.array([-1] * k)\n new_medoids = np.array([-1] * k)\n\n # Until the medoids stop updating, do the following:\n while not ((old_medoids == curr_medoids).all()):\n # Assign each point to cluster with closest medoid.\n clusters = self.assign_points_to_clusters(curr_medoids, distances)\n\n # Update cluster medoids to be lowest cost point.\n for curr_medoid in curr_medoids:\n cluster = np.where(clusters == curr_medoid)[0]\n new_medoids[curr_medoids == curr_medoid] = self.compute_new_medoid(\n cluster, distances)\n\n old_medoids[:] = curr_medoids[:]\n curr_medoids[:] = new_medoids[:]\n\n return clusters, curr_medoids","def pc_cluster(data, clusters):\n dist = MorningstarPCA.pc_distance(data, clusters)\n return MorningstarPCA.get_column_with_min_value(dist)","def clusters_distance(cluster1, cluster2):\n return max([euclidean_distance(point1, point2) for point1 in cluster1 for point2 in cluster2])","def __update_clusters(self, medoids):\n\n self.__belong = [0] * len(self.__pointer_data)\n self.__clusters = [[] for _ in range(len(medoids))]\n for index_point in range(len(self.__pointer_data)):\n index_optim = -1\n dist_optim = 0.0\n\n for index in range(len(medoids)):\n dist = euclidean_distance_square(\n self.__pointer_data[index_point],\n self.__pointer_data[medoids[index]],\n )\n\n if (dist < dist_optim) or (index == 0):\n index_optim = index\n dist_optim = dist\n\n self.__clusters[index_optim].append(index_point)\n self.__belong[index_point] = index_optim\n\n # If cluster is not able to capture object it should be removed\n self.__clusters = [\n cluster for cluster in self.__clusters if len(cluster) > 0\n ]","def closest_cluster(cluster_averages, example):\n\n # just do a normal search for a minimum\n best_index = -1\n best_distance = 10000000\n for (i, cluster_average) in enumerate(cluster_averages):\n distance = dist(cluster_average, example)\n\n # easy trick to get a single comparison and negation to check for\n # invalid number too\n if distance < best_distance:\n best_index = i\n best_distance = distance\n\n return best_index","def k_means(m: np.array, k: int, max_iter: int):\n d = m.shape[1]\n starting_points = {\n i : np.array([np.random.uniform(-1.0, 1.0) for _ in range(d)])\n for i in range(k)\n }\n\n for iteration in range(max_iter):\n assigned_cluster = []\n vecs_closest_to_k = defaultdict(list)\n for vec in m:\n closest_k = get_shortest_k(vec, starting_points)\n assigned_cluster.append(closest_k)\n vecs_closest_to_k[closest_k].append(vec)\n starting_points = {\n i: starting_points[i] if i not in vecs_closest_to_k else np.average(np.array(vecs_closest_to_k[i]), axis=1)\n for i in range(k)\n }\n\n return m, assigned_cluster","def _relocate_clusters(self, cluster_labels):\n for cluster_label in range(self.k):\n if cluster_labels[cluster_label] is not None:\n # mean of the pixels assigned to cluster\n p_sum, p_count = np.asarray(\n cluster_labels[\n cluster_label\n ]).sum(axis=0), len(cluster_labels[cluster_label])\n self._clusters[cluster_label] = p_sum / p_count","def find_nearest_neighbors(p, points, k):\n\timport numpy as np\n\tdistances = np.zeros(points.shape[0])\n\tfor i in range(len(distances)):\n\t\tdistances[i] = distance(p,points[i])\n\tind = np.argsort(distances)\n\treturn ind[0:k]","def agglomerative_clustering_in_pretopological_space(X, k, linkage, measure):\n\n # validating the X data\n if X.ndim != 2 or X.shape[0] < 1 or X.shape[1] < 1:\n raise ValueError('Data must be a valid 2D matrix.')\n\n # validating the amount of clusters\n if k <= 0:\n raise ValueError('The amount of clusters must be positive.')\n\n # validating the linkage method\n if linkage not in LINKAGE_LIST:\n raise ValueError('Unknown linkage method.')\n\n # the specified metric must be one of the implemented measures\n if measure not in measures.measure_to_function:\n raise ValueError('Unknown dissimilarity measure.')\n\n # getting the metric function\n d = measures.measure_to_function[measure]\n\n # build distance/dissimilarity matrix\n dm = squareform(pdist(X, d))\n\n # returning the partition obtained for agglomerative clustering in the built space\n return agglomerative_clustering_in_some_space(dm, k, linkage=linkage, affinity='precomputed')","def knn(p, k, x, t):\r\n\r\n # Number of instances in data set\r\n N = x.shape[0]\r\n\r\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\r\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\r\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\r\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\r\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\r\n\r\n\r\n #top_class = 0\r\n\r\n return top_class","def predict(self, test_data):\n if self.centroids_.shape[0]==0:\n raise ValueError(\"No centroids present. Run KMeans.fit first.\")\n\n print test_data.shape\n part_of_cluster=np.zeros(test_data.shape[0])\n for i in range(test_data.shape[0]):\n dists=[]\n for c in range(self.centroids_.shape[0]):\n # compute distance between current train_data instance and each cluster\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\n \n # assign point to cluster with minimal distance\n part_of_cluster[i]=dists.index(min(dists))\n\n return part_of_cluster","def find_closest_cluster(\n pose: np.ndarray, clusters: Sequence[Cluster]\n) -> Optional[int]:\n # Maybe later we might want to check wrt. the centroid instead of all the\n # elements, depending on the performances.\n for cluster_idx, cluster in enumerate(clusters):\n for clustered_pose in cluster.elements:\n if pose_close(pose, clustered_pose):\n # Just assign the first cluster that satisfies the reqs.\n return cluster_idx\n\n return None","def mean_min_distance_to_cluster(actual_activation,\n cluster_activation, n_cluster_samples):\n if cluster_activation.ndim == 4:\n actual_activation = actual_activation.dimshuffle('x',0,1,2)\n squared_distances = T.mean(T.square(cluster_activation -\n actual_activation), axis=(1,2,3))\n elif cluster_activation.ndim == 2:\n actual_activation = actual_activation.dimshuffle('x',0)\n squared_distances = T.mean(T.square(cluster_activation -\n actual_activation), axis=(1,))\n \n \n squared_distances_sorted = T.sort(squared_distances)\n \n distance = T.mean(squared_distances_sorted[:n_cluster_samples])\n return distance","def get_rank(self) -> int:\n return dist.get_rank()","def splitCluster(self, cluster):\n\t\tmaxValue = self.getMaxValue(self.clusterList[cluster])\n\t\tminValue = self.getMinValue(self.clusterList[cluster])\n\t\tmidValue = round(maxValue - ((maxValue - minValue) / 2))\n\n\t\t# Create a set of centroid\n\t\tfirstCentroid = random.randint(minValue, midValue)\n\t\tsecondCentroid = random.randint(midValue, maxValue)\n\n\t\tcpyCluster = self.clusterList[cluster]\n\t\tnextName = str(len(self.clusterList))\n\t\tself.clusterList[cluster] = []\n\t\tself.clusterList[nextName] = []\n\n\t\tfor value in cpyCluster:\n\t\t\tif abs(value - firstCentroid) < abs(value - secondCentroid):\n\t\t\t\tself.clusterList[cluster].append(value)\n\t\t\telse:\n\t\t\t\tself.clusterList[nextName].append(value)\n\t\t\tpass\n\t\tpass\n\t\tprint(self.clusterList)","def _nearest_cluster_distance(distances_row, labels, i):\n label = labels[i]\n b = np.min([np.mean(distances_row[labels == cur_label])\n for cur_label in set(labels) if not cur_label == label])\n return b","def cluster(self):\r\n\t\tself.clusterer.fit(self.koopman_feature_array)\r\n\t\tself.labels = self.clusterer.labels_\r\n\t\tfor j in range(max(self.labels)+1):\r\n\t\t\tself.koop_cluster_list.append([self.koop_list[i] for i in range(len(self.labels)) if self.labels[i] == j])\r\n\t\t\tself.koop_cluster_memb_prob_list.append([self.clusterer.probabilities_[i] for i in range(len(self.labels)) if self.labels[i] == j])","def calc_sw(X, cluster_labels):\n\n labels = np.array(cluster_labels)\n labels_set = set(cluster_labels)\n n_labels = len(labels_set)\n\n Sw = []\n for label in labels_set:\n # Loop through each cluster and calculate within cluster distance\n pairs = np.where(labels == label)\n pairs_distance = pdist(X[pairs[0]])\n within_cluster_distance = np.sum(pairs_distance, axis=0)\n Sw.append(within_cluster_distance)\n\n return np.sum(Sw)","def get_cluster_to_split(clusters):\n\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]","def assign_to_current_mean(img: np.ndarray, clustermask: np.ndarray) -> float:\n\n rows, cols = img.shape[:2]\n distances = np.zeros((numclusters, 1))\n overall_dist = 0\n\n for i in range(rows):\n for j in range(cols):\n distances = distance(img[i, j, :]) # returned shape: (numclusters, 1)\n \n k = np.argmin(distances) # closest cluster\n clustermask.itemset((i, j), k) # update cluster mask\n overall_dist += distances[k, 0] # sum distance\n\n return overall_dist","def density_based_cluster(R, clusters):\n c_points = {}\n i = 0\n for cluster in clusters:\n points = set()\n for attr in cluster:\n for point in R[attr]:\n points.add(point)\n c_points[i] = points\n i += 1\n return c_points","def get_clusters(self,points):\n self.points = points\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\n ##self.hull = \n return self.__dabest","def discover_new_cluster(\n self,\n n: int,\n items: List[str],\n embeddings: np.ndarray,\n weights: Optional[List[float]] = None,\n k_neighbours: int = 10,\n ) -> List[Tuple[float, str]]:\n # Get all cross-similarities\n similarity = cosine_similarity(embeddings)\n \n # Calculate scores for every row\n scores = []\n sorted_idx = similarity.argsort(axis=1) # Get sorted indices (sort on corresponding values)\n for i, (item, weight) in enumerate(zip(items, weights)):\n # No point in calculating score if weight equals zero\n if not weight:\n scores.append(0)\n continue\n \n # Assign score of zero if labeled entity is in K nearest neighbours\n top_indices = sorted_idx[i, -k_neighbours:]\n if any(items[idx] in self._clusters.keys() for idx in top_indices):\n scores.append(0)\n \n # Use accumulated similarity of K nearest neighbours as score\n else:\n scores.append(weight * similarity[i, top_indices].sum())\n \n # Filter out the highest score item\n return list(sorted(zip(scores, items), key=lambda x: x[0], reverse=True))[:n]","def kMeans(d, k):\n #First get the random centroids from the data\n newCentroids = getRandomCentroids(d, k)\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\n\n #Get the clusters from these random centroids\n clusters = initiateCentroid(d, newCentroids, k)\n oldCentroids = []\n\n counter = 0\n #While the old centroids are not equal to the new ones\n while oldCentroids != newCentroids:\n #old is equal to new\n oldCentroids = newCentroids\n #Calculate the new centroids\n k, newCentroids = calcCentroids(d, clusters)\n #Calculate the new clusters\n clusters = initiateCentroid(d, newCentroids, k)\n #Count how many iterations\n counter += 1\n\n return counter, clusters","def move_centroids(self, labelled_clusters):\n new_centroids = []\n # print(\"Cluster size\", end=\"\\t\")\n for cluster in labelled_clusters:\n new_centroids.append(self.mean_cluster(cluster))\n # print(len(cluster), end=\"\\t\" )\n # print(\"\\n\")\n return new_centroids","def grow_cluster(self):\n # Need a new list to store cluster points\n new_cluster_pts = []\n\n # Loop through the active points in the perimeter, add the point the cluster with probability p_init\n active_perimeter = [k for k, v in self.perimeter.items() if bool(v)]\n for pt in active_perimeter:\n if self.p >= np.random.rand():\n new_cluster_pts.append(pt)\n else:\n # self.cluster[pt] = False\n self.perimeter[pt] = False\n\n # Check if there are no new points being added to the cluster\n if len(new_cluster_pts) == 0:\n self.stopped_growing = True\n return False\n\n # Loop through the new cluster points and add their nearest neighbors to the perimeter\n for pt in new_cluster_pts:\n if pt[0] in range(0, self.N) and pt[1] in range(0, self.N):\n self.cluster[pt] = True\n self.perimeter[pt] = False\n self.no_particles += 1\n self.world[pt[1], pt[0]] = 1\n self.add_perimeter(pt)\n else:\n self.reached_end = True\n return False","def cluster(r: np.ndarray):\n return np.argmax(r, axis=0)","def cluster(players_df, columns):\n\toptimal_n=None\n\toptimal_clusters=None\n\toptimal_clusterer=None\n\toptimal_silhouette=-99\n\tfor n in range(2,9):\n\t\tclusterer=KMeans(n_clusters=n)\n\t\tcluster_labels=clusterer.fit_predict(players_df[columns])\n\t\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\n\t\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\n\t\tif avg_silhouette > optimal_silhouette:\n\t\t\toptimal_silhouette=avg_silhouette\n\t\t\toptimal_clusterer=clusterer\n\t\t\toptimal_clusters=cluster_labels\n\t\t\toptimal_n=n\n\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\n\tclusters = {n: [] for n in range(optimal_n)}\n\tfor i, label in enumerate(optimal_clusters):\n\t\tclusters[label].append(\n\t\t\tdict(\n\t\t\t\tplayer_id=players_df.iloc[i]['PERSON_ID'],\n\t\t\t\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\n\t\t\t\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\n\t\t\t\t)\n\t\t\t)\n\treturn clusters","def euclidean_cluster_extract(points, tolerance=2, min_cluster_size=20, max_cluster_size=25000):\n filtered_points = pclpy.pcl.segmentation.EuclideanClusterExtraction.PointXYZ()\n kd_tree = pclpy.pcl.search.KdTree.PointXYZ()\n points_to_cluster = pclpy.pcl.PointCloud.PointXYZ(points)\n \n kd_tree.setInputCloud(points_to_cluster)\n filtered_points.setInputCloud(points_to_cluster)\n filtered_points.setClusterTolerance(tolerance)\n filtered_points.setMinClusterSize(min_cluster_size)\n filtered_points.setMaxClusterSize(max_cluster_size)\n filtered_points.setSearchMethod(kd_tree)\n\n point_indexes = pclpy.pcl.vectors.PointIndices()\n filtered_points.extract(point_indexes)\n\n cluster_list = [points_to_cluster.xyz[i2.indices] for i2 in point_indexes]\n return cluster_list","def calcDistortion(medoids, clusters, class_header=\"Class\"):\n distortion = 0\n for medoid_row_index, medoid_tuple in enumerate(medoids.iterrows()): # For every Medoid\n for _, datum in clusters[medoid_row_index].iterrows(): # For each point in the medoid cluster\n # Add the distance between medoid and data point squared to total distortion\n distortion += (Cluster.calcDistance(medoid_tuple[1], datum, class_header=class_header)) ** 2\n return distortion","def findK_centroids_closest(self, features, clusters):\n\n class InnerFeatures:\n def __init__(self, kps, des, pos):\n self.kps = kps\n self.des = des\n self.pos = pos\n\n kmeans = KMeans(n_clusters=clusters)\n\n pts = np.array(features.pos)\n kps = np.array(features.kps)\n des = np.array(features.des)\n\n kmeans.fit(pts)\n m_clusters = kmeans.labels_.tolist()\n centers = np.array(kmeans.cluster_centers_)\n\n closest, _ = pairwise_distances_argmin_min(kmeans.cluster_centers_, pts)\n\n assert len(set(closest)) == clusters\n\n result = InnerFeatures(kps[closest], des[closest], pts[closest])\n return result","def _distorted_distance(self):\n distance = 0\n for i, pixel in enumerate(self.training_set):\n distance += self._euclid_distance(\n pixel, self.clusters[self.labels[i]], axis=0)\n return distance","def recluster(cluster, min_size, guard, func):\r\n if cluster.get_length() == 0:\r\n return\r\n if cluster.get_length() <= min_size:\r\n return cluster\r\n sim = func(cluster.get_tweets())\r\n if sim < guard:\r\n kmeans = TweetKMeans(2)\r\n kmeans.set_data(cluster.get_tweets())\r\n return kmeans.start_algorithm()\r\n return cluster","def visit_k_nearest(node, pt, k, result):\n # rather brute force but because cut off and k expected to be rather small\n # not further optimized\n # (result could instead of list be a bin heap with at most k items)\n for active, item in zip(node.active, node.items):\n # check active items\n if active:\n d = distance2(pt, item)\n result.append( (d, item) )\n # sort on distance\n result.sort(key=lambda x: x[0])\n # keep max k items\n while len(result) > k:\n result.pop()","def closestCentroids(self, points , centroids ):\n dists = scipy.spatial.distance.cdist(points,centroids)\n # 1 is dimension\n minIds = numpy.argmin(dists, 1)\n return minIds","def get_distances(centroid, points):\r\n return np.linalg.norm(points - centroid, axis=1)","def predict_cluster(self, point):\n # assuming point belongs to clusters that were computed by fit functions\n return self.cluster[tuple(point)]","def assign_k_clusters(data, centers):\n clusters = []\n center_data = np.take(data, centers, axis=0)\n best_center = np.argmax(center_data, axis=0)\n for i in range(len(centers)):\n inds = [ind for ind in np.where(best_center == i)[0]]\n clusters.append(inds)\n return clusters","def assign_cluster(node):\n if (node not in attrs_by_node):\n return -1\n else:\n attrs = list(attrs_by_node[node])\n if (len(attrs) == 1):\n return labels[indices_by_vocab[attrs[0]]]\n else:\n vec = np.zeros(k, dtype = float)\n for attr in attrs:\n vec += features[indices_by_vocab[attr]]\n vec /= len(attrs)\n if sphere:\n vec = normalize(vec)\n sims = [np.dot(vec, center) for center in centers]\n else:\n sims = [-np.linalg.norm(vec - center) for center in centers]\n max_index, max_sim = -1, -float('inf')\n for (i, sim) in enumerate(sims):\n if (sim > max_sim):\n max_index = i\n max_sim = sim\n return max_index","def cluster(M, point, eps): # zwraca punkty dla ktorych dystans z punktu point jest mniejszy od eps\n seeds = []\n for i in range(0, M.shape[0]):\n if eps_neighborhood(M, point, i, eps):\n seeds.append(i)\n return seeds","def nearest_neighbor(non_cancer_data, cancer_data):\r\n #status is based on the mean of smallest elements of cancer and non_cancer groups\r\n #sort\r\n non_cancer_data = sorted(non_cancer_data)\r\n cancer_data = sorted(cancer_data)\r\n\r\n #choose nearest neighbors\r\n non_cancer_neighbor = np.mean(non_cancer_data[:2])\r\n cancer_neighbor = np.mean(cancer_data[:2])\r\n\r\n #etermine cell status\r\n if non_cancer_neighbor > cancer_neighbor:\r\n print(\"Negative\")\r\n else:\r\n print(\"Positive\")"],"string":"[\n \"def rank_cluster_points_by_distance(self, cluster_id):\\n cluster_of_interest = self.embedding_df[self.embedding_df['cluster'] == cluster_id].copy()\\n \\n if cluster_of_interest.empty:\\n raise ValueError(f'Cluster id {cluster_id} not found')\\n \\n if 'dist_to_rep_point' not in self.embedding_df.columns:\\n distance_df = self.calculate_distances_for_cluster(cluster_id)\\n cluster_of_interest = cluster_of_interest.merge(distance_df, left_index=True, right_index=True)\\n \\n cluster_of_interest.sort_values('dist_to_rep_point', inplace=True)\\n return cluster_of_interest\",\n \"def get_all_cluster_rankings(self):\\n if 'dist_to_rep_point' not in self.embedding_df.columns:\\n self.calculate_all_distances_to_center()\\n\\n self.embedding_df['rank_in_cluster'] = self.embedding_df.groupby('cluster')['dist_to_rep_point'].rank(method='min')\",\n \"def rankNeighbors(Data):\\r\\n strokeDist = []\\r\\n for i in range(len(Data)):\\r\\n strokeDist.append([])\\r\\n index = 0\\r\\n for point1 in Data:\\r\\n dist = []\\r\\n index1=0\\r\\n for point2 in Data:\\r\\n #dist.append(math.sqrt((center1[0]-center2[0])**2+(center1[1]-center2[1])**2))\\r\\n dist.append((index1,math.sqrt((point1[0]-point2[0])**2+(point1[1]-point2[1])**2+(point1[2]-point2[2])**2)))\\r\\n index1+=1\\r\\n #x = copy.deepcopy(dist)\\r\\n #print(x)\\r\\n dist.sort(key= lambda x:x[1])\\r\\n #print(x)\\r\\n # Get rank for each element\\r\\n idx1 =0\\r\\n for e in dist:\\r\\n #i = x.index(e)\\r\\n strokeDist[index].append(e)\\r\\n idx1 +=1\\r\\n index+=1\\r\\n return strokeDist\",\n \"def _assign_clusters(self):\\n\\n dist = np.zeros((self.k, ))\\n distortion = 0\\n\\n for index in range(0, self.data.shape[0]):\\n for i in range(0, self.k):\\n dist[i] = np.linalg.norm(self.data[index] - self.centroids[i])\\n\\n self.assigned_clusters[index] = np.argmin(dist)\\n distortion += np.min(dist)\\n\\n return distortion\",\n \"def distance(point, cluster):\\n return np.sqrt((point[0] - cluster[0])**2 + (point[1] - cluster[1])**2)\",\n \"def cluster_spatial_positioning(data):\\n \\n n_clusters = len(set(data['clusters'])-{-1}) # since -1 element denotes noice\\n if n_clusters <2:\\n #Setting cluster angluar features to default\\n cdist=[Cluster_Relative_Distances()]\\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n elif n_clusters >=2:\\n # Here we implement two approaches for measuring distances between clustes:\\n # (1) border-boder distances and (2) centroid-centroid distances. \\n # We compute dispersion measures for the distances obtained. \\n \\n d = dict(tuple(data.groupby('clusters')))\\n d.pop(-1, None)\\n\\n min_dist_between_clusters=np.row_stack([[np.amin(ss.distance_matrix(np.column_stack([d[i]['X'].array,d[i]['Y'].array]), \\n np.column_stack([d[j]['X'].array,d[j]['Y'].array]))) for j in d.keys()] for i in d.keys()])\\n min_dist_between_clusters=np.delete(list(set(np.frombuffer(min_dist_between_clusters))) ,0)\\n\\n cen_dist_between_clusters=ss.distance_matrix(np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]),\\n np.row_stack([(np.mean(d[i]['X'].array),np.mean(d[i]['Y'].array)) for i in d.keys()]))\\n cen_dist_between_clusters=np.delete(list(set(np.frombuffer(cen_dist_between_clusters))) ,0)\\n\\n (avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster)= distribution_statistics(min_dist_between_clusters)\\n\\n (avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster)= distribution_statistics(cen_dist_between_clusters)\\n\\n cdist = [Cluster_Relative_Distances([avg_bor_bor_dist_cluster,min_bor_bor_dist_cluster,max_bor_bor_dist_cluster,\\n std_bor_bor_dist_cluster,CV_bor_bor_dist_cluster,CD_bor_bor_dist_cluster,\\n IQR_bor_bor_dist_cluster,Quartile_CD_bor_bor_dist_cluster,\\n avg_cen_cen_dist_cluster,min_cen_cen_dist_cluster,max_cen_cen_dist_cluster,\\n std_cen_cen_dist_cluster,CV_cen_cen_dist_cluster,CD_cen_cen_dist_cluster,\\n IQR_cen_cen_dist_cluster,Quartile_CD_cen_cen_dist_cluster])]\\n \\n cdist = pd.DataFrame([o.__dict__ for o in cdist])\\n\\n \\n return cdist\",\n \"def cluster(self):\\n center_index = np.random.choice(range(100), self.K, replace=False)\\n self.centers = np.array([self.X[i] for i in center_index])\\n self.cluster_sizes = np.zeros(self.K)\\n member_of = np.zeros(100, dtype=int)\\n min_dist = np.array([distance.euclidean(self.centers[0], point) for point in self.X])\\n self.cluster_sizes[0] = 100\\n flag = True\\n while flag:\\n flag = False\\n for i, point in enumerate(self.X):\\n for j, center in enumerate(self.centers):\\n if member_of[i] != j:\\n dist = distance.euclidean(point, center)\\n if dist < min_dist[i]:\\n flag = True\\n current = member_of[i]\\n self.cluster_sizes[current] -= 1\\n self.cluster_sizes[j] += 1\\n member_of[i] = j\\n min_dist[i] = dist\\n if np.count_nonzero(self.cluster_sizes) != self.K:\\n return self.cluster()\\n self.centers = np.zeros((self.K, 2), dtype='d')\\n for i, point in enumerate(self.X):\\n center = member_of[i]\\n self.centers[center] += point\\n for i, center in enumerate(self.centers):\\n center /= self.cluster_sizes[i]\",\n \"def cluster(self):\\n\\n result_nominatim = self.nominatim()\\n try:\\n coord = [(float( i['lat'] ), float( i['lon'] )) for i in result_nominatim]\\n except:\\n return None\\n #print( \\\"coord\\\", coord )\\n kms_per_radian = 6371.0088\\n # Augmenter cette valeur augmente le nombre d'éléments dans un cluster et change les résultats\\n epsilon = 2 / kms_per_radian\\n # Adapter le nombre de clusters (min_sample) au nombre d'entités dans array ?\\n db = DBSCAN( eps=epsilon, min_samples=1, algorithm='ball_tree',\\n metric='haversine' ).fit( np.radians( coord ) )\\n cluster_labels = db.labels_\\n #print( \\\"cluster\\\", cluster_labels )\\n num_clusters = len( set( cluster_labels ) )\\n #print( \\\"num clusters\\\", num_clusters )\\n counts = np.bincount( cluster_labels )\\n #print( \\\"count\\\", counts )\\n maxi = np.argmax( counts )\\n #print( \\\"maxi\\\", maxi )\\n itemindex = np.where( cluster_labels == maxi )[0]\\n #print( \\\"itemindex\\\", itemindex )\\n\\n lat: List[float] = [float( result_nominatim[index]['lat'] ) for index in itemindex]\\n lon: List[float] = [float( result_nominatim[index]['lon'] ) for index in itemindex]\\n\\n # on récupère la moyenne des coordonnées du plus gros cluster. Cette moyenne équivaut au centroide :\\n # https://gis.stackexchange.com/questions/12120/calculate-midpoint-from-a-series-of-latitude-and-longitude-coordinates\\n\\n average = {\\\"lat\\\": sum( lat ) / len( lat ), \\\"lon\\\": sum( lon ) / len( lon )}\\n\\n #print( list( zip( cluster_labels, [x['display_name'] for x in results] ) ) )\\n #print( \\\"plus proche de moyenne\\\", closest( results, average ) )\\n return closest( result_nominatim, average )\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n points = cluster_list[:]\\n \\n # n <-- |p|;\\n len_points_list = len(points)\\n\\n # position initial clusters at the location of clusters with largest populations (i.e., cluster[3] which is population) \\n cluster_centers = []\\n temp_cl = points[:]\\n \\n temp_cl.sort(key=lambda cluster: cluster.total_population())\\n for cluster in reversed(temp_cl):\\n if len(cluster_centers) < num_clusters:\\n cluster_centers.append(alg_cluster.Cluster(set([]), cluster.horiz_center(), cluster.vert_center(), 0, 0))\\n\\n # For number of iterations\\n for dummy_var in range(num_iterations):\\n # initialize k (num_clusters) empty sets C1, ... Ck;\\n cluster_groupings = []\\n for index in range(len(cluster_centers)):\\n cluster_groupings.append(alg_cluster.Cluster(set(), 0, 0, 0, 0))\\n # # For each county\\n # for j = 0 to n - 1 do\\n for index in range(len_points_list):\\n # Find the old cluster center that is closest \\n # L <-- argminsub(1<=f<=k) (dsub(psubj), musubf); \\n min_dist = float('inf')\\n nearest_cluster_index = None\\n\\n for idx, cluster in enumerate(cluster_centers):\\n if points[index].distance(cluster) < min_dist:\\n min_dist = points[index].distance(cluster)\\n nearest_cluster_index = idx\\n\\n # Add the county to the corresponding new cluster\\n # Handled with Cluster class merge_clusters method, which will automatically update the cluster centers to correct locations.\\n cluster_groupings[nearest_cluster_index].merge_clusters(points[index])\\n # Set old clusters equal to new clusters \\n # for f = 1 to k do\\n for index in range(len(cluster_centers)):\\n # muf = center (Cf) // handled with Cluster class built-in method(s)\\n cluster_centers[index] = cluster_groupings[index].copy()\\n\\n # return {C1, C2, ..., Ck}; \\n return cluster_groupings\",\n \"def nearest_cluster_center(point, cluster_centers):\\n def sqr_distance_2D(a, b):\\n return abs(a.x - b.x) *abs(a.x - b.x) + abs(a.y - b.y) *abs(a.x - b.x) + abs(a.z-b.z)*abs(a.x - b.x)\\n min_index = point.group\\n min_dist = FLOAT_MAX\\n \\n for i, cc in enumerate(cluster_centers):\\n d = sqr_distance_2D(cc, point)\\n if min_dist > d:\\n min_dist = d\\n min_index = i\\n \\n return (min_index, min_dist)\",\n \"def closestCluster(p, centers):\\n\\tbestIndex = 0\\n closest = float(\\\"+inf\\\")\\n for i in range(len(centers)):\\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\\n if distance < closest:\\n closest = distance\\n bestIndex = i\\n\\treturn bestIndex\",\n \"def in_xi(self, sample, cluster, cluster_size):\\n sum_distance = 0\\n for cur_sample in cluster.get_samples():\\n if sample.get_s_id() != cur_sample.get_s_id():\\n if cur_sample.get_s_id() < sample.get_s_id():\\n sum_distance += self.distance_dict[(cur_sample.get_s_id(), sample.get_s_id())]\\n elif cur_sample.get_s_id() > sample.get_s_id():\\n sum_distance += self.distance_dict[(sample.get_s_id(), cur_sample.get_s_id())]\\n return sum_distance / (cluster_size - 1)\",\n \"def cluster_dpc_knn(token_dict, cluster_num, k=5, token_mask=None):\\n with torch.no_grad():\\n x = token_dict['x']\\n B, N, C = x.shape\\n dist_matrix = torch.cdist(x, x) / C ** 0.5\\n if token_mask is not None:\\n token_mask = token_mask > 0\\n dist_matrix = dist_matrix * token_mask[:, None, :] + (dist_matrix.max() + 1) * ~token_mask[:, None, :]\\n dist_nearest, index_nearest = torch.topk(dist_matrix, k=k, dim=-1, largest=False)\\n density = (-(dist_nearest ** 2).mean(dim=-1)).exp()\\n density = density + torch.rand(density.shape, device=density.device, dtype=density.dtype) * 1e-06\\n if token_mask is not None:\\n density = density * token_mask\\n mask = density[:, None, :] > density[:, :, None]\\n mask = mask.type(x.dtype)\\n dist_max = dist_matrix.flatten(1).max(dim=-1)[0][:, None, None]\\n dist, index_parent = (dist_matrix * mask + dist_max * (1 - mask)).min(dim=-1)\\n score = dist * density\\n _, index_down = torch.topk(score, k=cluster_num, dim=-1)\\n dist_matrix = index_points(dist_matrix, index_down)\\n idx_cluster = dist_matrix.argmin(dim=1)\\n idx_batch = torch.arange(B, device=x.device)[:, None].expand(B, cluster_num)\\n idx_tmp = torch.arange(cluster_num, device=x.device)[None, :].expand(B, cluster_num)\\n idx_cluster[idx_batch.reshape(-1), index_down.reshape(-1)] = idx_tmp.reshape(-1)\\n return idx_cluster, cluster_num\",\n \"def k_means_clustering(rows, distance=pearson_distance, k=4):\\n # Determine the min and max values for each point\\n ranges = [(min(row[i] for row in rows), max([row[i] for row in rows])) for i in range(len(rows[0]))]\\n\\n # Create k RANDOMLY placed centroids\\n clusters = [[random() * (ranges[i][1] - ranges[i][0]) + ranges[i][0] for i in range(len(rows[0]))] for j in\\n range(k)]\\n distances_from_centroids = {}\\n last_matches = None\\n best_matches = None\\n for t in range(100):\\n print ('Iteration {}'.format(t))\\n best_matches = [[] for i in range(k)]\\n\\n # Find the centroid that is the closest for each row\\n for j in range(len(rows)):\\n row = rows[j]\\n best_match = 0\\n for i in range(k):\\n d = distance(clusters[i], row)\\n if d < distance(clusters[best_match], row):\\n best_match = i\\n best_matches[best_match].append(j)\\n\\n # if the results are the same as last time, then this is complete\\n if best_matches == last_matches:\\n break\\n last_matches = best_matches\\n\\n # Move the centroids to the average of their members\\n for i in range(k):\\n avgs = [0.0] * len(rows[0])\\n if len(best_matches[i]) > 0:\\n for row_id in best_matches[i]:\\n for m in range(len(rows[row_id])):\\n avgs[m] += rows[row_id][m]\\n for j in range(len(avgs)):\\n avgs[j] /= len(best_matches[i])\\n clusters[i] = avgs\\n\\n # Chapter 3 Exercise 5: Return along with the cluster results the total distance between all items\\n # and their respective centroids\\n for i in range(k):\\n for j in range(len(best_matches[i])):\\n distances_from_centroids[best_matches[i][j]] = distance(clusters[i],rows[best_matches[i][j]])\\n return best_matches, distances_from_centroids\",\n \"def iterative_cluster(clusters, points, distance_function, max_iterations=1000):\\n point_assignments = {p: 0 for p in points}\\n\\n for p in points:\\n if p not in symmetric_distances:\\n print p\\n\\n for n in range(max_iterations):\\n assignment_change = False\\n new_clusters = [set() for c in clusters]\\n\\n for p in points:\\n (score, i) = min_argmin(\\n lambda i: distance_function(set([p]), clusters[i]),\\n range(len(clusters)))\\n if point_assignments[p] != i:\\n point_assignments[p] = i\\n assignment_change = True\\n new_clusters[i].add(p)\\n\\n clusters = new_clusters\\n if not assignment_change: break\\n\\n return sorted_clusters(clusters, distance_function)\",\n \"def nearest_cluster(X,c):\\n K = np.size(c,0)\\n idx = np.zeros((np.size(X,0),1))\\n arr = np.empty((np.size(X,0),1))\\n for i in range(0,K):\\n y = c[i]\\n temp = np.ones((np.size(X,0),1))*y\\n b = np.power(np.subtract(X,temp),2)\\n a = np.sum(b,axis = 1)\\n a.resize((np.size(X,0),1))\\n arr = np.append(arr, a, axis=1)\\n arr = np.delete(arr,0,axis=1)\\n idx = np.argmin(arr, axis=1)\\n return idx\",\n \"def closestClusterAndDistance(p, centers):\\n\\tbestIndex = 0\\n closest = float(\\\"+inf\\\")\\n for i in range(len(centers)):\\n distance = np.sqrt(np.sum((np.array(p) - centers[i]) ** 2))\\n if distance < closest:\\n closest = distance\\n bestIndex = i\\n return (bestIndex, closest)\",\n \"def clusterAndDistance(self, data):\\n\\t\\treturn closestClusterAndDistance(data, self.centers)\",\n \"def distance_scipy_spatial(z, k=4, metric='euclidean'):\\n d = scipy.spatial.distance.pdist(z, metric)\\n d = scipy.spatial.distance.squareform(d)\\n # k-NN graph.\\n idx = np.argsort(d)[:, 1:k + 1]\\n d.sort()\\n d = d[:, 1:k + 1]\\n return d, idx\",\n \"def __find_nearest_centroids(self, data):\\n \\n self.clusters = np.array([]) \\n for i, d in enumerate(data):\\n min_dist = np.inf\\n self.clusters = np.concatenate((self.clusters, np.array([-1])))\\n for j, c in enumerate(self.centroids):\\n dist = self.__compute_distance(d, c)\\n if min_dist > dist:\\n min_dist = dist\\n self.clusters[i] = j\",\n \"def clustering(cluster_list):\\n while len(cluster_list) > 1:\\n x = 0\\n y = 0\\n distance_min = 10\\n\\n for i in range(0,len(cluster_list)):\\n\\n for j in range(0,len(cluster_list)):\\n\\n if i != j:\\n distance = cluster_list[i].linkage(cluster_list[j])\\n if distance < distance_min:\\n x = i\\n y = j\\n distance_min = distance\\n \\n \\n clusX = cluster_list[x]\\n clusY = cluster_list[y]\\n cluster_list.pop(cluster_list.index(clusX))\\n cluster_list.pop(cluster_list.index(clusY))\\n\\n cluster_list.append(Cluster(clusX,clusY))\\n return cluster_list[0]\",\n \"def move_centroids(centroids, x, assigned_clusters):\\n\\n return np.array([1 / np.sum(assigned_clusters == k) * np.sum(x[assigned_clusters == k], axis=0)\\n for k in range(centroids.shape[0])])\",\n \"def get_ranked_points(zpoints, dsq):\\n pos_map = calc_positions(zpoints, dsq)\\n rpoints = calc_ranked_points(pos_map, dsq)\\n return rpoints\",\n \"def out_xi(self, sample, cluster):\\n min_distance = 0\\n first = True\\n for cur_cluster in self.cluster_lst:\\n sum_distance = 0\\n if cur_cluster.get_c_id() != cluster.get_c_id():\\n for cur_sample in cur_cluster.get_samples():\\n if cur_sample.get_s_id() < sample.get_s_id():\\n sum_distance += self.distance_dict[(cur_sample.get_s_id(), sample.get_s_id())]\\n elif cur_sample.get_s_id() > sample.get_s_id():\\n sum_distance += self.distance_dict[(sample.get_s_id(), cur_sample.get_s_id())]\\n cluster_size = len(cur_cluster.get_samples())\\n temp_distance = sum_distance / cluster_size\\n if first:\\n min_distance = temp_distance\\n first = False\\n min_distance = min(temp_distance, min_distance)\\n return min_distance\",\n \"def find_centroid_for_each(self):\",\n \"def knn_classify_point(point, data, k, distance_metric):\\n k_closest_points = get_k_closest_points(point, data, k, distance_metric)\\n classification_counts = {}\\n for item in k_closest_points:\\n classification_type = item.classification\\n if classification_type not in classification_counts:\\n classification_counts[classification_type] = 0\\n else:\\n classification_counts[classification_type] += 1\\n classification_counts = sorted(classification_counts, key = classification_counts.get)\\n return classification_counts[-1]\",\n \"def kmeans(boxes, k, dist=np.median,seed=1):\\n rows = boxes.shape[0]\\n distances = np.empty((rows, k)) ## N row x N cluster\\n last_clusters = np.zeros((rows,))\\n np.random.seed(seed)\\n # initialize the cluster centers to be k items\\n clusters = boxes[np.random.choice(rows, k, replace=False)]\\n aveIOU=0.0\\n while True:\\n # 为每个点指定聚类的类别（如果这个点距离某类别最近，那么就指定它是这个类别)\\n for icluster in range(k):\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n nearest_clusters = np.argmin(distances, axis=1)\\n\\n for i in range(rows ):\\n aveIOU=aveIOU+1-distances[i,nearest_clusters[i]]\\n aveIOU=aveIOU/rows\\n\\n\\t# 如果聚类簇的中心位置基本不变了，那么迭代终止。\\n if (last_clusters == nearest_clusters).all():\\n break\\n # 重新计算每个聚类簇的平均中心位置，并它作为聚类中心点\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters,nearest_clusters,distances,aveIOU\",\n \"def rank() -> int:\\n return dist.get_rank() if dist.is_initialized() else 0\",\n \"def kmeans_clustering(cluster_list, num_clusters, num_iterations):\\n\\n # position initial clusters at the location of clusters with largest populations\\n \\n cluster_n = len(cluster_list)\\n\\n miu_k = sorted(cluster_list,\\n key=lambda c: c.total_population())[-num_clusters:]\\n miu_k = [c.copy() for c in miu_k]\\n\\n # n: cluster_n\\n # q: num_iterations\\n for _ in xrange(num_iterations):\\n cluster_result = [alg_cluster.Cluster(set([]), 0, 0, 0, 0) for _ in range(num_clusters)]\\n # put the node into closet center node\\n\\n for jjj in xrange(cluster_n):\\n min_num_k = 0\\n min_dist_k = float('inf')\\n for num_k in xrange(len(miu_k)):\\n dist = cluster_list[jjj].distance(miu_k[num_k])\\n if dist < min_dist_k:\\n min_dist_k = dist\\n min_num_k = num_k\\n\\n cluster_result[min_num_k].merge_clusters(cluster_list[jjj])\\n\\n # re-computer its center node\\n for kkk in xrange(len(miu_k)):\\n miu_k[kkk] = cluster_result[kkk]\\n\\n return cluster_result\",\n \"def find_nearest_neighbors(p, points, k=5):\\n dist = np.zeros(points.shape[0])\\n for i in range(len(dist)):\\n dist[i] = distance(p, points[i])\\n ind = np.argsort(dist)\\n return ind[0:k]\",\n \"def _calculate_nearest_cluster(self, pixels, cluster_labels):\\n\\n # assign pixel (RGB) to nearest cluster label (index)\\n for index, rgb in pixels:\\n rgb_vector = np.tile(rgb, (self.k, 1))\\n self._labels[index] = np.argmin(\\n self._euclid_distance(rgb_vector, self._clusters), axis=0)\\n\\n if cluster_labels[self._labels[index]] is None:\\n cluster_labels[self._labels[index]] = list()\\n\\n cluster_labels[self._labels[index]].append(rgb)\\n\\n return cluster_labels\",\n \"def predict_cluster(point):\\n # assuming point belongs to clusters that were computed by fit functions\\n return cluster[tuple(point)]\",\n \"def get_k_closest_points(point, data, k, distance_metric):\\n points_and_scores = []\\n k_closest_points = []\\n for item in data:\\n item_score = distance_metric(point, item)\\n points_and_scores.append([item, item_score])\\n points_and_scores = sorted(points_and_scores, key = lambda item:(item[1], item[0].coords))\\n for i in range(k):\\n k_closest_points.append(points_and_scores[i][0])\\n return k_closest_points\",\n \"def makeCluster(self):\\n for i in range(self.k):\\n #vector of length total users, pick random number 1-5\\n self.centroids.append(np.random.uniform(low=1,high=5,size=len(self.user)))\\n memberList = []\\n self.membership.append(memberList)\\n self.centroids = np.round(self.centroids)\\n\\n for movie in self.dictionary.keys():\\n #Finds the index of the closest centroid\\n closest = np.argmin(self.calculateDistance(self.dictionary[movie]))\\n newVector = []\\n newVector.append(movie)\\n #Add the movie to the list of members of the closest centroid\\n self.membership[closest].append(newVector)\\n self.recalculateCentroid(self.membership[closest], closest)\",\n \"def get_k_neighbors(self, point):\\n nn = []\\n nnl = []\\n for p,l in zip(self.train_features,self.train_labels):\\n d = self.distance_function(p,point)\\n dl_pair = (d,l)\\n nn.append(dl_pair)\\n nn = sorted(nn, key = lambda x: x[0])\\n for i in range(0,self.k):\\n nnl.append(nn[i][1])\\n return nnl\\n raise NotImplementedError\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def calc_ranked_points(pos_map, dsq_list):\\n\\n rpoints = {}\\n\\n for pos, zones in pos_map.items():\\n # remove any that are dsqaulified\\n # note that we do this before working out the ties, so that any\\n # dsq tie members are removed from contention\\n zones = [ z for z in zones if z not in dsq_list ]\\n if len(zones) == 0:\\n continue\\n\\n # max points is 4, add one because pos is 1-indexed\\n points = (4 + 1) - pos\\n # Now that we have the value for this position if it were not a tie,\\n # we need to allow for ties. In case of a tie, the available points\\n # for all the places used are shared by all those thus placed.\\n # Eg: three first places get 3pts each (4+3+2)/3.\\n # Rather than generate a list and average it, it's quicker to just\\n # do some maths using the max value and the length of the list\\n points = points - ( (len(zones) - 1) / 2.0 )\\n for z in zones:\\n rpoints[z] = points\\n\\n # those that were dsq get 0\\n for z in dsq_list:\\n rpoints[z] = 0.0\\n\\n return rpoints\",\n \"def kmeans(matrix, k) :\\n clusters = [0 for i in range(k)]\\n lastcluster=[0 for i in range(k)]\\n min_=0\\n max_=matrix.__len__()\\n print \\\"len\\\",max_\\n cluster = [0 for i in range(k)]\\n for i in range(k) :\\n\\n cluster[i]=int(random.random() * (max_ - min_) + min_)\\n clusters[i]=matrix[cluster[i]]\\n lastcluster[i]=matrix[cluster[i]]\\n #print cluster[i],clusters[i]\\n\\n lastmatchs = [ [] for i in range(k)]\\n\\n \\\"\\\"\\\" initial the round is 100\\\"\\\"\\\"\\n rounds = 100\\n while rounds > 0 :\\n matchs = [ [] for i in range(k)]\\n print 'round \\\\t',rounds\\n for i in range(len(matrix)) :\\n bestmatch_cluster = None\\n\\n min_distance = 100000\\n for j in range(k) :\\n dis = pearson_distance(clusters[j], matrix[i])\\n if dis < min_distance :\\n min_distance = dis\\n bestmatch_cluster = j\\n matchs[bestmatch_cluster].append(i)\\n\\n print_matchs(matchs)\\n #print_matchs(lastmatchs)\\n\\n\\n\\n if matchs == lastmatchs : break\\n #if cluster== lastcluster :break\\n lastmatchs = [[ item for item in matchs[i] ] for i in range(k)]\\n\\n #move the centroids to the average of their members\\n for j in range(k) :\\n avg = [0.0 for i in range(len(matrix[0])) ]\\n for m in matchs[j] :\\n vec = matrix[m]\\n for i in range(len(matrix[0])) :\\n avg[i] += vec[i]\\n avg = [ item / len(matrix[0]) for item in avg]\\n clusters[j] = avg\\n lastcluster=clusters\\n\\n\\n rounds -= 1\\n print \\\"rounds:\\\",100-rounds\\n print \\\"result:\\\"\\n for i in matchs:\\n print i\",\n \"def calOffsetOfCluster(color_cluster, cluster):\\n offset = 0\\n for cc in color_cluster:\\n l = len(cluster)\\n for i in range(l):\\n offset_temp = math.pow( (cc[1][i] - cluster[i]), 2 )\\n offset += offset_temp\\n return offset\",\n \"def addToTheCluster(pointIdx,AllPoints,Allneighbors,DistanceRanks,cluster,visited,eps,minPts):\\r\\n point = AllPoints[pointIdx]\\r\\n cluster.addToCluster(point)\\r\\n point.clusterId = 1\\r\\n\\r\\n temp = Allneighbors[pointIdx]\\r\\n count = 0\\r\\n for points in temp:\\r\\n if visited[points] == 0:\\r\\n visited[points] =1\\r\\n neighbors = findNeighbors(AllPoints[points],DistanceRanks,eps)\\r\\n Allneighbors[points] = neighbors\\r\\n if len(neighbors) >= minPts:\\r\\n temp += neighbors\\r\\n\\r\\n if AllPoints[points].clusterId == -1:\\r\\n AllPoints[points].clusterId = 1\\r\\n cluster.addToCluster(AllPoints[points])\\r\\n count+=1\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def kmeans(boxes, k, dist=numpy.median, seed=1):\\n rows = boxes.shape[0]\\n distances = numpy.empty((rows, k)) ## N row x N cluster\\n last_clusters = numpy.zeros((rows,))\\n\\n numpy.random.seed(seed)\\n\\n # initialize the cluster centers to be k items\\n clusters = boxes[numpy.random.choice(rows, k, replace=False)]\\n\\n while True:\\n # Step 1: allocate each item to the closest cluster centers\\n for icluster in range(k): # I made change to lars76's code here to make the code faster\\n distances[:,icluster] = 1 - iou(clusters[icluster], boxes)\\n\\n nearest_clusters = numpy.argmin(distances, axis=1)\\n\\n if (last_clusters == nearest_clusters).all():\\n break\\n\\n # Step 2: calculate the cluster centers as mean (or median) of all the cases in the clusters.\\n for cluster in range(k):\\n clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)\\n last_clusters = nearest_clusters\\n\\n return clusters, nearest_clusters, distances\",\n \"def cluster_feature(feature_mat, k):\\n whitened = whiten(feature_mat.transpose())\\n centroid, distortion = kmeans(whitened, k)\\n\\n return centroid, distortion\",\n \"def cluster_index_2(X):\\n \\n global_mean = X.mean(axis=0)\\n\\n sum_squared_distances = (((X - global_mean)**2).sum(axis = 1)).sum()\\n #Sum of squared distances of each sample from the global mean\\n \\n centroids, labels, inertia = k_means(X, 2)\\n\\n ci = inertia / sum_squared_distances\\n\\n return ci , labels\",\n \"def kmeans_clustering(all_features, vocab_size, epsilon, max_iter):\\n\\n # Your code here. You should also change the return value.\\n\\n def _initiate_random_centroids(all_features, vocab_size):\\n \\\"\\\"\\\"\\n Initiate random centroids in the range of input\\n\\n :param all_features:\\n :param vocab_size:\\n :return:\\n \\\"\\\"\\\"\\n centroids = []\\n # 1) Genereate points for initial centroids\\n\\n min_feat = np.ones(all_features[0].size)*np.inf\\n max_feat = np.zeros(all_features[0].size)\\n\\n for a in all_features:\\n for p in range(len(a)):\\n if a[p] < min_feat[p]:\\n min_feat[p] = a[p]\\n else:\\n if a[p] > max_feat[p]:\\n max_feat[p] = a[p]\\n\\n\\n for _ in range(vocab_size):\\n random_vector = np.multiply(np.random.rand(1, all_features[0].size),\\n max_feat-min_feat) + min_feat\\n centroids.append(random_vector.flatten())\\n\\n return np.array(centroids)\\n\\n def _assign_vectors_to_nearest_centroid(all_features, centroid):\\n \\\"\\\"\\\"\\n Assign vectors to nearest centroids\\n\\n :param all_features:\\n :param centroid:\\n :return:\\n \\\"\\\"\\\"\\n #TODO: sprawdz co lepiej dziala\\n new_centroid_coor = np.zeros([len(centroid), all_features[0].size])\\n #new_centroid_coor = centroid\\n new_centroid_counter = np.zeros(len(centroid))\\n\\n dist = pdist(centroid, all_features)\\n #min_dist = dist.min(axis=0)\\n min_dist_index = dist.argmin(axis=0)\\n\\n for x in range(len(min_dist_index)):\\n id = min_dist_index[x]\\n new_centroid_coor[id] = np.add(new_centroid_coor[id],\\n all_features[x])\\n new_centroid_counter[id] += 1\\n\\n new_centroid_coor_out = []\\n for i in range(len(new_centroid_coor)):\\n if new_centroid_counter[i] == 0:\\n new_centroid_coor_out.append(centroid[i])\\n else:\\n new_centroid_coor_out.append(np.divide(new_centroid_coor[i],new_centroid_counter[i]))\\n\\n return np.array(new_centroid_coor_out), new_centroid_counter\\n\\n\\n def _check_convergence_condition(old_centroids, new_centroids, epsilon):\\n \\\"\\\"\\\"\\n Check convergence confition\\n\\n :param old_centroids:\\n :param new_centroids:\\n :param epsilon: if every centroid is moved by dist < epsilon KMeans terminates\\n :return:\\n \\\"\\\"\\\"\\n for i in range(len(old_centroids)):\\n dist = euclidean(old_centroids[i], new_centroids[i])\\n if dist > epsilon:\\n return False\\n\\n return True\\n\\n def delete_small_clusters(new_centroids, centroid_counter, threshold):\\n \\\"\\\"\\\"\\n Potential extension of the algorithm -> if there is not any point in the cluster, delete this cluste\\n\\n :param new_centroids:\\n :param centroid_counter:\\n :param threshold:\\n :return:\\n \\\"\\\"\\\"\\n\\n out_centroids = []\\n for n in range(len(new_centroids)):\\n if centroid_counter[n] > threshold:\\n out_centroids.append(new_centroids[n])\\n out_centroids = np.array(out_centroids)\\n return out_centroids\\n\\n #MAIN\\n old_centroids = _initiate_random_centroids(all_features, vocab_size)\\n\\n for _ in range(max_iter):\\n new_centroids, centroid_counter = _assign_vectors_to_nearest_centroid(all_features, old_centroids)\\n if_convergenced = _check_convergence_condition(new_centroids, old_centroids, epsilon)\\n\\n if if_convergenced == True:\\n # return centroids if algorithm is converged\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\\n old_centroids = new_centroids\\n\\n # return centroids if reached max_iter\\n # return delete_small_clusters(new_centroids, centroid_counter, 0)\\n return new_centroids\",\n \"def initiateCentroid(data_points, centroids, k):\\n #Create empty list in list (amount is k)\\n AvgCentroids = [[] for i in range(k)]\\n\\n #For each datapoint in all datapoints\\n for dp in data_points:\\n dis = []\\n #For each centroid in centroids\\n for c in range(len(centroids)):\\n #Calculate the euclidean distance between those points and append\\n #to distance list\\n dis.append(calcEuclideanDistance(dp, centroids[c]))\\n \\n #Get the smallest value of the list and the index\\n val, idx = min((val, idx) for (idx, val) in enumerate(dis))\\n\\n #The index of the smallest value is the index where it will be added\\n #to the avgCentroids list. So it represents the number of the cluster\\n AvgCentroids[idx].append(dp)\\n \\n return AvgCentroids\",\n \"def classify_point(self, point):\\n mindistance = float(\\\"inf\\\")\\n for (label, centroid) in self.labelled_centroids:\\n distance = np.linalg.norm(centroid - point)\\n if distance < mindistance:\\n mindistance = distance\\n closest_centroid_label = label\\n return closest_centroid_label\",\n \"def _kneighbors_reduce_func(self, dist, start, n_neighbors, return_distance):\\n sample_range = np.arange(dist.shape[0])[:, None]\\n neigh_ind = np.argpartition(dist, n_neighbors - 1, axis=1)\\n neigh_ind = neigh_ind[:, :n_neighbors]\\n # argpartition doesn't guarantee sorted order, so we sort again\\n neigh_ind = neigh_ind[sample_range, np.argsort(dist[sample_range, neigh_ind])]\\n if return_distance:\\n if self.effective_metric_ == \\\"euclidean\\\":\\n result = np.sqrt(dist[sample_range, neigh_ind]), neigh_ind\\n else:\\n result = dist[sample_range, neigh_ind], neigh_ind\\n else:\\n result = neigh_ind\\n return result\",\n \"def _compute_dist(self, K, dist, within_distances, update_within):\\r\\n\\r\\n sw = self.sample_weight_\\r\\n\\r\\n for j in xrange(self.n_clusters):\\r\\n mask = self.labels_ == j\\r\\n if np.sum(mask) == 0:\\r\\n raise ValueError(\\\"Empty cluster found, try smaller n_cluster.\\\")\\r\\n\\r\\n denom = sw[mask].sum()\\r\\n denomsq = denom * denom\\r\\n if update_within:\\r\\n KK = K[mask][:, mask] \\r\\n dist_j = np.sum(np.outer(sw[mask], sw[mask]) * KK / denomsq)\\r\\n within_distances[j] = dist_j\\r\\n dist[:, j] += dist_j\\r\\n else:\\r\\n dist[:, j] += within_distances[j]\\r\\n\\r\\n dist[:, j] -= 2 * np.sum(sw[mask] * K[:, mask], axis=1) / denom #calculating distance of each point from centroid of cluster j by finding \\r\\n #diff. b/w centroid of cluster j & similarity of it with points in cluster j\\r\",\n \"def computeKMeans(self, points, k):\\n centroids = self.init_centroids(points,k)\\n \\n for i in range(5):\\n closest = self.closestCentroids(points,centroids)\\n centroids = self.updateCentroids(points, closest ,centroids)\\n\\n return centroids\",\n \"def __move_centroids(self, data):\\n \\n for i in range(len(self.centroids)):\\n members_cluster = data[self.clusters == i]\\n self.centroids[i] = np.sum(members_cluster, axis=0) / (len(members_cluster) + self.epsilon)\",\n \"def kmean(X,initial_centroids,max_iters):\\n m = np.size(X,0)\\n K = np.size(initial_centroids,0)\\n centroids = initial_centroids\\n idx = np.zeros((m,1))\\n for i in range(1,max_iters):\\n idx = nearest_cluster(X,centroids)\\n centroids = update_centroids(X,idx,K)\\n return centroids,idx\",\n \"def findClusters(data):\\n\\tcentroids = data[0, None]\\n\\tmin_R = 0.1\\n\\n\\tfor _ in range(8):\\n\\t\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\t\\tpotentials = (1 / dists).sum(axis=1)\\n\\n\\t\\tnew_c_idx = np.argmin(potentials)\\n\\n\\t\\tif np.min(dists[new_c_idx]) < min_R:\\n\\t\\t\\t# if this is close to an existing centroid, stop finding centroids\\n\\t\\t\\tbreak\\n\\n\\t\\tcentroids = np.concatenate([centroids, data[new_c_idx, None]], axis=0)\\n\\n\\tax.scatter(*centroids.T, color='tab:orange')\\n\\n\\t# run a single k-means to find the centroid of each cluster\\n\\tk = centroids.shape[0]\\n\\tdists = np.linalg.norm(data[:, None, :] - centroids[None, :, :], axis=-1)\\n\\tclosest_centroid = np.argmin(dists, axis=-1)\\n\\n\\tfor n in range(k):\\n\\t\\tnew_centroid = data[closest_centroid == n].mean(axis=0)\\n\\t\\tcentroids[n] = new_centroid\\n\\tprint(centroids)\\n\\tax.scatter(*centroids.T, color='tab:blue')\",\n \"def _kmedoids_run(X, n_clusters, dist_func, max_iter=1000, verbose=True):\\n # Get initial centers\\n n_samples, n_features = len(X), 2\\n init_ids = _get_init_centers(n_clusters, X)\\n if verbose:\\n print('Initial centers are: {}'.format(init_ids))\\n centers = init_ids\\n members, costs, tot_cost, dist_mat = _get_cost(X, init_ids, dist_func)\\n cc, swapped = 0, True\\n while True:\\n swapped = False\\n for i in range(n_samples):\\n if i not in centers:\\n for j in range(len(centers)):\\n centers_ = deepcopy(centers)\\n centers_[j] = i\\n members_, costs_, tot_cost_, dist_mat_ = _get_cost(X, centers_, dist_func)\\n if tot_cost_ < tot_cost:\\n members, costs, tot_cost, dist_mat = members_, costs_, tot_cost_, dist_mat_\\n centers = centers_\\n swapped = True\\n if verbose:\\n print('Change centers to {}'.format(centers))\\n if cc > max_iter:\\n if verbose:\\n print('End Searching by reaching maximum iteration')\\n break\\n if not swapped:\\n if verbose:\\n print('End Searching by no swaps')\\n break\\n cc += 1\\n return centers, members, costs, tot_cost, dist_mat\",\n \"def k_neighbors(self, unknown, dataset, k):\\n distances = []\\n for title in dataset:\\n point = dataset[title]\\n distance_to_point = distance.euclidean_distance(point, unknown)\\n distances.append([distance_to_point, title])\\n distances.sort()\\n neighbors = distances[0:k]\\n return neighbors\",\n \"def run(self, points, K):\\n # Get size\\n D, N = points.shape\\n\\n # DxK array initialiezd with random points\\n centroids = points[:, np.random.permutation(N)[:K]]\\n\\n # Assigments 1xN array\\n labels = np.zeros(N)\\n\\n for it in np.arange(self.niter):\\n # 1. Compute distance to all cluster\\n #v1 dirty\\n distances = np.zeros([K, N])\\n for n in np.arange(N):\\n for k in np.arange(K):\\n distances[k, n] = np.sqrt( (points[:, n] - centroids[:, k])**2 ).sum()\\n #distances = np.sqrt(((points - centroids[:, np.newaxis, 0])**2)).sum(axis=0) \\n\\n # 2. Update assigments\\n # v1 dirty\\n for n in np.arange(N):\\n kmin = 0\\n for k in np.arange(1, K):\\n if distances[k, n] <= distances[kmin, n]:\\n kmin = k\\n labels[n] = kmin\\n # v2 quicker\\n #labels = np.argmin(distances, axis=1)\\n\\n # 3. Update mean\\n for k in np.arange(K):\\n centroids[:, k] = np.mean(points[:, labels == k], axis=1)\\n #np.array([points[closest==k].mean(axis=0) for k in range(centroids.shape[0])])\\n\\n return centroids, labels\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def __update_clusters(self, medoids):\\r\\n\\r\\n self.__belong = [0] * len(self.__pointer_data)\\r\\n self.__clusters = [[] for i in range(len(medoids))]\\r\\n for index_point in range(len(self.__pointer_data)):\\r\\n index_optim = -1\\r\\n dist_optim = 0.0\\r\\n\\r\\n for index in range(len(medoids)):\\r\\n dist = euclidean_distance_square(self.__pointer_data[index_point], self.__pointer_data[medoids[index]])\\r\\n\\r\\n if (dist < dist_optim) or (index is 0):\\r\\n index_optim = index\\r\\n dist_optim = dist\\r\\n\\r\\n self.__clusters[index_optim].append(index_point)\\r\\n self.__belong[index_point] = index_optim\\r\\n\\r\\n # If cluster is not able to capture object it should be removed\\r\\n self.__clusters = [cluster for cluster in self.__clusters if len(cluster) > 0]\",\n \"def kmeans(points, clusters, threshold=1e-10):\\n diff = threshold + 1.0\\n while diff > threshold:\\n _empty_clusters(clusters)\\n for pt in points:\\n min_dis = sys.maxint\\n min_cls = None\\n for clst in clusters:\\n dis = pt.distance(clst.centroid)\\n if min_dis > dis:\\n min_dis = dis\\n min_cls = clst\\n min_cls.add_point(pt)\\n diff = 0.0\\n\\n for clst in clusters:\\n diff += clst.update()\",\n \"def rmsd_cluster(input, ref, output, clusters):\\n ifs = oemolistream()\\n if not ifs.open(input):\\n OEThrow.Fatal(\\\"Unable to open %s for reading\\\" % input)\\n poses = list()\\n mol = OEMol()\\n while OEReadMolecule(ifs, mol):\\n mol_copy = OEMol(mol)\\n #print(dir(mol_copy))\\n #print(mol_copy.NumConfs())\\n for conf in mol_copy.GetConfs():\\n poses.append(conf)\\n ifs.close()\\n print(\\\"%d poses read\\\" % len(poses))\\n\\n # Create a list of centroids, starting with first molecule.\\n centroids = list()\\n\\n # Make first pose our first centroid.\\n centroids.append(poses.pop(0))\\n if int(clusters) < len(poses):\\n print(\\\"Will return %s poses...\\\" % clusters)\\n else:\\n print(\\\"Will return %s poses...\\\" % (len(poses)+1))\\n while len(centroids) < int(clusters) and len(poses)>0:\\n print(len(centroids))\\n # Compute distance from all poses to closest centroid.\\n min_rmsd = numpy.zeros([len(poses)])\\n for (pose_index, pose) in enumerate(poses):\\n centroids_rmsds = [OERMSD(pose, centroid) for centroid in centroids]\\n min_rmsd[pose_index] = min(centroids_rmsds)\\n # Find pose that is farthest away from all current centroids.\\n farthest_pose_index = min_rmsd.argmax()\\n print(\\\"Farthest pose is %d at %f A away from centroids\\\" % (farthest_pose_index, min_rmsd[farthest_pose_index]))\\n # Move farthest pose to centroids.\\n centroids.append(poses.pop(farthest_pose_index))\\n # Write out all centroids.\\n ofs=oemolostream()\\n if not ofs.open(output):\\n OEThrow.Fatal(\\\"Unable to open %s for writing\\\" % itf.GetString(\\\"-o\\\"))\\n for mol in centroids:\\n #OEWritePDBFile(ofs, mol)\\n OEWriteMolecule(ofs, mol)\\n\\n print(\\\"Done!\\\")\\n\\n return 0\",\n \"def calculate_medoids(self, distances, k=6):\\n m = distances.shape[0] # number of points\\n\\n # Pick k random medoids.\\n curr_medoids = np.array([-1] * k)\\n while not len(np.unique(curr_medoids)) == k:\\n curr_medoids = np.array([random.randint(0, m - 1)\\n for _ in range(k)])\\n # Doesn't matter what we initialize these to.\\n old_medoids = np.array([-1] * k)\\n new_medoids = np.array([-1] * k)\\n\\n # Until the medoids stop updating, do the following:\\n while not ((old_medoids == curr_medoids).all()):\\n # Assign each point to cluster with closest medoid.\\n clusters = self.assign_points_to_clusters(curr_medoids, distances)\\n\\n # Update cluster medoids to be lowest cost point.\\n for curr_medoid in curr_medoids:\\n cluster = np.where(clusters == curr_medoid)[0]\\n new_medoids[curr_medoids == curr_medoid] = self.compute_new_medoid(\\n cluster, distances)\\n\\n old_medoids[:] = curr_medoids[:]\\n curr_medoids[:] = new_medoids[:]\\n\\n return clusters, curr_medoids\",\n \"def pc_cluster(data, clusters):\\n dist = MorningstarPCA.pc_distance(data, clusters)\\n return MorningstarPCA.get_column_with_min_value(dist)\",\n \"def clusters_distance(cluster1, cluster2):\\n return max([euclidean_distance(point1, point2) for point1 in cluster1 for point2 in cluster2])\",\n \"def __update_clusters(self, medoids):\\n\\n self.__belong = [0] * len(self.__pointer_data)\\n self.__clusters = [[] for _ in range(len(medoids))]\\n for index_point in range(len(self.__pointer_data)):\\n index_optim = -1\\n dist_optim = 0.0\\n\\n for index in range(len(medoids)):\\n dist = euclidean_distance_square(\\n self.__pointer_data[index_point],\\n self.__pointer_data[medoids[index]],\\n )\\n\\n if (dist < dist_optim) or (index == 0):\\n index_optim = index\\n dist_optim = dist\\n\\n self.__clusters[index_optim].append(index_point)\\n self.__belong[index_point] = index_optim\\n\\n # If cluster is not able to capture object it should be removed\\n self.__clusters = [\\n cluster for cluster in self.__clusters if len(cluster) > 0\\n ]\",\n \"def closest_cluster(cluster_averages, example):\\n\\n # just do a normal search for a minimum\\n best_index = -1\\n best_distance = 10000000\\n for (i, cluster_average) in enumerate(cluster_averages):\\n distance = dist(cluster_average, example)\\n\\n # easy trick to get a single comparison and negation to check for\\n # invalid number too\\n if distance < best_distance:\\n best_index = i\\n best_distance = distance\\n\\n return best_index\",\n \"def k_means(m: np.array, k: int, max_iter: int):\\n d = m.shape[1]\\n starting_points = {\\n i : np.array([np.random.uniform(-1.0, 1.0) for _ in range(d)])\\n for i in range(k)\\n }\\n\\n for iteration in range(max_iter):\\n assigned_cluster = []\\n vecs_closest_to_k = defaultdict(list)\\n for vec in m:\\n closest_k = get_shortest_k(vec, starting_points)\\n assigned_cluster.append(closest_k)\\n vecs_closest_to_k[closest_k].append(vec)\\n starting_points = {\\n i: starting_points[i] if i not in vecs_closest_to_k else np.average(np.array(vecs_closest_to_k[i]), axis=1)\\n for i in range(k)\\n }\\n\\n return m, assigned_cluster\",\n \"def _relocate_clusters(self, cluster_labels):\\n for cluster_label in range(self.k):\\n if cluster_labels[cluster_label] is not None:\\n # mean of the pixels assigned to cluster\\n p_sum, p_count = np.asarray(\\n cluster_labels[\\n cluster_label\\n ]).sum(axis=0), len(cluster_labels[cluster_label])\\n self._clusters[cluster_label] = p_sum / p_count\",\n \"def find_nearest_neighbors(p, points, k):\\n\\timport numpy as np\\n\\tdistances = np.zeros(points.shape[0])\\n\\tfor i in range(len(distances)):\\n\\t\\tdistances[i] = distance(p,points[i])\\n\\tind = np.argsort(distances)\\n\\treturn ind[0:k]\",\n \"def agglomerative_clustering_in_pretopological_space(X, k, linkage, measure):\\n\\n # validating the X data\\n if X.ndim != 2 or X.shape[0] < 1 or X.shape[1] < 1:\\n raise ValueError('Data must be a valid 2D matrix.')\\n\\n # validating the amount of clusters\\n if k <= 0:\\n raise ValueError('The amount of clusters must be positive.')\\n\\n # validating the linkage method\\n if linkage not in LINKAGE_LIST:\\n raise ValueError('Unknown linkage method.')\\n\\n # the specified metric must be one of the implemented measures\\n if measure not in measures.measure_to_function:\\n raise ValueError('Unknown dissimilarity measure.')\\n\\n # getting the metric function\\n d = measures.measure_to_function[measure]\\n\\n # build distance/dissimilarity matrix\\n dm = squareform(pdist(X, d))\\n\\n # returning the partition obtained for agglomerative clustering in the built space\\n return agglomerative_clustering_in_some_space(dm, k, linkage=linkage, affinity='precomputed')\",\n \"def knn(p, k, x, t):\\r\\n\\r\\n # Number of instances in data set\\r\\n N = x.shape[0]\\r\\n\\r\\n Euclidean_Distance = numpy.square(x - p) #Euclidean distance\\r\\n dis = numpy.sum(Euclidean_Distance, axis=1) #sum of the euclidean distance\\r\\n inds = numpy.argsort(dis)[:k] #sort the indices of the distance array\\r\\n tgt_cat = Counter([t[i] for i in inds]) #count the times of equivalent target labels\\r\\n top_class = max(tgt_cat, key= tgt_cat.get) #top class among the k nearest points\\r\\n\\r\\n\\r\\n #top_class = 0\\r\\n\\r\\n return top_class\",\n \"def predict(self, test_data):\\n if self.centroids_.shape[0]==0:\\n raise ValueError(\\\"No centroids present. Run KMeans.fit first.\\\")\\n\\n print test_data.shape\\n part_of_cluster=np.zeros(test_data.shape[0])\\n for i in range(test_data.shape[0]):\\n dists=[]\\n for c in range(self.centroids_.shape[0]):\\n # compute distance between current train_data instance and each cluster\\n dists.append( self.metric( instance=test_data[i,:], centroid=self.centroids_[c,:]) )\\n \\n # assign point to cluster with minimal distance\\n part_of_cluster[i]=dists.index(min(dists))\\n\\n return part_of_cluster\",\n \"def find_closest_cluster(\\n pose: np.ndarray, clusters: Sequence[Cluster]\\n) -> Optional[int]:\\n # Maybe later we might want to check wrt. the centroid instead of all the\\n # elements, depending on the performances.\\n for cluster_idx, cluster in enumerate(clusters):\\n for clustered_pose in cluster.elements:\\n if pose_close(pose, clustered_pose):\\n # Just assign the first cluster that satisfies the reqs.\\n return cluster_idx\\n\\n return None\",\n \"def mean_min_distance_to_cluster(actual_activation,\\n cluster_activation, n_cluster_samples):\\n if cluster_activation.ndim == 4:\\n actual_activation = actual_activation.dimshuffle('x',0,1,2)\\n squared_distances = T.mean(T.square(cluster_activation -\\n actual_activation), axis=(1,2,3))\\n elif cluster_activation.ndim == 2:\\n actual_activation = actual_activation.dimshuffle('x',0)\\n squared_distances = T.mean(T.square(cluster_activation -\\n actual_activation), axis=(1,))\\n \\n \\n squared_distances_sorted = T.sort(squared_distances)\\n \\n distance = T.mean(squared_distances_sorted[:n_cluster_samples])\\n return distance\",\n \"def get_rank(self) -> int:\\n return dist.get_rank()\",\n \"def splitCluster(self, cluster):\\n\\t\\tmaxValue = self.getMaxValue(self.clusterList[cluster])\\n\\t\\tminValue = self.getMinValue(self.clusterList[cluster])\\n\\t\\tmidValue = round(maxValue - ((maxValue - minValue) / 2))\\n\\n\\t\\t# Create a set of centroid\\n\\t\\tfirstCentroid = random.randint(minValue, midValue)\\n\\t\\tsecondCentroid = random.randint(midValue, maxValue)\\n\\n\\t\\tcpyCluster = self.clusterList[cluster]\\n\\t\\tnextName = str(len(self.clusterList))\\n\\t\\tself.clusterList[cluster] = []\\n\\t\\tself.clusterList[nextName] = []\\n\\n\\t\\tfor value in cpyCluster:\\n\\t\\t\\tif abs(value - firstCentroid) < abs(value - secondCentroid):\\n\\t\\t\\t\\tself.clusterList[cluster].append(value)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.clusterList[nextName].append(value)\\n\\t\\t\\tpass\\n\\t\\tpass\\n\\t\\tprint(self.clusterList)\",\n \"def _nearest_cluster_distance(distances_row, labels, i):\\n label = labels[i]\\n b = np.min([np.mean(distances_row[labels == cur_label])\\n for cur_label in set(labels) if not cur_label == label])\\n return b\",\n \"def cluster(self):\\r\\n\\t\\tself.clusterer.fit(self.koopman_feature_array)\\r\\n\\t\\tself.labels = self.clusterer.labels_\\r\\n\\t\\tfor j in range(max(self.labels)+1):\\r\\n\\t\\t\\tself.koop_cluster_list.append([self.koop_list[i] for i in range(len(self.labels)) if self.labels[i] == j])\\r\\n\\t\\t\\tself.koop_cluster_memb_prob_list.append([self.clusterer.probabilities_[i] for i in range(len(self.labels)) if self.labels[i] == j])\",\n \"def calc_sw(X, cluster_labels):\\n\\n labels = np.array(cluster_labels)\\n labels_set = set(cluster_labels)\\n n_labels = len(labels_set)\\n\\n Sw = []\\n for label in labels_set:\\n # Loop through each cluster and calculate within cluster distance\\n pairs = np.where(labels == label)\\n pairs_distance = pdist(X[pairs[0]])\\n within_cluster_distance = np.sum(pairs_distance, axis=0)\\n Sw.append(within_cluster_distance)\\n\\n return np.sum(Sw)\",\n \"def get_cluster_to_split(clusters):\\n\\treturn max(clusters.items(), key=lambda x: x[1].get_distortion())[1]\",\n \"def assign_to_current_mean(img: np.ndarray, clustermask: np.ndarray) -> float:\\n\\n rows, cols = img.shape[:2]\\n distances = np.zeros((numclusters, 1))\\n overall_dist = 0\\n\\n for i in range(rows):\\n for j in range(cols):\\n distances = distance(img[i, j, :]) # returned shape: (numclusters, 1)\\n \\n k = np.argmin(distances) # closest cluster\\n clustermask.itemset((i, j), k) # update cluster mask\\n overall_dist += distances[k, 0] # sum distance\\n\\n return overall_dist\",\n \"def density_based_cluster(R, clusters):\\n c_points = {}\\n i = 0\\n for cluster in clusters:\\n points = set()\\n for attr in cluster:\\n for point in R[attr]:\\n points.add(point)\\n c_points[i] = points\\n i += 1\\n return c_points\",\n \"def get_clusters(self,points):\\n self.points = points\\n self.__dabest = [self.__cmeans(points,i) for i in range(self.__start,self.__end)]\\n ##self.hull = \\n return self.__dabest\",\n \"def discover_new_cluster(\\n self,\\n n: int,\\n items: List[str],\\n embeddings: np.ndarray,\\n weights: Optional[List[float]] = None,\\n k_neighbours: int = 10,\\n ) -> List[Tuple[float, str]]:\\n # Get all cross-similarities\\n similarity = cosine_similarity(embeddings)\\n \\n # Calculate scores for every row\\n scores = []\\n sorted_idx = similarity.argsort(axis=1) # Get sorted indices (sort on corresponding values)\\n for i, (item, weight) in enumerate(zip(items, weights)):\\n # No point in calculating score if weight equals zero\\n if not weight:\\n scores.append(0)\\n continue\\n \\n # Assign score of zero if labeled entity is in K nearest neighbours\\n top_indices = sorted_idx[i, -k_neighbours:]\\n if any(items[idx] in self._clusters.keys() for idx in top_indices):\\n scores.append(0)\\n \\n # Use accumulated similarity of K nearest neighbours as score\\n else:\\n scores.append(weight * similarity[i, top_indices].sum())\\n \\n # Filter out the highest score item\\n return list(sorted(zip(scores, items), key=lambda x: x[0], reverse=True))[:n]\",\n \"def kMeans(d, k):\\n #First get the random centroids from the data\\n newCentroids = getRandomCentroids(d, k)\\n #newCentroids = [[-2.0, 1.0], [-2.0, -2.0], [2.0, 2.0], [0.0, 0.0]]\\n\\n #Get the clusters from these random centroids\\n clusters = initiateCentroid(d, newCentroids, k)\\n oldCentroids = []\\n\\n counter = 0\\n #While the old centroids are not equal to the new ones\\n while oldCentroids != newCentroids:\\n #old is equal to new\\n oldCentroids = newCentroids\\n #Calculate the new centroids\\n k, newCentroids = calcCentroids(d, clusters)\\n #Calculate the new clusters\\n clusters = initiateCentroid(d, newCentroids, k)\\n #Count how many iterations\\n counter += 1\\n\\n return counter, clusters\",\n \"def move_centroids(self, labelled_clusters):\\n new_centroids = []\\n # print(\\\"Cluster size\\\", end=\\\"\\\\t\\\")\\n for cluster in labelled_clusters:\\n new_centroids.append(self.mean_cluster(cluster))\\n # print(len(cluster), end=\\\"\\\\t\\\" )\\n # print(\\\"\\\\n\\\")\\n return new_centroids\",\n \"def grow_cluster(self):\\n # Need a new list to store cluster points\\n new_cluster_pts = []\\n\\n # Loop through the active points in the perimeter, add the point the cluster with probability p_init\\n active_perimeter = [k for k, v in self.perimeter.items() if bool(v)]\\n for pt in active_perimeter:\\n if self.p >= np.random.rand():\\n new_cluster_pts.append(pt)\\n else:\\n # self.cluster[pt] = False\\n self.perimeter[pt] = False\\n\\n # Check if there are no new points being added to the cluster\\n if len(new_cluster_pts) == 0:\\n self.stopped_growing = True\\n return False\\n\\n # Loop through the new cluster points and add their nearest neighbors to the perimeter\\n for pt in new_cluster_pts:\\n if pt[0] in range(0, self.N) and pt[1] in range(0, self.N):\\n self.cluster[pt] = True\\n self.perimeter[pt] = False\\n self.no_particles += 1\\n self.world[pt[1], pt[0]] = 1\\n self.add_perimeter(pt)\\n else:\\n self.reached_end = True\\n return False\",\n \"def cluster(r: np.ndarray):\\n return np.argmax(r, axis=0)\",\n \"def cluster(players_df, columns):\\n\\toptimal_n=None\\n\\toptimal_clusters=None\\n\\toptimal_clusterer=None\\n\\toptimal_silhouette=-99\\n\\tfor n in range(2,9):\\n\\t\\tclusterer=KMeans(n_clusters=n)\\n\\t\\tcluster_labels=clusterer.fit_predict(players_df[columns])\\n\\t\\tavg_silhouette=silhouette_score(players_df[columns], cluster_labels)\\n\\t\\tprint('The avg silhouette score for {} clusters is {}'.format(n, avg_silhouette))\\n\\t\\tif avg_silhouette > optimal_silhouette:\\n\\t\\t\\toptimal_silhouette=avg_silhouette\\n\\t\\t\\toptimal_clusterer=clusterer\\n\\t\\t\\toptimal_clusters=cluster_labels\\n\\t\\t\\toptimal_n=n\\n\\tprint('Returning optimal clusters found with n={}'.format(optimal_n))\\n\\tclusters = {n: [] for n in range(optimal_n)}\\n\\tfor i, label in enumerate(optimal_clusters):\\n\\t\\tclusters[label].append(\\n\\t\\t\\tdict(\\n\\t\\t\\t\\tplayer_id=players_df.iloc[i]['PERSON_ID'],\\n\\t\\t\\t\\tfirst_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[-1],\\n\\t\\t\\t\\tlast_name=players_df.iloc[i]['DISPLAY_LAST_COMMA_FIRST'].split()[0],\\n\\t\\t\\t\\t)\\n\\t\\t\\t)\\n\\treturn clusters\",\n \"def euclidean_cluster_extract(points, tolerance=2, min_cluster_size=20, max_cluster_size=25000):\\n filtered_points = pclpy.pcl.segmentation.EuclideanClusterExtraction.PointXYZ()\\n kd_tree = pclpy.pcl.search.KdTree.PointXYZ()\\n points_to_cluster = pclpy.pcl.PointCloud.PointXYZ(points)\\n \\n kd_tree.setInputCloud(points_to_cluster)\\n filtered_points.setInputCloud(points_to_cluster)\\n filtered_points.setClusterTolerance(tolerance)\\n filtered_points.setMinClusterSize(min_cluster_size)\\n filtered_points.setMaxClusterSize(max_cluster_size)\\n filtered_points.setSearchMethod(kd_tree)\\n\\n point_indexes = pclpy.pcl.vectors.PointIndices()\\n filtered_points.extract(point_indexes)\\n\\n cluster_list = [points_to_cluster.xyz[i2.indices] for i2 in point_indexes]\\n return cluster_list\",\n \"def calcDistortion(medoids, clusters, class_header=\\\"Class\\\"):\\n distortion = 0\\n for medoid_row_index, medoid_tuple in enumerate(medoids.iterrows()): # For every Medoid\\n for _, datum in clusters[medoid_row_index].iterrows(): # For each point in the medoid cluster\\n # Add the distance between medoid and data point squared to total distortion\\n distortion += (Cluster.calcDistance(medoid_tuple[1], datum, class_header=class_header)) ** 2\\n return distortion\",\n \"def findK_centroids_closest(self, features, clusters):\\n\\n class InnerFeatures:\\n def __init__(self, kps, des, pos):\\n self.kps = kps\\n self.des = des\\n self.pos = pos\\n\\n kmeans = KMeans(n_clusters=clusters)\\n\\n pts = np.array(features.pos)\\n kps = np.array(features.kps)\\n des = np.array(features.des)\\n\\n kmeans.fit(pts)\\n m_clusters = kmeans.labels_.tolist()\\n centers = np.array(kmeans.cluster_centers_)\\n\\n closest, _ = pairwise_distances_argmin_min(kmeans.cluster_centers_, pts)\\n\\n assert len(set(closest)) == clusters\\n\\n result = InnerFeatures(kps[closest], des[closest], pts[closest])\\n return result\",\n \"def _distorted_distance(self):\\n distance = 0\\n for i, pixel in enumerate(self.training_set):\\n distance += self._euclid_distance(\\n pixel, self.clusters[self.labels[i]], axis=0)\\n return distance\",\n \"def recluster(cluster, min_size, guard, func):\\r\\n if cluster.get_length() == 0:\\r\\n return\\r\\n if cluster.get_length() <= min_size:\\r\\n return cluster\\r\\n sim = func(cluster.get_tweets())\\r\\n if sim < guard:\\r\\n kmeans = TweetKMeans(2)\\r\\n kmeans.set_data(cluster.get_tweets())\\r\\n return kmeans.start_algorithm()\\r\\n return cluster\",\n \"def visit_k_nearest(node, pt, k, result):\\n # rather brute force but because cut off and k expected to be rather small\\n # not further optimized\\n # (result could instead of list be a bin heap with at most k items)\\n for active, item in zip(node.active, node.items):\\n # check active items\\n if active:\\n d = distance2(pt, item)\\n result.append( (d, item) )\\n # sort on distance\\n result.sort(key=lambda x: x[0])\\n # keep max k items\\n while len(result) > k:\\n result.pop()\",\n \"def closestCentroids(self, points , centroids ):\\n dists = scipy.spatial.distance.cdist(points,centroids)\\n # 1 is dimension\\n minIds = numpy.argmin(dists, 1)\\n return minIds\",\n \"def get_distances(centroid, points):\\r\\n return np.linalg.norm(points - centroid, axis=1)\",\n \"def predict_cluster(self, point):\\n # assuming point belongs to clusters that were computed by fit functions\\n return self.cluster[tuple(point)]\",\n \"def assign_k_clusters(data, centers):\\n clusters = []\\n center_data = np.take(data, centers, axis=0)\\n best_center = np.argmax(center_data, axis=0)\\n for i in range(len(centers)):\\n inds = [ind for ind in np.where(best_center == i)[0]]\\n clusters.append(inds)\\n return clusters\",\n \"def assign_cluster(node):\\n if (node not in attrs_by_node):\\n return -1\\n else:\\n attrs = list(attrs_by_node[node])\\n if (len(attrs) == 1):\\n return labels[indices_by_vocab[attrs[0]]]\\n else:\\n vec = np.zeros(k, dtype = float)\\n for attr in attrs:\\n vec += features[indices_by_vocab[attr]]\\n vec /= len(attrs)\\n if sphere:\\n vec = normalize(vec)\\n sims = [np.dot(vec, center) for center in centers]\\n else:\\n sims = [-np.linalg.norm(vec - center) for center in centers]\\n max_index, max_sim = -1, -float('inf')\\n for (i, sim) in enumerate(sims):\\n if (sim > max_sim):\\n max_index = i\\n max_sim = sim\\n return max_index\",\n \"def cluster(M, point, eps): # zwraca punkty dla ktorych dystans z punktu point jest mniejszy od eps\\n seeds = []\\n for i in range(0, M.shape[0]):\\n if eps_neighborhood(M, point, i, eps):\\n seeds.append(i)\\n return seeds\",\n \"def nearest_neighbor(non_cancer_data, cancer_data):\\r\\n #status is based on the mean of smallest elements of cancer and non_cancer groups\\r\\n #sort\\r\\n non_cancer_data = sorted(non_cancer_data)\\r\\n cancer_data = sorted(cancer_data)\\r\\n\\r\\n #choose nearest neighbors\\r\\n non_cancer_neighbor = np.mean(non_cancer_data[:2])\\r\\n cancer_neighbor = np.mean(cancer_data[:2])\\r\\n\\r\\n #etermine cell status\\r\\n if non_cancer_neighbor > cancer_neighbor:\\r\\n print(\\\"Negative\\\")\\r\\n else:\\r\\n print(\\\"Positive\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.774409","0.7352601","0.6793966","0.6695094","0.6618769","0.66128606","0.647569","0.6447817","0.638387","0.6371435","0.6332436","0.6308149","0.63051474","0.6276134","0.62399524","0.6237592","0.62352484","0.6164116","0.61512566","0.6150622","0.60985726","0.60867566","0.6032783","0.60309845","0.6004393","0.59903264","0.596755","0.5952811","0.59439194","0.5943123","0.59139824","0.59069824","0.59001696","0.5896834","0.58955055","0.58444715","0.5844026","0.58397496","0.58389866","0.5836943","0.5831759","0.5831525","0.5827932","0.58234435","0.58207005","0.58083904","0.5804167","0.58024037","0.57936984","0.5780323","0.57792497","0.5767139","0.57669234","0.57665986","0.57650566","0.5763236","0.57596","0.5744065","0.5741072","0.57299596","0.5721082","0.5718042","0.57111883","0.57081807","0.5705261","0.5698879","0.5691073","0.56870663","0.5687054","0.56826967","0.5679851","0.56773907","0.5671031","0.56660515","0.56583637","0.56541723","0.5649344","0.5639995","0.5637342","0.5632808","0.56267583","0.5626239","0.5622488","0.56190985","0.5616996","0.56121826","0.5607063","0.5606206","0.56033385","0.56013006","0.55970913","0.5595009","0.55865717","0.5585788","0.5579287","0.555807","0.5555375","0.5551075","0.55475086","0.55458796","0.5543848"],"string":"[\n \"0.774409\",\n \"0.7352601\",\n \"0.6793966\",\n \"0.6695094\",\n \"0.6618769\",\n \"0.66128606\",\n \"0.647569\",\n \"0.6447817\",\n \"0.638387\",\n \"0.6371435\",\n \"0.6332436\",\n \"0.6308149\",\n \"0.63051474\",\n \"0.6276134\",\n \"0.62399524\",\n \"0.6237592\",\n \"0.62352484\",\n \"0.6164116\",\n \"0.61512566\",\n \"0.6150622\",\n \"0.60985726\",\n \"0.60867566\",\n \"0.6032783\",\n \"0.60309845\",\n \"0.6004393\",\n \"0.59903264\",\n \"0.596755\",\n \"0.5952811\",\n \"0.59439194\",\n \"0.5943123\",\n \"0.59139824\",\n \"0.59069824\",\n \"0.59001696\",\n \"0.5896834\",\n \"0.58955055\",\n \"0.58444715\",\n \"0.5844026\",\n \"0.58397496\",\n \"0.58389866\",\n \"0.5836943\",\n \"0.5831759\",\n \"0.5831525\",\n \"0.5827932\",\n \"0.58234435\",\n \"0.58207005\",\n \"0.58083904\",\n \"0.5804167\",\n \"0.58024037\",\n \"0.57936984\",\n \"0.5780323\",\n \"0.57792497\",\n \"0.5767139\",\n \"0.57669234\",\n \"0.57665986\",\n \"0.57650566\",\n \"0.5763236\",\n \"0.57596\",\n \"0.5744065\",\n \"0.5741072\",\n \"0.57299596\",\n \"0.5721082\",\n \"0.5718042\",\n \"0.57111883\",\n \"0.57081807\",\n \"0.5705261\",\n \"0.5698879\",\n \"0.5691073\",\n \"0.56870663\",\n \"0.5687054\",\n \"0.56826967\",\n \"0.5679851\",\n \"0.56773907\",\n \"0.5671031\",\n \"0.56660515\",\n \"0.56583637\",\n \"0.56541723\",\n \"0.5649344\",\n \"0.5639995\",\n \"0.5637342\",\n \"0.5632808\",\n \"0.56267583\",\n \"0.5626239\",\n \"0.5622488\",\n \"0.56190985\",\n \"0.5616996\",\n \"0.56121826\",\n \"0.5607063\",\n \"0.5606206\",\n \"0.56033385\",\n \"0.56013006\",\n \"0.55970913\",\n \"0.5595009\",\n \"0.55865717\",\n \"0.5585788\",\n \"0.5579287\",\n \"0.555807\",\n \"0.5555375\",\n \"0.5551075\",\n \"0.55475086\",\n \"0.55458796\",\n \"0.5543848\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":197,"numItemsPerPage":100,"numTotalItems":95772,"offset":19700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMxNTM4MiwianRpIjoiNDI0YWNkMzktYmY2Zi00ZGI0LWI2MjMtOTE3ODNjYjZiODg2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMTg5ODIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.lA6QEZ-zjnqW6Z_4f9k8ekwKwd_X3ZZGgHWbHWhuJh0Ugl-v0I0bed1EVln4kSR-3bRUAx5AnDFygve_ETHjBw","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 |
|---|---|---|---|---|---|---|
Provides a function which deletes all subparts of a dictionary based on a list of paths. | def glob_filter(exclude_globs: List[str]) -> Callable[[Dict], None]:
def filter_func(state_dict: Dict) -> None:
# Flatten dictionary into paths
paths = []
_flatten_keys(state_dict, paths, '/')
filtered_paths = []
for exclude_glob in exclude_globs:
filtered_paths... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_by_path(data: Dict[str, T], path: Sequence[str]):\n del get_by_path(data, path[:-1])[path[-1]]",
"def _clean_paths(paths):\n\n\tclean_paths = {key: np.concatenate([path[key] for path in paths]) for key in paths[0].keys()}\n\n\treturn clean_paths",
"def delete_keys_from_dict(dictionary, list_keys)... | [
"0.6701357",
"0.66678226",
"0.6317049",
"0.61463994",
"0.6094173",
"0.60304415",
"0.5982631",
"0.5948575",
"0.59154505",
"0.59153736",
"0.59026176",
"0.5891703",
"0.58425975",
"0.58365303",
"0.57102394",
"0.56950706",
"0.5676483",
"0.5665751",
"0.5658024",
"0.5655463",
"0.564... | 0.0 | -1 |
Load a torch checkpoint, catching errors due to backwards compatibility issues. | def safe_torch_load(
composer_states_filepath: Union[Path, str],
map_location: str = 'cpu',
load_fsdp_monolith_rank0_only: bool = False,
) -> Dict[str, Any]:
try:
if not load_fsdp_monolith_rank0_only:
return torch.load(composer_states_filepath, map_location=map_location)
log.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_checkpoint(ckpt_path):\n checkpoint = None\n if ckpt_path:\n logger.info(\"Loading checkpoint from %s\" % ckpt_path)\n checkpoint = torch.load(ckpt_path, map_location=torch.device(\"cpu\"))\n\n if \"model\" in checkpoint.keys():\n # This preserves backward-compat for ... | [
"0.74511135",
"0.7429308",
"0.74096036",
"0.73403966",
"0.72154325",
"0.72154325",
"0.72027546",
"0.7168721",
"0.7161929",
"0.712888",
"0.71182865",
"0.71064115",
"0.7092487",
"0.70710784",
"0.70690227",
"0.7059356",
"0.70333356",
"0.70289314",
"0.69980466",
"0.6958403",
"0.6... | 0.0 | -1 |
Restore a checkpoint into ``state`` and returns the rng state dicts (if ``load_weights_only`` is False). | def _restore_checkpoint(
state: State,
logger: Logger,
composer_states_filepath: str,
extracted_rank_n: bool,
extracted_checkpoint_folder: Optional[str],
load_weights_only: bool,
strict_model_weights: bool,
ignore_keys: Optional[Union[List[str], Callable[[Dict], None]]],
exclude_algo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _restore_training_state(self, restore_state):\n self.load_state_dict(restore_state[\"model\"])\n self.optimizer.load_state_dict(restore_state[\"optimizer\"])\n self.lr_scheduler.load_state_dict(restore_state[\"lr_scheduler\"])\n start_iteration = restore_state[\"iteration\"] + 1\n ... | [
"0.73388803",
"0.72150517",
"0.7131705",
"0.70134574",
"0.6997281",
"0.6942888",
"0.6694779",
"0.6665034",
"0.6642213",
"0.66123784",
"0.65712357",
"0.65587157",
"0.6545347",
"0.6525875",
"0.65182793",
"0.6469714",
"0.64419687",
"0.64180094",
"0.63763607",
"0.63705903",
"0.63... | 0.6288278 | 24 |
Replace a file with its compressed version. The contents will be called ``basename`` inside the compressed archive. | def _compress_file(filename: str, basename: str):
write_mode = _get_write_mode(filename)
with tempfile.TemporaryDirectory() as tmpdir:
shutil.move(filename, os.path.join(tmpdir, basename))
with tarfile.open(filename, write_mode) as tarball:
tarball.add(tmpdir, arcname='') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_file(filename, contents):\n filename = path.join(PATH_ROOT, filename)\n filename_bak = \"%s.release.bak\" % filename\n os.rename(filename, filename_bak)\n with open(filename, \"w\") as out_file:\n out_file.write(\"\".join(contents))\n shutil.copymode(filename_bak, filename)\n o... | [
"0.6415052",
"0.6314928",
"0.6199872",
"0.6001604",
"0.5810293",
"0.5780952",
"0.5752636",
"0.57117546",
"0.5672663",
"0.5574416",
"0.55683494",
"0.55642724",
"0.55603486",
"0.5546732",
"0.5530672",
"0.55286574",
"0.550386",
"0.5496359",
"0.5496359",
"0.54615456",
"0.54451406... | 0.6844481 | 0 |
Save Deepspeed model and tarball the files. | def _save_deepspeed_model(model, filename: str):
write_mode = _get_write_mode(filename)
read_mode = f'r{write_mode[1:]}'
with tempfile.TemporaryDirectory() as tmpdir:
model.save_checkpoint(tmpdir, _DEEPSPEED_TAG)
if os.path.exists(filename):
# extract to tmpdir to append below
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_model(self, step):\n\n # file_name = params['name']\n # pickle.dump(self, gzip.open(file_name, 'wb'))",
"def save(self, path=None):\n if path is None:\n path = os.path.join(logger.get_dir(), \"model.pkl\")\n\n with tempfile.TemporaryDirectory() as td:\n ... | [
"0.6917545",
"0.6801277",
"0.6786645",
"0.6771546",
"0.65725636",
"0.654351",
"0.6506806",
"0.6503191",
"0.6480949",
"0.6474152",
"0.64712524",
"0.64655024",
"0.6454765",
"0.64464855",
"0.643115",
"0.64104533",
"0.6390846",
"0.6343271",
"0.6322349",
"0.6322143",
"0.63072705",... | 0.7130798 | 0 |
Get the association type mapping for a given query string, splitting the category and predicate components apart | def get_association_type_mapping_by_query_string(
query_string: str,
) -> AssociationTypeMapping:
categories = parse_query_string_for_category(query_string)
matching_types = [
a_type for a_type in AssociationTypeMappings.get_mappings() if set(a_type.category) == set(categories)
]
if len(m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup_categories(querystring):\n tokens = tokenize_query(querystring)\n categories = []\n for idx, token in enumerate(tokens):\n if token.type == \"EXTERNAL_COMMAND\":\n categories.append(category.get(token.value, \"Miscellaneous\"))\n elif token.type == \"MACRO\":\n ... | [
"0.58501035",
"0.52250046",
"0.51798195",
"0.48137656",
"0.4768399",
"0.46968216",
"0.4696489",
"0.46959627",
"0.46701097",
"0.46667367",
"0.46602768",
"0.46147487",
"0.46047112",
"0.45540965",
"0.4524083",
"0.4497096",
"0.44962004",
"0.44849357",
"0.4439901",
"0.443559",
"0.... | 0.71058404 | 0 |
Spawner en kopi af instancen til en given position | def spawn(self: T, game_map, x: int, y: int) -> T:
clone = copy.deepcopy(self)
clone.x, clone.y = x, y
clone.parent = game_map
game_map.entities.add(clone)
return clone | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spawn(self, y, x, h, w):\n self.pos = (np.random.randint(y, y + h), np.random.randint(x, x + w))",
"def create(self, pos):\n self.pos = pos",
"def __init__(self, position: Sequence[float], respawn_time: float = 20.0):\n self._position = position\n self._tnt: Optional[Bomb] = None\n ... | [
"0.69008267",
"0.6770838",
"0.6619198",
"0.6575561",
"0.6571484",
"0.65230316",
"0.6420453",
"0.635845",
"0.63377917",
"0.6319819",
"0.62801486",
"0.627715",
"0.62371975",
"0.6227935",
"0.6213373",
"0.6204491",
"0.6200694",
"0.61768955",
"0.61760086",
"0.61162835",
"0.6102015... | 0.6046237 | 25 |
Returns the distance between the current entity and the given (x, y) coordinate. | def distance(self, x: int, y: int) -> float:
return math.sqrt((x - self.x) ** 2 + (y - self.y) ** 2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance_to(self, x, y):\n\t\tdx = x - self.x\n\t\tdy = y - self.y\n\t\treturn math.sqrt((dx**2)+(dy**2))",
"def distance_from_center(self, x: int, y: int) -> float:\n width, height = self.width, self.height\n dis = distance(x, y, width/2, height/2)\n return dis",
"def distance(self, x... | [
"0.81523913",
"0.7383806",
"0.72868764",
"0.7262011",
"0.7195622",
"0.7163461",
"0.7131348",
"0.71239984",
"0.71239984",
"0.71239984",
"0.71239984",
"0.71239984",
"0.71239984",
"0.71239984",
"0.7074517",
"0.70256484",
"0.7024614",
"0.70112294",
"0.68983996",
"0.6831905",
"0.6... | 0.7916495 | 1 |
Process Calculate debit, credit and balance | def _total_d(self):
debit = 0.0
for l in self.data:
debit += l['debit']
self.t_credit += l['credit']
self.t_balance += l['balance']
return debit | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_balance(self,args):\n \"\"\"Can show total, available(available for trading), or reserved(reserved in open orders)\"\"\"\n \"\"\"usage: balance [available/reserved](optional)\"\"\"\n args = stripoffensive(args)\n if 'available' in args:\n btc,usd = available() \n ... | [
"0.658766",
"0.65644854",
"0.6550185",
"0.653063",
"0.64185905",
"0.641678",
"0.63939947",
"0.6387895",
"0.6294101",
"0.6265298",
"0.6234861",
"0.6214223",
"0.6211379",
"0.6209451",
"0.61597407",
"0.6155157",
"0.61335325",
"0.6120291",
"0.61068213",
"0.60987514",
"0.6071012",... | 0.6470188 | 4 |
Process get company name and detail values from account Return Company Name,Address of Company | def _cname(self,account_id):
company = self.pool.get('account.account').browse(self.cr, self.uid, account_id).company_id
self.caddress = self._cadd(company)
return company.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def company(self):\n\n x = 0\n my_company = self.data[\"Company Name\"]\n my_account = self.data[\"Account\"]\n result = []\n for i in my_company:\n my_string = i + \" -- \" + my_account[x]\n x += 1\n result.append(my_string)\n\n return res... | [
"0.69058377",
"0.6532363",
"0.63970184",
"0.6110438",
"0.6075707",
"0.6048244",
"0.6011991",
"0.5984431",
"0.59701777",
"0.58567214",
"0.5844856",
"0.5829678",
"0.58110636",
"0.58070755",
"0.57983863",
"0.5797018",
"0.5794627",
"0.57643694",
"0.5755209",
"0.5755209",
"0.57437... | 0.64875424 | 2 |
Process Monthly period wise report Find all child accounts of parent(Total Accounts = Own + Its child accounts) Get context value to pass on _query_get method Query to get values of account move line period wise Return list of dictionary | def lines(self, form, ids=None, done=None):
moveline_obj = self.pool.get('account.move.line')
cr,uid = self.cr,self.uid
ctx = self.context.copy()
ctx['fiscalyear'] = form['fiscalyear_id']
if form['filter'] == 'filter_period':
ctx['period_from'] = form['period_from']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _query_get(self, cr, uid, obj='l', context=None):\n \n fiscalyear_obj = self.pool.get('account.fiscalyear')\n fiscalperiod_obj = self.pool.get('account.period')\n account_obj = self.pool.get('account.account')\n journal_obj = self.pool.get('account.journal')\n initial_bal = c... | [
"0.6288617",
"0.6161747",
"0.5946709",
"0.58965355",
"0.5824919",
"0.55932254",
"0.551057",
"0.5463138",
"0.545744",
"0.542648",
"0.5404174",
"0.5381288",
"0.52867204",
"0.5258971",
"0.52570456",
"0.51793706",
"0.51743454",
"0.514316",
"0.51324767",
"0.5126693",
"0.5098991",
... | 0.5420634 | 10 |
Make sure that the file is writeable. Useful if our source is readonly. | def _make_writeable(filename):
if not os.access(filename, os.W_OK):
st = os.stat(filename)
new_permissions = stat.S_IMODE(st.st_mode) | stat.S_IWUSR
os.chmod(filename, new_permissions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_can_write(self):\n if self._mode not in WRITE_MODES:\n raise IOError(\"File is not writable\")\n if self.Writable == 'no':\n raise IOError(\"'Writable' flag is 'no'\")",
"def is_writable_file(obj):\n try:\n obj.write(\"\")\n except(AttributeError, OS... | [
"0.7919693",
"0.7208863",
"0.71912867",
"0.715788",
"0.715714",
"0.7111602",
"0.70478153",
"0.6997669",
"0.6925458",
"0.6914876",
"0.68376625",
"0.6644299",
"0.6634337",
"0.65951955",
"0.65799665",
"0.65485585",
"0.65146774",
"0.6463636",
"0.6432738",
"0.642454",
"0.63557035"... | 0.7010632 | 7 |
Similar to forward but only return features. Includes several features from "Jointly Learning to Align and Translate with Transformer Models" (Garg et al., EMNLP 2019). | def extract_features_scriptable(
self,
prev_output_tokens,
encoder_out: Optional[Dict[str, List[Tensor]]],
incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
full_context_alignment: bool = False,
alignment_layer: Optional[int] = None,
alig... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward (self, features, cat_featrs=None):\n \n # cat_featrs = None\n features = features.view (-1, N_FEATURES)\n f_emb = self.features2emb()\n features_2 = torch.matmul (features, f_emb)\n \n # Concatenate the two features (features + their embeddings)\n ... | [
"0.7270778",
"0.72664255",
"0.7230385",
"0.7188819",
"0.7188819",
"0.7116068",
"0.7092778",
"0.6863423",
"0.6840569",
"0.6833632",
"0.6770238",
"0.6749367",
"0.67337835",
"0.66973716",
"0.66973716",
"0.66921663",
"0.66771543",
"0.667196",
"0.66449076",
"0.6639564",
"0.6632218... | 0.0 | -1 |
Project features to the vocabulary size. | def output_layer(self, features):
if self.adaptive_softmax is None:
# project back to size of vocabulary
return self.output_projection(features)
else:
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def review_to_vec(words, model, num_features , index2word_set):\n \n feature_vec = np.zeros((num_features), dtype=\"float32\")\n word_count = 0\n \n \n \n for word in words:\n if word in index2word_set: \n word_count += 1\n feature_vec += model[word]\n\n if word... | [
"0.6354882",
"0.6334816",
"0.62666094",
"0.6220303",
"0.6203577",
"0.616738",
"0.6150227",
"0.6132004",
"0.6092889",
"0.6077156",
"0.6057188",
"0.6045521",
"0.6029445",
"0.6023707",
"0.6004405",
"0.59847",
"0.59653866",
"0.59480286",
"0.5927678",
"0.59204453",
"0.59164006",
... | 0.57181746 | 39 |
Maximum output length supported by the decoder. | def max_positions(self):
if self.embed_positions is None:
return self.max_target_positions
return min(self.max_target_positions, self.embed_positions.max_positions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def len_max(self):\n return 16 + 16 + 8 + 8 + Tools.bin_to_dec(self.get_data_size()) + Tools.bin_to_dec(self.get_verification_size())",
"def setMaxOutputLength(self, value):\n return self._set(maxOutputLength=value)",
"def setMaxOutputLength(self, value):\n return self._set(maxOutputLength... | [
"0.7432989",
"0.73925817",
"0.73925817",
"0.73925817",
"0.7161096",
"0.71449983",
"0.70124006",
"0.69647205",
"0.69551724",
"0.69273204",
"0.68699276",
"0.68549514",
"0.684077",
"0.68397105",
"0.68026745",
"0.6781775",
"0.67704415",
"0.6759464",
"0.6752665",
"0.6748612",
"0.6... | 0.0 | -1 |
Upgrade a (possibly old) state dict for new versions of fairseq. | def upgrade_state_dict_named(self, state_dict, name):
if isinstance(self.embed_positions, SinusoidalPositionalEmbedding):
weights_key = "{}.embed_positions.weights".format(name)
if weights_key in state_dict:
del state_dict[weights_key]
state_dict[
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upgrade_state_dict(self, state_dict):\n return state_dict",
"def upgrade_state_dict(self, state_dict):\n return state_dict",
"def upgrade_state_dict(self, state_dict):\n self.upgrade_state_dict_named(state_dict, \"\")",
"def upgrade_state_dict_named(self, state_dict, name):\n ... | [
"0.7462838",
"0.7462838",
"0.7427273",
"0.67221797",
"0.66385204",
"0.6512428",
"0.6499821",
"0.645798",
"0.62921524",
"0.6210894",
"0.6208642",
"0.6035896",
"0.6035896",
"0.6035896",
"0.60316265",
"0.6010375",
"0.60029566",
"0.59973645",
"0.594021",
"0.58850825",
"0.5855274"... | 0.6633675 | 5 |
Calc md5 32 hexa digits | def calc_md5(string):
return md5(string).hexdigest() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MD5(self) -> _n_0_t_3[_n_0_t_9]:",
"def hash_password(password):\n password_md5 = hashlib.md5(password.encode('utf-8')).hexdigest()\n for i in range(0, len(password_md5), 2):\n if password_md5[i] == '0':\n password_md5 = password_md5[0:i] + 'c' + password_md5[i + 1:]\n return passw... | [
"0.74037653",
"0.73589516",
"0.7223155",
"0.71314096",
"0.7061002",
"0.7040754",
"0.69246835",
"0.69222784",
"0.6914624",
"0.68938214",
"0.6877271",
"0.6828704",
"0.68168634",
"0.67665535",
"0.67429805",
"0.6740992",
"0.6719082",
"0.67109585",
"0.6700948",
"0.66997695",
"0.66... | 0.7135242 | 3 |
Brute force md5 hash | def main():
md5_pass = sys.argv[1]
print brute_force_rec('f', md5_pass) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MD5(self) -> _n_0_t_3[_n_0_t_9]:",
"def _md5(input):\n m = hashlib.md5()\n m.update(input)\n return m.hexdigest()",
"def __hash_md5__(self, text):\n key = hashlib.md5()\n key.update(text.encode('utf-8'))\n return key.digest()",
"def __md5_hash(txt) -> str:\n\n ... | [
"0.8090531",
"0.7789014",
"0.7702612",
"0.76611775",
"0.756921",
"0.7564498",
"0.7545351",
"0.7458243",
"0.74500227",
"0.73919755",
"0.7363182",
"0.7308294",
"0.7295818",
"0.7254136",
"0.71921223",
"0.7171104",
"0.7152653",
"0.71270955",
"0.7125174",
"0.71061033",
"0.70904404... | 0.65695006 | 61 |
Turns dataset into string object | def read_dataset(filetxt):
text = open(filetxt, 'r')
dataset = text.read()
dataset = dataset.strip()
text.close()
return dataset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataAsString(self):\n\n # Force generation of .array\n d = self.asArray()\n slist = []\n for l in self.array:\n s = \"%s %s\" % (self.name, self.rowAsString(l))\n slist.append(s)\n return '\\n'.join(slist)",
"def _convert_to_str(self, data):\n r... | [
"0.65239686",
"0.6491759",
"0.6149112",
"0.61289436",
"0.6053482",
"0.6053482",
"0.60275704",
"0.6023861",
"0.5988325",
"0.5981235",
"0.5981235",
"0.5981235",
"0.5981235",
"0.5981235",
"0.59611607",
"0.59489954",
"0.5908034",
"0.5877692",
"0.5870428",
"0.58585924",
"0.5854603... | 0.0 | -1 |
Turns dataset string separated by \n into a list | def split_dataset(dataset):
sequence = dataset.split()
return sequence | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_grid(self, data):\n return [list(row) for row in data.strip().split(\"\\n\")]",
"def load_data():\n with open('../data/dataset.txt', 'r') as data_file:\n return data_file.read().split('\\n')",
"def format_data(data_string):\n lines = data_string.split('\\\"\\n\\\"')\n split_dat... | [
"0.6875302",
"0.6804295",
"0.6741924",
"0.6668688",
"0.66176885",
"0.6568523",
"0.6558075",
"0.6512331",
"0.65080684",
"0.645106",
"0.6440016",
"0.64314526",
"0.6427407",
"0.6367948",
"0.6280195",
"0.6262507",
"0.62485737",
"0.6235929",
"0.620022",
"0.619506",
"0.6193576",
... | 0.59947836 | 37 |
create dictionary with protein ids and fasta sequence from uniprot site | def open_uniprotsite(prot_names):
fasta_dict = {}
for prot_id in prot_names:
uniprot_link = "https://www.uniprot.org/uniprot/" + prot_id + ".fasta"
uniprot_fasta = urllib.request.urlopen(uniprot_link)
fasta_sequence = uniprot_fasta.readlines()#.decode('utf-8')
fasta_sequenc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prot_sequence_finder(protL):\n \n idDict = prot_id_converter(protL, \"9606\", inpDB = \"genesymbol\",outDB=\"refseqproteingi\")\n seqD = prot_entrez_fetch(idDict, retM=\"gb\", retT=\"fasta\")\n \n protD = {}\n \n for keyS, valueS in idDict.items():\n protD[keyS] = seqD[valueS]\n \n return protD",
... | [
"0.6781977",
"0.6571823",
"0.6411829",
"0.63938284",
"0.6391897",
"0.6324395",
"0.63109064",
"0.6232596",
"0.62234",
"0.6181884",
"0.61223954",
"0.60952413",
"0.6050396",
"0.5965492",
"0.5963545",
"0.5963038",
"0.5939162",
"0.58732736",
"0.5828895",
"0.578113",
"0.57796746",
... | 0.7153276 | 0 |
create dictionary with protein ids and motif positions of N{P}[ST]{P} +overlapping matches | def search_motif(sequences):
motif = re.compile(r'(?=(N[^P](S|T)[^P]))') #N{P}[ST]{P}
motif_index = {}
for key,value in sequences.items():
match_motif = re.finditer(motif, value)
motif_start_list = []
for i in match_motif:
motif_start_list.append(str(i.start()+1))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mapping(reads_list, k, h, index, genome):\n snps_dict = {}\n # Map the read on the genome and store the snps found\n for read in reads_list:\n reversed_read = reverse_read(read)\n reverse = False\n list_mapping = seed_and_extend(read, k, h, index, genome)\n if list_mapping[... | [
"0.58689076",
"0.5789363",
"0.5755219",
"0.5687147",
"0.5647959",
"0.5635121",
"0.5623256",
"0.56161094",
"0.5606003",
"0.5603484",
"0.5583012",
"0.5560962",
"0.55549896",
"0.55387646",
"0.5521165",
"0.55000585",
"0.54610294",
"0.5446249",
"0.54335797",
"0.5430714",
"0.542768... | 0.71227914 | 0 |
Remove every allowed functions from the condition. | def condition_is_valid(self):
cond = self.condition.lower()
cond = re.sub('\s+', ' ', cond)
for ap in self.available_functions:
ap = ap.lower()
ret = re.search(ap, cond)
if ret:
# [('a', 'b'), ('a', 'b'), ...]
self.used_functi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(func):",
"def bypass_conds(self):\n for block in self.get_basic_blocks_followed_by_branches():\n constants = collect_constant_assigns(block.statements)\n branch = block.outgoing_edge[0]\n cond = deepcopy(branch.cond)\n cond = specialize_constants(cond... | [
"0.6023306",
"0.5889629",
"0.5797258",
"0.5612402",
"0.5607669",
"0.55887026",
"0.5466718",
"0.54654783",
"0.5451011",
"0.54385215",
"0.5421896",
"0.5409747",
"0.5409747",
"0.5409747",
"0.5408993",
"0.53844345",
"0.53592044",
"0.5351946",
"0.5325206",
"0.52944034",
"0.5287918... | 0.0 | -1 |
Evaluate the provided object to the condition | def evaluate(self, obj):
#obj._print()
# substitute event's attributes names by their values.
cond = self.condition
for attr in obj._attr_:
cond = re.sub('evt\.%s' % attr, "\"%s\"" % str(obj._attr_[attr]), cond)
# if it remains evt.* objects in the rule, there is a ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, operand: object) -> bool:\n pass",
"def eval(self, Vobj):\n try:\n return Vobj.evaluated_on(self)\n except AttributeError:\n return self.A() * Vobj + self.b()",
"def condition(self) -> global___Expression:",
"def condition(self) -> global___Expres... | [
"0.6598018",
"0.6156341",
"0.6133143",
"0.6133143",
"0.6017951",
"0.59076935",
"0.5841889",
"0.5841889",
"0.5840776",
"0.5840498",
"0.5802535",
"0.57257354",
"0.5681474",
"0.56519026",
"0.56487983",
"0.5630435",
"0.56184256",
"0.56154966",
"0.56067294",
"0.55853695",
"0.55552... | 0.71140516 | 0 |
Execute the action of a rule. This mainly execute a script. We should add parameters passing ;) | def take_action(self, obj):
self.logger.info(
"Rule \"%s\" triggered and now I'm supposed to run the action \"%s\" with the log's object..." %
(self.name, self.action)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute_script(self, action, *args):\n self.host.cmd(('./%s' + len(args) * ' %s') % (action, *args))",
"def execute_action(self, agent, action):\n abstract",
"def _execute(self):\n\n action_name = self.action.lower()\n method_name = action_name.replace('node', 'do')\n met... | [
"0.6758261",
"0.6552314",
"0.6320851",
"0.6226973",
"0.6191258",
"0.6191258",
"0.6187765",
"0.60632503",
"0.5946773",
"0.59280115",
"0.5915756",
"0.59023356",
"0.58932996",
"0.58872306",
"0.5838028",
"0.5825276",
"0.58204365",
"0.57939714",
"0.5788293",
"0.57869744",
"0.57848... | 0.5289828 | 75 |
Gets the assigned_user of this Workitems. | def assigned_user(self):
return self._assigned_user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assignee(self):\n membership = UnitMembershipFactory(unit=self.unit)\n return membership.user",
"def assigned_to(self) -> Optional[str]:\n return pulumi.get(self, \"assigned_to\")",
"def assigned_to(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"assigned_to\")... | [
"0.70582396",
"0.70253783",
"0.68387794",
"0.6594624",
"0.64337957",
"0.63194",
"0.62276447",
"0.61899453",
"0.61852264",
"0.617757",
"0.617757",
"0.6168088",
"0.6168088",
"0.6166981",
"0.612094",
"0.6104734",
"0.6104734",
"0.6104734",
"0.6104734",
"0.606838",
"0.60127085",
... | 0.8579693 | 0 |
Sets the assigned_user of this Workitems. | def assigned_user(self, assigned_user):
self._assigned_user = assigned_user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assigned_by_user(self, assigned_by_user):\n\n self._assigned_by_user = assigned_by_user",
"def assigned_user(self):\n return self._assigned_user",
"def assign_user_to_issue(self, issue, JIRAUsername):\r\n # TODO: Review docs\r\n self.jira.assign_issue(issue=issue, assignee=JIRAUsern... | [
"0.8350922",
"0.68189096",
"0.5876797",
"0.58575225",
"0.57323456",
"0.56373864",
"0.56373864",
"0.55778617",
"0.55627865",
"0.55390745",
"0.55118716",
"0.55098593",
"0.54444087",
"0.54271966",
"0.54271966",
"0.54271966",
"0.54271966",
"0.54271966",
"0.54271966",
"0.54271966",
... | 0.85572076 | 0 |
Gets the author of this Workitems. | def author(self):
return self._author | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_author(self):\n return self.author",
"def get_author(self):\n return self.author",
"def author(self):\n return self._changeset.get('author', None)",
"def author(self):\r\n return self.user",
"def author(self) -> str:\n return self._author",
"def author(self) -> ... | [
"0.81033164",
"0.81033164",
"0.7832732",
"0.7830362",
"0.77745897",
"0.77745897",
"0.7709737",
"0.766907",
"0.76471317",
"0.7558222",
"0.7392863",
"0.7310641",
"0.7100226",
"0.7055616",
"0.69088775",
"0.68823814",
"0.6879495",
"0.68097967",
"0.667739",
"0.6604308",
"0.6585194... | 0.7929328 | 4 |
Sets the author of this Workitems. | def author(self, author):
self._author = author | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_author (self, author):\n self.author = author",
"def set_author(self, author):\n self.author = author\n self.opf.author = author",
"def author(self, author):\n\n self._author = author",
"def author(self, author):\n\n self._author = author",
"def author(self, autho... | [
"0.7831896",
"0.7744839",
"0.7661029",
"0.7661029",
"0.76171625",
"0.7417469",
"0.73834866",
"0.723238",
"0.7022792",
"0.69591576",
"0.69440097",
"0.6846459",
"0.6799037",
"0.6625127",
"0.654796",
"0.6416991",
"0.6416991",
"0.64145887",
"0.6382336",
"0.6332261",
"0.6310402",
... | 0.7739136 | 2 |
Gets the developer of this Workitems. | def developer(self):
return self._developer | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def developer(self):\n return self.proto.creator",
"def get_maintainer(self):\n return self.paragraphs[0].get(\"Maintainer\")",
"def technical_owner(self):\n return self._technical_owner",
"def user(self):\n return self._project.user",
"def is_developer(self):\n\n return ... | [
"0.6467594",
"0.6383037",
"0.59011614",
"0.58858037",
"0.5882263",
"0.58464813",
"0.58373034",
"0.58373034",
"0.58332425",
"0.5788284",
"0.5727513",
"0.5696962",
"0.5679556",
"0.5662634",
"0.56608135",
"0.5650917",
"0.5645489",
"0.5638031",
"0.56320435",
"0.5630453",
"0.56304... | 0.77347624 | 0 |
Sets the developer of this Workitems. | def developer(self, developer):
self._developer = developer | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def developer_certificate_identity(self, developer_certificate_identity):\n\n self._developer_certificate_identity = developer_certificate_identity",
"def developer(self):\n return self._developer",
"def set_maintainer(self, maintainer):\n self.paragraphs[0][\"Maintainer\"] = maintainer",
... | [
"0.6069986",
"0.6056044",
"0.5680614",
"0.5558243",
"0.5480942",
"0.5418043",
"0.53070056",
"0.5263238",
"0.51771384",
"0.51729125",
"0.5170096",
"0.51270753",
"0.50323236",
"0.50323236",
"0.5031481",
"0.49122766",
"0.48889783",
"0.4874513",
"0.48558733",
"0.4839325",
"0.4819... | 0.78007984 | 0 |
Gets the domain of this Workitems. | def domain(self):
return self._domain | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def domain(self):\n # type: () -> string_types\n return self._domain",
"def domain(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"domain\")",
"def get_domain(self):\n return self._domain",
"def _get_domain(self):\n self.ensure_one()\n domain = []\n ... | [
"0.7335138",
"0.7294818",
"0.7221173",
"0.72163355",
"0.71790045",
"0.7176716",
"0.7176716",
"0.7156457",
"0.7156457",
"0.70826006",
"0.7024091",
"0.6920591",
"0.6887922",
"0.6887922",
"0.6887922",
"0.6878303",
"0.68715984",
"0.6822546",
"0.6797321",
"0.6797321",
"0.6797321",... | 0.7219861 | 5 |
Sets the domain of this Workitems. | def domain(self, domain):
self._domain = domain | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def domain(self, domain):\n\n self._domain = domain",
"def domain(self, domain):\n\n self._domain = domain",
"def setDomainRange(self, domain, range):\n self.domain = domain.cloneSpace()\n self.range = range.cloneSpace()\n return",
"def set_domain(self, var, domain) :\n ... | [
"0.6938591",
"0.6938591",
"0.68689",
"0.68229336",
"0.65074587",
"0.647992",
"0.64145446",
"0.6360417",
"0.6316579",
"0.6233607",
"0.62118834",
"0.62118834",
"0.6182328",
"0.61120147",
"0.60630286",
"0.6041117",
"0.6008707",
"0.5991201",
"0.5972056",
"0.596478",
"0.5924517",
... | 0.6992701 | 1 |
Gets the iteration of this Workitems. | def iteration(self):
return self._iteration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iter(self):\n return self._iter",
"def __iter__(self):\n return iter(self._items)",
"def __iter__(self):\n return iter(self._items)",
"def __iter__(self):\r\n return iter(self._items)",
"def __iter__(self):\r\n return iter(self._items)",
"def getIteration(self): ... | [
"0.6821687",
"0.66895986",
"0.66895986",
"0.6630318",
"0.6630318",
"0.6520295",
"0.6465367",
"0.64646924",
"0.64641094",
"0.6435678",
"0.6435678",
"0.64066315",
"0.6316668",
"0.6269533",
"0.62403",
"0.6145356",
"0.611292",
"0.61077815",
"0.6079022",
"0.60638726",
"0.60638726"... | 0.6638763 | 6 |
Sets the iteration of this Workitems. | def iteration(self, iteration):
self._iteration = iteration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, iteration):\n pass",
"def setIterations( self, iterations):\n self.iterations = iterations",
"def it(self, it):\n\n self._it = it",
"def setIterationCount(self, newIterationCount):\n \n pass",
"def i(self, i):\n\n self._i = i",
"def set_all(self, val... | [
"0.6847173",
"0.65657055",
"0.6490476",
"0.6258614",
"0.61279064",
"0.59690887",
"0.5951158",
"0.5938038",
"0.5919914",
"0.5919914",
"0.5919914",
"0.5919914",
"0.58851314",
"0.58851314",
"0.58851314",
"0.58851314",
"0.5750854",
"0.5742167",
"0.57331824",
"0.569525",
"0.569525... | 0.72155607 | 2 |
Gets the module of this Workitems. | def module(self):
return self._module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_module(self):\n return self.module",
"def module(self):\n return self.lib.module",
"def module(self) -> Optional[Module]:\n return self._module",
"def get_module_name(self):\n return self.module_name",
"def get_module(self, name: str) -> ModuleInstance:\n return s... | [
"0.7658881",
"0.7166972",
"0.7157267",
"0.66238433",
"0.6583515",
"0.6492179",
"0.6423812",
"0.63698703",
"0.63572747",
"0.6329867",
"0.63244796",
"0.6299108",
"0.62677187",
"0.62471384",
"0.62409633",
"0.6178302",
"0.61514336",
"0.6147349",
"0.6082053",
"0.603593",
"0.597129... | 0.7441217 | 5 |
Sets the module of this Workitems. | def module(self, module):
self._module = module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_module(self, module):\n setattr(self, \"module\", module)",
"def _setModule(self, module):\n self._module = module",
"def setModule(name, module):",
"def _setModule(self, module):\n self._module = module\n # copy the original module for exploration\n self.n_values =... | [
"0.7361021",
"0.73544645",
"0.69366276",
"0.6877493",
"0.65113515",
"0.6313436",
"0.60764545",
"0.60761255",
"0.5895355",
"0.5888052",
"0.5743862",
"0.5599974",
"0.5553506",
"0.55327725",
"0.55154467",
"0.55154467",
"0.5501181",
"0.5475767",
"0.5469222",
"0.5444131",
"0.54159... | 0.6948856 | 4 |
Gets the status of this Workitems. | def status(self):
return self._status | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def status(self) -> pulumi.Output['outputs.JobStatus']:\n return pulumi.get(self, \"status\")",
"def getStatus(self):\n return self._status",
"def get_status(self):\n return self._status",
"def getStatus(self):\n return self.__status",
"def status(self):\n return self._ge... | [
"0.7593097",
"0.75146943",
"0.74803483",
"0.74482",
"0.74374527",
"0.74322176",
"0.742835",
"0.7412562",
"0.73759395",
"0.73736787",
"0.7371924",
"0.7368407",
"0.7368407",
"0.7368407",
"0.73665434",
"0.73664135",
"0.73664135",
"0.73664135",
"0.7341932",
"0.7341932",
"0.731509... | 0.73683554 | 34 |
Sets the status of this Workitems. | def status(self, status):
self._status = status | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setstatus(self, status):\n with self.lock:\n self.status = status",
"def set_status(self, status):\n self.status = status",
"def set_status(self, status):\n self.status = status",
"def set_status(self, status):\n self.status = status",
"def setStatus(self, status)... | [
"0.72003525",
"0.7144866",
"0.7144866",
"0.7144866",
"0.71241933",
"0.71099335",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
"0.6907424",
... | 0.6939003 | 12 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
import simplejson as json
if six.PY2:
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
return json.dumps(sanitize_for_serialization(self), ensure_ascii=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, Workitems):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.80886984",
"0.80886984",
"0.8055307",
"0.7983415",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
"0.79673034",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
Convert a timedomain array `E` to the frequency domain via 2D FFT. `dx` and `dy` are sample spacing in x (leftright, 1st axis) and y (updown, 0th axis) directions. An optional `upsample > 1` will zeropad `E` to obtain an upsampled spectrum. Returns `(spectrum, xf, yf)` where `spectrum` contains the 2D FFT of `E`. If `N... | def makeSpectrum(E, dx, dy, upsample=10):
zeropadded = np.array(E.shape) * upsample
F = fft.fftshift(fft.fft2(E, zeropadded)) / E.size
xf = fft.fftshift(fft.fftfreq(zeropadded[1], d=dx))
yf = fft.fftshift(fft.fftfreq(zeropadded[0], d=dy))
return (F, xf, yf) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fft2d(pm, win, x, /, detrend='constant'):\n x = signal.detrend(x, type=detrend, axis=0) # remove trend or mean from \"time\"\n x = signal.detrend(x, type='constant', axis=1) # remove mean from \"longitude\"\n\n # Use 1D numpy.fft.rfft (identical)\n # Follows Libby's recipe, where instead real is... | [
"0.5888486",
"0.56503826",
"0.5601818",
"0.54491526",
"0.5392617",
"0.5390208",
"0.53717124",
"0.5368106",
"0.5360478",
"0.5329879",
"0.5306462",
"0.524618",
"0.5245024",
"0.524321",
"0.5240639",
"0.5181204",
"0.51742285",
"0.51686364",
"0.5167768",
"0.51577264",
"0.5120336",... | 0.74132943 | 0 |
Test that the bot selects the shortest input string. | def test_strat(strategy, l, expected):
assert strategy(*l) == expected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def give_short():\n short = input('What DNA sequence would you like to match? ')\n short = short.upper()\n return short",
"def test_minlength():\n assert has_min_length(None, 8) is None\n assert has_min_length('abcd1234', 8) is None\n assert has_min_length('a', 8)",
"def check_this_input(self, inp,... | [
"0.62415373",
"0.59910303",
"0.58833826",
"0.58302915",
"0.57707727",
"0.57583714",
"0.5756031",
"0.57520384",
"0.57448035",
"0.5701577",
"0.56848115",
"0.56739223",
"0.5619197",
"0.56118274",
"0.5557221",
"0.55126894",
"0.5511944",
"0.5500234",
"0.54978585",
"0.54975474",
"0... | 0.0 | -1 |
Output a string to the html file with a trailing newline | def outputHtml(s):
htmlFile.write(s + "\n") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_html_page(htmldata, filename):\n begin = \"<html>\\n\\n<body>\\n\\n<p>\\n\"\n end = \"\\n</p>\\n\\n</body>\\n\\n</html>\"\n full_text = begin + htmldata + end\n f = open(filename, \"w\")\n f.write(full_text)\n f.close()",
"def finish(self):\r\n\r\n self.text += \"</html>\\n\"\r\n\... | [
"0.66473573",
"0.66443795",
"0.6528386",
"0.6365278",
"0.63228464",
"0.6304377",
"0.6303967",
"0.6297656",
"0.62927836",
"0.62136006",
"0.6187122",
"0.61672395",
"0.6166157",
"0.6161343",
"0.6142821",
"0.61315984",
"0.6131482",
"0.6089356",
"0.6076196",
"0.6050305",
"0.601354... | 0.8278069 | 0 |
Output the HTML boilerplate at the top of a file | def outputHtmlFileHeader(pageTitle):
outputHtml(
"""
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def common_header_part1(outfile: TextIO, title: str, indexpath: str = \"\") -> None:\n outfile.write(\"<!DOCTYPE HTML>\\n\")\n outfile.write(\"<html lang=\\\"en\\\">\\n\")\n outfile.write(\" <head>\\n\")\n outfile.write(\" <!-- Google tag (gtag.js) -->\\n\")\n outfile.write(\" <script async src=\... | [
"0.66860414",
"0.6647583",
"0.6486037",
"0.6479137",
"0.6328803",
"0.6274983",
"0.60532254",
"0.5973262",
"0.595949",
"0.5949522",
"0.594761",
"0.5927138",
"0.5927138",
"0.5917435",
"0.5899198",
"0.58875376",
"0.58822405",
"0.5860369",
"0.5858839",
"0.5831532",
"0.5831131",
... | 0.65417224 | 2 |
Compute arithmetic mean of a list | def mean(l):
return sum(l) / len(l) if len(l) != 0 else 0.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_mean(lst):\n return list_sum(lst) / len(lst)",
"def getMean(list):\n return sum(list) / len(list)",
"def lmean (inlist):\r\n sum = 0\r\n for item in inlist:\r\n sum = sum + item\r\n return sum/float(len(inlist))",
"def mean(my_list):\n the_mean = sum(my_list) / len(my_list)\... | [
"0.86610144",
"0.85852724",
"0.8468351",
"0.83844525",
"0.82865095",
"0.8281245",
"0.81897223",
"0.8165559",
"0.815529",
"0.814069",
"0.81378514",
"0.81044215",
"0.80317014",
"0.8011878",
"0.8000918",
"0.7990514",
"0.7977984",
"0.7968724",
"0.79624313",
"0.79264283",
"0.79127... | 0.78250355 | 26 |
Compute the geometric mean of a list | def geomean(l):
return math.exp(mean([math.log(v) for v in l if v != 0])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geometric_mean(xs):\n p = 1.0\n for num in xs:\n p = p * num\n return (p)**(1.0/len(xs))",
"def geo_mean(num_list):\n np_array = np.array(num_list)\n return np_array.prod() ** (1.0 / len(np_array))",
"def lgeometricmean (inlist):\r\n mult = 1.0\r\n one_over_n = 1.0/len(inlist)\r... | [
"0.8738079",
"0.8272834",
"0.81446886",
"0.8056818",
"0.8011409",
"0.8007783",
"0.79629153",
"0.79254365",
"0.7901607",
"0.7868861",
"0.7864818",
"0.784954",
"0.78374404",
"0.7753002",
"0.77423346",
"0.766942",
"0.76617575",
"0.76493603",
"0.7628073",
"0.7620105",
"0.757927",... | 0.0 | -1 |
Transpose a hash of hashes so that the inner keys are now outer | def transpose(h):
res = {}
for i in list(h.keys()):
v = h[i]
for j in list(v.keys()):
if not res.get(j, None):
res[j] = {}
res[j][i] = v[j]
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transpose_2d_table(dicts_within_dict_table):\n transposed_table = {}\n for x2 in dicts_within_dict_table:\n for x1 in dicts_within_dict_table[x2]:\n if x1 not in transposed_table:\n transposed_table[x1] = \\\n {x2: dicts_within_d... | [
"0.7166209",
"0.65619993",
"0.5991071",
"0.59697735",
"0.5820064",
"0.5810341",
"0.5809102",
"0.57978475",
"0.5764748",
"0.57150954",
"0.5670478",
"0.5656125",
"0.5622417",
"0.55814767",
"0.55814767",
"0.5565617",
"0.5564947",
"0.5563796",
"0.5557678",
"0.5549799",
"0.5546132... | 0.7801839 | 0 |
Split a string which may contain a number into a tuple of the string without the digits, and the integer value of the digits. We can then use that as a good thing to sort on, so that we get "a5" and "a15" right. | def extractDigits(key):
text = ""
digits = ""
for c in key:
if c in "0123456789":
digits += c
else:
text += c
return (text, 0 if not digits else int(digits)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_num(a_str):\n idx = None\n for i in iter(a_str):\n if i.isdigit():\n idx = a_str.index(i)\n break\n if idx == None:\n return (a_str[:idx], int('1'))\n else:\n return (a_str[:idx], int(a_str[idx:]))",
"def split_num(s):\n i = 0\n while... | [
"0.7999296",
"0.7962896",
"0.7909838",
"0.7309415",
"0.71487594",
"0.6907238",
"0.68968225",
"0.6889628",
"0.67835516",
"0.677049",
"0.6512375",
"0.64990336",
"0.6499031",
"0.6465821",
"0.64021933",
"0.63611853",
"0.63611853",
"0.6291423",
"0.6285332",
"0.62362725",
"0.623576... | 0.5844136 | 37 |
Choose a good ordering for the implementations | def compareFn(impl1, impl2):
for (v1, v2) in zip(
[extractDigits(f.strip()) for f in impl1.split(",")],
[extractDigits(f.strip()) for f in impl2.split(",")],
):
res = comparePair(v1, v2)
if res:
return res
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def order(self):\n raise NotImplementedError()",
"def order_ideal(self, gens):",
"def test_hookimpls_can_be_sorted_by_the_order():\n # given\n hooks = [\n HookImpl(\"what\", \"when\", None, [], 1),\n HookImpl(\"what\", \"when\", None, [], 10),\n HookImpl(\"what\", \"when\", No... | [
"0.73337257",
"0.61040646",
"0.6041241",
"0.60189027",
"0.6015308",
"0.5974476",
"0.5974476",
"0.5907545",
"0.58723503",
"0.57924604",
"0.5774532",
"0.57127625",
"0.57061774",
"0.56941235",
"0.56875736",
"0.56831706",
"0.56466395",
"0.56466395",
"0.56368846",
"0.56287706",
"0... | 0.0 | -1 |
Compute the line colour and point style for each implementation once so that all plots are consistent. | def computeStyles(implv, monotone=False):
# The lengths of the styles and colours lists should be co-prime,
# so that you don't get replication of the same style and colour before
# you have seen the product of the two lengths.
styles = ("+", "*", "o", "^", "D", "v", "x", "p", "s", "h")
if monotone:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_lines(self):\n self._checkfigure()\n for ld in self.lines:\n line = ld['line']\n\n color = ld['color']\n line.set_color(color)\n\n lw = ld['linewidth']\n hlf = ld['highlight factor']\n highlight = hlf if ld['highlighted'] el... | [
"0.64330816",
"0.63422924",
"0.625823",
"0.6153564",
"0.6108134",
"0.5927725",
"0.5922304",
"0.59211296",
"0.59206307",
"0.5802298",
"0.5726381",
"0.57217574",
"0.5707714",
"0.5695703",
"0.568625",
"0.568072",
"0.56716514",
"0.56624395",
"0.56526595",
"0.56420404",
"0.5628221... | 0.5691588 | 14 |
Set up the X axis, including scaling, labels and max/min values | def setupXAxis(plot, minVal, maxVal, label, logarithmic):
plot.set_xlabel(label)
if logarithmic:
plot.set_xscale("log")
plot.set_xlim(minVal, maxVal)
# plot.set_xscale('log', basex=2)
# tickLabels = [1]
# labelValue = minVal
# while labelValue <= maxVal:
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __draw_xaxis(self):\n self.ax.set_xlim(self.xlims)\n # put x ticks on top\n xticks = [1]\n xticks.extend(range(5, self.xmax+5, 5))\n fs = self.settings.rcParams[\"axes.labelsize\"] if self.settings.otherParams[\n \"xlabel.fontsize\"] is None else self.settings.othe... | [
"0.76962334",
"0.7142678",
"0.70777565",
"0.7023679",
"0.6677621",
"0.66705173",
"0.6669855",
"0.66405183",
"0.65903085",
"0.6455307",
"0.64306533",
"0.64306533",
"0.6370854",
"0.6364356",
"0.62985694",
"0.6293797",
"0.6283952",
"0.62325585",
"0.6220945",
"0.61975974",
"0.617... | 0.7718785 | 0 |
Add the legend to the plot, shrinking the plot slightly to make room, since we add the legend outside the plot to the right, or leaving the plot full sized and allowing matplotlib to choose a good placement | def addLegend(ax, lines, impls, legendPos):
# If there's only one piece of data being plotted, there's no need for a legend
# since all the parameters will be in the title.
# Compute the length (in characters) of the longest implementation.
legendLen = max(list(map(len, impls)))
if legendLen == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def legend(self):\n if self.nplots == 1:\n lax = self.ax\n loff = 0.2\n else:\n lax = self.ax1\n loff = 0.4\n box = lax.get_position()\n\n lax.figure.subplots_adjust(bottom=loff) # make space on bottom for legend\n lax.legend(self.plot... | [
"0.8135134",
"0.7360067",
"0.7313128",
"0.73119825",
"0.72300524",
"0.7143622",
"0.7033816",
"0.70186085",
"0.69774044",
"0.6967444",
"0.692776",
"0.6845011",
"0.6801535",
"0.6784947",
"0.6779383",
"0.67106515",
"0.65214556",
"0.6519761",
"0.65141386",
"0.6490154",
"0.6467635... | 0.76351845 | 1 |
Generate a lits of strings to use as labels, given the list of labels. Depending on how many entries there are we may label only every 5th or 10th entry. Doing that really only makes sense if the list of labels is actually numeric with constant delta between them... | def generateLabelsTicks(posns):
if len(posns) <= 10:
return labelsTicks(posns, 1)
elif len(posns) <= 50:
return labelsTicks(posns, 5)
else:
return labelsTicks(posns, 10) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_labels(self, ilines):\n\n llist = []\n for lind, lstr in enumerate(ilines):\n # get label and value list\n rv, label, vals = self.get_label_vals(lstr)\n if rv < 1: continue\n\n nvals = len(vals)\n\n # label = self.find_parent_label(label)\n\n if se... | [
"0.72463655",
"0.69913936",
"0.6633301",
"0.6608494",
"0.65925914",
"0.65915483",
"0.65355",
"0.65144134",
"0.6511961",
"0.6503672",
"0.6500188",
"0.64750016",
"0.6460352",
"0.64051265",
"0.638604",
"0.6364243",
"0.6330974",
"0.63303053",
"0.63243955",
"0.63158953",
"0.626744... | 0.6879352 | 2 |
Generate a heatmap Each experiment becomes a line in the map. We expect the experiments to have names of the form "text number", and all agree on the text. The text then becomes the yaxis name, the number the value used to sort the experiments, and the label associated with each one. | def generateHeatmap(title, unit, labels, sizeValues, xAxisName, legendPos, timeUnit):
fig = preparePlot(title)
ax = fig.axes[0]
impls = sorted(list(sizeValues.keys()), key=cmp_to_key(compareFn))
yposns = [val for (discard, val) in [extractDigits(impl) for impl in impls]]
(yAxisName, discard) = extra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_heatmap(data, labels_dict, file_title, plot_title):\n\n fig = plt.figure()\n ax = sn.heatmap(data,\n linewidths=0.3)\n figure = ax.get_figure()\n\n if labels_dict:\n ax.set_xlabel(labels_dict[\"x\"])\n ax.set_ylabel(labels_dict[\"y\"])\n if plot_title:\n... | [
"0.6487668",
"0.6414247",
"0.64019465",
"0.6235494",
"0.62288266",
"0.6192175",
"0.6147586",
"0.6145392",
"0.6111261",
"0.6063312",
"0.60262156",
"0.59966576",
"0.59835917",
"0.59658575",
"0.59642565",
"0.5914604",
"0.5872015",
"0.58711034",
"0.58513516",
"0.5820075",
"0.5809... | 0.57783556 | 23 |
Generate a single plot, which has various options. The maximum y axis value can be set Grid lines can be plotted across the graph Error bars can be plotted | def generatePlot(
bmName,
yAxisName,
npl,
sizeValues,
deviations=None,
yMax=None,
yMin=None,
yLines=(),
fileSuffix="",
xMin=None,
xLabel="",
logarithmic=False,
legendPos="best",
sortKeyFn=lambda x: x,
timeUnit=None,
):
print("Plot: '" + bmName + "'")
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TwoOrOneValuePlot(no_of_sets, Xax, Ydat1, Ydat2, Label1, Label2,\n xmin, xmax, ymin_1, ymax_1, ymin_2, ymax_2,\n XLab, YLab_1, YLab_2, SupTitle, Title, FileName,\n currentDate, currentTime, Software_version):\n\n rc('font', size=6, weight=... | [
"0.6829554",
"0.661534",
"0.6599279",
"0.6443192",
"0.64005935",
"0.6339009",
"0.6306646",
"0.6288057",
"0.6278511",
"0.62476623",
"0.6240224",
"0.6229401",
"0.62160033",
"0.62088746",
"0.62024546",
"0.6184107",
"0.6181531",
"0.6175892",
"0.61673915",
"0.61650753",
"0.6149910... | 0.66698444 | 1 |
Generate a single bar chart | def generateBarChart(bmName, yAxisName, bins, fileSuffix="", xLabel=""):
fig = plt.figure()
plt.title(bmName)
ax = fig.add_subplot(111)
setupXAxis(ax, 1, len(bins), xLabel, False)
# print "npl: " + str(npl) + " sizeValues " + str(sizeValues)
ax.bar(numpy.arange(len(bins)), bins, 1, color="blue")... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def barGraph(listOfWord, listOfFrequency):\r\n\r\n\tindex = np.arange(len(listOfWord))\r\n\r\n\tplt.title(\"Frekuensi Kemunculan Kata\")\r\n\tplt.barh(index, listOfFrequency)\r\n\tplt.xlabel('Frekuensi')\r\n\tplt.yticks(index, listOfWord, fontsize=6)\r\n\r\n\tplt.show()",
"def _bar_example_1(quantity_by_fruit):\... | [
"0.71167594",
"0.70187116",
"0.6961445",
"0.69579554",
"0.6940399",
"0.69216317",
"0.6876572",
"0.6829726",
"0.6812839",
"0.6810216",
"0.68029815",
"0.67386836",
"0.6736258",
"0.66588956",
"0.6652312",
"0.66424024",
"0.6640939",
"0.66339326",
"0.66232735",
"0.66198415",
"0.66... | 0.6277766 | 42 |
Extract a sorted list of all the second level keys | def extractColumnKeys(array):
columnKeys = set()
for i in list(array.values()):
columnKeys |= set(i.keys())
return sorted(list(columnKeys), key=cmp_to_key(compareFn)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self, depth=None):\n if depth is not None:\n levels = self.levels[0:depth]\n else:\n levels = self.levels\n\n return [level.key for level in levels]",
"def sortedKeys(self):\n sortedItems = self.items()\n compare = lambda x, y: sign(y[1] - x[1])\n... | [
"0.6977336",
"0.69595975",
"0.6898443",
"0.6693866",
"0.65704405",
"0.6485746",
"0.64736134",
"0.64507824",
"0.6409091",
"0.6212825",
"0.61982757",
"0.61745584",
"0.6172122",
"0.6162426",
"0.61520964",
"0.61424357",
"0.61192876",
"0.61134183",
"0.61134183",
"0.61051226",
"0.6... | 0.0 | -1 |
Print an HTML table from a two deep hash. The top level hash keys form the row titles The second level keys the column titles | def outputHtmlTable(
leftmostTitle,
array,
formatFn=lambda x: str(x),
valueFn=lambda x: x,
best="Lowest",
okPercent=5,
):
# Work out what all the column titles should be, we can't assume that each
# row has all of the same data entries
# Sort the numeric entries, then add the non-nu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_table(response, title):\n print title + ':'\n\n if 'rows' not in response:\n print 'Empty response'\n return\n\n rows = response['rows']\n row_format = '{:<20}' + '{:>20}' * 4\n print row_format.format('Keys', 'Clicks', 'Impressions', 'CTR', 'Position')\n for row in rows:\n keys = ''\n ... | [
"0.6904662",
"0.66678137",
"0.66342795",
"0.65841013",
"0.6493956",
"0.6489375",
"0.6478768",
"0.6459146",
"0.64458627",
"0.64458627",
"0.6423975",
"0.6423727",
"0.63952196",
"0.6314732",
"0.6302233",
"0.6301837",
"0.62923825",
"0.62326974",
"0.6199919",
"0.61683637",
"0.6139... | 0.6058267 | 27 |
Output a media wiki formatted table | def mediaWikiTable(leftmostTitle, array, formatFn=lambda x: str(x)):
columnKeys = extractColumnKeys(array)
print("{|")
for t in [leftmostTitle] + [str(k) for k in columnKeys]:
print("!" + " !! ".join(titles))
for k in sorted(array.keys, key=cmp_to_key(compareFn)):
print("|-")
pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_table():\n\n title_list = ('ID', 'Platform', 'Producer', 'Year', 'Elements')\n \n return table, title_list",
"def print_table(self):\n print(\"%-12s%-12s%-12s%-12s%-12s\" % (\"index\",\"balance\",\"payment\",\"interest\",\"amortization\"))\n print(\"-------------------------------... | [
"0.6593098",
"0.65204376",
"0.6463597",
"0.6431361",
"0.643116",
"0.6429846",
"0.63246125",
"0.63038605",
"0.6286171",
"0.626248",
"0.6258474",
"0.6157692",
"0.6144443",
"0.6130239",
"0.6066116",
"0.60581213",
"0.6050008",
"0.60433495",
"0.602486",
"0.60156596",
"0.6002523",
... | 0.7025748 | 0 |
Print info on a linear fit | def linearFit(title, threadCounts, bestTimes, independentVar, unit):
outputHtml("<h1>" + title + "</h1>")
results = {}
impls = sorted(list(bestTimes.keys()), key=cmp_to_key(compareFn))
outputHtml('<table border="1">')
if independentVar[-1] == "s":
independentVar = independentVar[:-1]
out... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show(self):\n print \"Name: \"+str(self.name)\n ss = self.y.shape[0]\n for i in xrange(ss):\n print \"Actual: \"+str(self.y[i])\n print \"Prediction: \"+str(self.a[i])\n print \"\"\n print \"\\n\"",
"def print_fit(funct, fit, cov=False):\n param... | [
"0.6531072",
"0.64496905",
"0.6358777",
"0.6357666",
"0.629485",
"0.6260334",
"0.6251646",
"0.6163279",
"0.6158657",
"0.61278737",
"0.6047489",
"0.6043604",
"0.59669435",
"0.5965726",
"0.5951386",
"0.59207463",
"0.5912625",
"0.5912578",
"0.58851093",
"0.58696395",
"0.5834422"... | 0.53718823 | 97 |
Plot the data and best fit for implementations that contain the given key | def plotFit(title, threadCounts, bestTimes, coeffs, independentVar, unit):
values = {}
for impl in sorted(list(bestTimes.keys()), key=cmp_to_key(compareFn)):
values[impl] = bestTimes[impl]
(tThread, tZero) = coeffs[impl]
values[impl + "(best fit)"] = [
tZero + thread * tThrea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_predictions(ax, key='M19'):\n \n pred = {'TT95': (0.3, 0.27),\n 'R03': (0.5, 0.33),\n 'M19': (0.33, 0.3)}\n \n x = np.array(ax.get_xlim())\n y2d = pred[key][0] * np.ones(2)\n y3d = pred[key][1] * np.ones(2)\n \n ax.plot(x, y2d, color='black', ls='--', lw=0.5)\n ... | [
"0.6572249",
"0.6459799",
"0.6231436",
"0.60326815",
"0.584273",
"0.5824968",
"0.5811195",
"0.57366365",
"0.5727006",
"0.5686137",
"0.56817913",
"0.56704575",
"0.5646141",
"0.56150794",
"0.5598639",
"0.5595212",
"0.55930716",
"0.5543753",
"0.5513676",
"0.55058753",
"0.5436735... | 0.5828787 | 5 |
Convert a measurement with a range suffix into a suitably scaled value | def extractSI(s):
# If this is representing a range, just return it as is.
if "[" in s:
return (s, None)
types = {"T": "Time", "O": "Rate", "A": "Rate", "s": "Seconds", "%": "Percentage"}
du = s.split()
# Preserve integers as such, so that columns like "Threads" generate an X axis "1 2 3",... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval\n outputrange = float(output_interval_end) - float(output_interval_start) #finds leng... | [
"0.6494964",
"0.6392252",
"0.63828164",
"0.6337366",
"0.62488836",
"0.61872506",
"0.6183594",
"0.61008835",
"0.6078754",
"0.6049721",
"0.60395986",
"0.6036124",
"0.60281193",
"0.5985939",
"0.59293014",
"0.5922022",
"0.59183216",
"0.59165215",
"0.59144276",
"0.5909274",
"0.589... | 0.0 | -1 |
Load data into a Pandas' data frame, we're not using this yet... | def readData(f):
line = f.readline()
fieldnames = [x.strip() for x in line.split(",")]
line = f.readline().strip()
data = []
while line != "":
if line[0] != "#":
fields = line.split(",")
data.append((fields[0], [extractSI(v)[0] for v in fields[1:]]))
line = f.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_pandas():\n data = _get_data()\n return du.process_pandas(data, endog_idx=5, exog_idx=[10, 2, 6, 7, 8])",
"def load_pandas():\n data = _get_data()\n return du.process_pandas(data, endog_idx=0)",
"def load_pandas():\n data = _get_data()\n return du.process_pandas(data, endog_idx=0)",
... | [
"0.749106",
"0.74122226",
"0.74122226",
"0.727072",
"0.71829814",
"0.7006",
"0.69675386",
"0.6942656",
"0.6923089",
"0.68960166",
"0.68508947",
"0.68508947",
"0.67666906",
"0.6748329",
"0.67455745",
"0.6717121",
"0.6707512",
"0.6682415",
"0.66772085",
"0.66612744",
"0.6639854... | 0.0 | -1 |
Extract a time from a string of the form "%dm %4.2fs" which is what "time" generates. | def extractTime(s):
msRe = r"([0-9]+)m +([0-9]+\.[0-9]+)s"
matched = re.match(msRe, s)
if matched:
return 60 * int(matched.group(1)) + float(matched.group(2))
# Maybe we don't have any minutes
sRe = r"([0-9]+\.[0-9]+)s"
matched = re.match(sRe, s)
if matched:
return float(matc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_time(s: str):\n return utils.parsers.parse_eng_unit(s, base_unit='s', default=1e-12)",
"def parse_time(value: str) -> float:\n return float(value[:-1]) * TIME[value[-1]]",
"def _get_time(string):\n string = string[0:7] # Drop day\n return string.replace(\"-\", \"\")",
"def parse_time(s... | [
"0.7376245",
"0.69885296",
"0.69597244",
"0.680901",
"0.6714649",
"0.67008376",
"0.66874033",
"0.6630157",
"0.6610557",
"0.65271956",
"0.65221244",
"0.64632",
"0.6434758",
"0.64113086",
"0.6404067",
"0.6317093",
"0.63148624",
"0.6314434",
"0.631036",
"0.6283578",
"0.6228409",... | 0.7262653 | 1 |
Format a number in engineering format, where the exponent is a multiple of 3 | def engFormat(f):
if f == 0.0:
value = 0.0
exponent = 0
else:
exponent = math.log10(-f if f < 0 else f)
if exponent < 0:
exponent = -int(math.ceil(-exponent))
else:
exponent = int(math.floor(exponent))
for i in range(3):
if (exp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_engineering( number, unit = \"\" ):\n if math.isnan(number):\n return \"nan\"\n if number == 0.0:\n return 0\n\n convert_table = {-18:'a', -15:'f', -12:'p', -9:'n', -6:'u',\n -3:'m', -2:'c', -1:'d', 0:'', 3:'k',\n 6:'M', 9:'G', 12... | [
"0.7254678",
"0.6709356",
"0.65849704",
"0.6535096",
"0.64507467",
"0.64036494",
"0.63798475",
"0.6357471",
"0.6309954",
"0.6143084",
"0.61399496",
"0.6122176",
"0.61172795",
"0.6037605",
"0.59719115",
"0.5958524",
"0.58732384",
"0.5864186",
"0.5839863",
"0.5835042",
"0.58245... | 0.6764551 | 1 |
If a measurement has Min and Max, we can convert them into a notional error bar by replacing the name_SD field with a [minNamevalue, maxNamevalue] pair | def convertMinMaxIntoError(m, name, minName, maxName):
minVal = m.__dict__.get(minName, None)
maxVal = m.__dict__.get(maxName, None)
if maxVal == None or minVal == None:
return None
value = m.__dict__[name]
return [[value - minVal], [maxVal - value]] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determinePlotLimits(self):\n max_str = \"up99\"\n min_str = \"dn99\"\n if self.keywords.get(\"limit_type\",\"99per\") == \"minmax\":\n max_str = \"max\"\n min_str = \"min\"\n \n # Determine the min/max of variables over all models\n limits = {... | [
"0.55634105",
"0.5557625",
"0.5547021",
"0.54915667",
"0.53918475",
"0.5362521",
"0.5332207",
"0.5294759",
"0.5274828",
"0.52670044",
"0.5266675",
"0.5235942",
"0.5220849",
"0.51992804",
"0.51608247",
"0.51373273",
"0.51251656",
"0.5120511",
"0.51145077",
"0.5092589",
"0.5086... | 0.66927224 | 0 |
Extract a list of thread counts, The times per benchmark/thread, and standard deviations per benchmark/thread | def summarizeResults(results, what, discard=(), minName=None, maxName=None):
# threadCounts = sorted (transpose(results).keys())
threadCounts = [t for t in list(transpose(results).keys()) if t not in discard]
if not isinstance(threadCounts[0], str):
threadCounts.sort()
sds = {}
meanValue... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getThreads():\r\n return multiprocessing.cpu_count()",
"def count_benchmarks():\n return len(setup_storage().fetch_benchmark({}))",
"def per_cpu_times():\n ret = []\n for user, system, idle, interrupt, dpc in cext.per_cpu_times():\n item = scputimes(user, system, idle, interrupt, dpc)\n ... | [
"0.60619295",
"0.60282296",
"0.60126525",
"0.5891208",
"0.5888971",
"0.58332855",
"0.5748321",
"0.5742721",
"0.57208693",
"0.57146215",
"0.5707351",
"0.5706242",
"0.5697053",
"0.5691065",
"0.56903625",
"0.56756157",
"0.5672929",
"0.56703794",
"0.5642237",
"0.5642025",
"0.5637... | 0.0 | -1 |
Extract a minimum or maximum value for the given key on the fewest number of threads we measured on (anywhere) | def selectedT1(results, what, doMin=True):
selectedCount = min(
[k for k in transpose(results).keys() if not isinstance(k, str)]
)
selectedVal = 1e9 if doMin else -1e9
# print "selectedCount " + str(selectedCount)
comparison = min if doMin else max
for k in list(results.keys()):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def task_6_min_value_list_of_dicts(data: DT, key: str) -> ST:\n purified_from_not_valid_dicts = filter(lambda dic: key in dic, data)\n return min(purified_from_not_valid_dicts, key=lambda dic: dic[key])",
"def get_max_key(dico):\n our_max = 0\n argmax = None\n for key, val in dico.items():\n ... | [
"0.6385478",
"0.6036219",
"0.6012997",
"0.5945911",
"0.5859294",
"0.58188885",
"0.5807972",
"0.5760502",
"0.57217646",
"0.57083887",
"0.56111264",
"0.56076187",
"0.56050617",
"0.5570697",
"0.55512816",
"0.55372494",
"0.5534718",
"0.5507914",
"0.55025536",
"0.5500761",
"0.5477... | 0.5430186 | 23 |
Apply the function to all of the measurements | def transformResults(threadCounts, values, function):
res = {}
for bm in list(values.keys()):
res[bm] = []
for (nThreads, v) in zip(threadCounts, values[bm]):
res[bm].append(None if v == None else function(v, nThreads))
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_fn(self,fn):\r\n \r\n self.check_Data()\r\n for split,data_ in self.processed_data.items():\r\n x = data_['x']\r\n x = np.array([fn(xi) for xi in x])\r\n data_['x'] = x",
"def applyFuncOnValues(self, func):\r\n self._value = func(self._value)... | [
"0.6649706",
"0.6167145",
"0.60951185",
"0.600086",
"0.5972153",
"0.5929994",
"0.57918704",
"0.5734103",
"0.5721275",
"0.5699407",
"0.56757295",
"0.5655823",
"0.56521386",
"0.5651394",
"0.56490105",
"0.5633817",
"0.56256026",
"0.5601849",
"0.55617565",
"0.552346",
"0.5499854"... | 0.0 | -1 |
Compute mean and standard deviation results for duplicate entries in the list of measurements. | def computeStats(results, independentVariable):
common = {}
# Collect lists of the values
for v in results:
test = v.__dict__[independentVariable]
try:
common[test].append(v)
except:
common[test] = [v]
result = []
# Sanity check for number of data it... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _avg_sd_from_list(lst):\n arr = flex.double(lst)\n avg = round(flex.mean(arr), 5)\n std = round(arr.standard_deviation_of_the_sample(), 5)\n return avg, std",
"def stat(lst):\n n = float(len(lst))\n mean = sum(lst) / n\n stdev = sqrt((sum(x * x for x in lst) / n) - (mean ... | [
"0.683622",
"0.673926",
"0.65098774",
"0.6467416",
"0.63125694",
"0.63054687",
"0.62478226",
"0.62117904",
"0.6203736",
"0.6197018",
"0.616801",
"0.6128668",
"0.60844576",
"0.60655826",
"0.6058886",
"0.6038068",
"0.6000037",
"0.5999568",
"0.5967793",
"0.5965543",
"0.59363204"... | 0.64897317 | 3 |
Add an overall mean for the given field | def addOverallMeans(results, fieldNames, fields):
# Work out what the values we already have look like
meanValues = ["Overall Mean"]
geoMeanValues = ["Overall Geometric Mean"]
for name in fieldNames[1:]:
if name in fields:
values = [r.__dict__[name] for r in results]
geoM... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getMean(self, field):\n\n return np.mean([self.fitnesses[i][field] for i in range(len(self.fitnesses))])",
"def fmean(field):\n warnings.simplefilter(\"ignore\")\n return np.nanmean(field, axis=3, keepdims=True)",
"def mean(self, field, axis=None, region=None):\n # \n # If a regi... | [
"0.7278746",
"0.7135875",
"0.6684064",
"0.6644748",
"0.6622957",
"0.65778464",
"0.6480201",
"0.644461",
"0.6373308",
"0.6351624",
"0.6294219",
"0.62699544",
"0.62606704",
"0.6239302",
"0.62274325",
"0.6176736",
"0.6157787",
"0.6149142",
"0.6136901",
"0.61185",
"0.6103634",
... | 0.7149263 | 1 |
Find a good value for the maximum on the Y axis | def computeGoodMax(totalTimes, noerrs):
# Could allow a small amount of space above the top, but it's annnoying for percentages!
# return None
factor = 1.00
maxReading = factor * max(
[max([v for v in l if v != None]) for l in list(totalTimes.values())]
)
if maxReading == 0:
maxR... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y_max(self):\n return self.get_max_value(self.Y_INDEX)",
"def get_y_max(self):\n if len(self._statDict) == 0:\n return -1E10\n\n line_id_list = self._statDict.keys()\n max_y = self._statDict[line_id_list[0]][3]\n for i_plot in range(1, len(line_id_list)):\n ... | [
"0.8277419",
"0.8052967",
"0.78747857",
"0.7690648",
"0.7672491",
"0.7557933",
"0.74574304",
"0.7440886",
"0.7161742",
"0.70999867",
"0.69315743",
"0.6918759",
"0.6918502",
"0.6871075",
"0.68578976",
"0.68520427",
"0.6791778",
"0.67885953",
"0.6769947",
"0.67635864",
"0.67626... | 0.62784785 | 86 |
Return the next nonblank, noncomment line N.B. readline returns a zero length line at EOF. | def readFiltered(f):
line = f.readline()
while line:
line = line.strip()
if len(line) != 0:
if line == "### NEW EXPERIMENT ###":
# print ("readFiltered: ''")
yield ""
elif line[0] != "#":
# print ("readFiltered: '",line,"'")... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_line(fin):\n line = fin.readline()\n\n pos = line.find(\"#\")\n\n while (pos == 0 or line.strip() == \"\") and line:\n line = fin.readline()\n pos = line.find(\"#\")\n\n if pos == -1:\n return line.strip()\n return line[:pos]",
"def _consume_blanklines(self):\n ... | [
"0.7206668",
"0.6796377",
"0.6481613",
"0.6395342",
"0.6350605",
"0.63455814",
"0.63159776",
"0.62680876",
"0.62291354",
"0.6182882",
"0.61470836",
"0.6128067",
"0.6110453",
"0.60997826",
"0.60870755",
"0.60870755",
"0.6078397",
"0.6022083",
"0.5994597",
"0.59730536",
"0.5958... | 0.0 | -1 |
Consume a single experiment from a file. That is either the whole file, or the amount up to a NEW EXPERIMENT line | def readExperiment(getLine, desiredFields, minX, maxX):
try:
title = next(getLine)
except StopIteration:
# We're at the end of the file
return (None, None, None, None)
l = next(getLine)
# print ("Title: " + title)
# print ("l: " + l)
line = next(getLine)
fieldnames... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_experiment(experiment_file, exp_method_template, experiment):\n with open(exp_method_template, 'r') as f:\n exp_text = f.readlines()\n for idx, l in enumerate(exp_text):\n exp_text[idx] = exp_text[idx].replace('EDIT', experiment)\n exp_text[idx] = exp_text[idx].replace('RANDALPHA... | [
"0.5461225",
"0.5247547",
"0.51944584",
"0.5111096",
"0.50642157",
"0.505239",
"0.50488585",
"0.50231916",
"0.49975798",
"0.49756852",
"0.49649516",
"0.4946024",
"0.49411646",
"0.4932227",
"0.49090433",
"0.49063843",
"0.49063843",
"0.49010712",
"0.48967376",
"0.48967376",
"0.... | 0.45445573 | 81 |
Find each set of results with the same first parameter, compute the min of their means and then scale all their results by that. The aim here is to scale results for specific processors in a way that is internally consistent. Scaling each run by its own min can be misleading, since then results which were smaller can l... | def normalizeResults(results, independentVariable, basis):
normValues = {}
if basis == "min":
reduction = min
elif basis == "mean":
reduction = mean
elif basis == "max":
reduction = max
print("Normalising by " + basis)
for k in results.keys():
ik = k.split(",")[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale_together(data, comp):\n scales = []\n guess = 1.\n s = opt.minimize(sq_residuals_in_range, guess, args = (data, comp), \n method = 'Nelder-Mead').x\n return s",
"def cluster_means_scaled(self):\n if self.evaluate_by is not None:\n return(self.merged_scaled_... | [
"0.5730076",
"0.57292515",
"0.5662298",
"0.5552494",
"0.551228",
"0.5499445",
"0.5480341",
"0.5479149",
"0.5476675",
"0.5461815",
"0.5429813",
"0.5428306",
"0.5410855",
"0.5396706",
"0.5393401",
"0.5375831",
"0.5367997",
"0.5347249",
"0.53420913",
"0.5333558",
"0.5322741",
... | 0.6127019 | 0 |
Turn runs of bad characters to have in a filename into a single underscore, remove any trailing underscore | def cleanFilename(fname):
return re.sub("_$", "", re.sub("[ _\n\t/()*,&:;@.]+", "_", fname)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scrub_underscore_suffix(filename):\n scrubbed = re.sub(r\"_[^_]+\\.\", \".\", filename)\n return scrubbed",
"def safe_filename(filename):\n string = str(filename).strip().replace(\" \", \"_\")\n string = re.sub(r\"(?u)[^-\\w.]\", \"_\", string)\n return re.sub(r\"_+\", \"_\", string)",
"def ... | [
"0.84402937",
"0.8271259",
"0.79155785",
"0.78541076",
"0.7842436",
"0.7829296",
"0.7724186",
"0.76734734",
"0.76034737",
"0.75659907",
"0.75494283",
"0.75451845",
"0.75305706",
"0.7522911",
"0.74923533",
"0.7423959",
"0.742056",
"0.7403071",
"0.73820186",
"0.7378246",
"0.737... | 0.8063518 | 2 |
Performs mutations on the children, stochastically, based on the mutation probability. | def _mutate(self, p_mutate, mutation):
self.children = mutation(self.children, p_mutate) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mutation(child_weights):\n for index, _ in enumerate(child_weights):\n # Add a chance for random mutation\n has_mutation = random.uniform(0, 1)\n if has_mutation <= .1:\n child_weights[index] *= random.randint(0, 5)",
"def __mutate(self, chromosomes, mutation_probability):\... | [
"0.7766687",
"0.7341522",
"0.7289419",
"0.7230715",
"0.7209466",
"0.7037261",
"0.6843733",
"0.674903",
"0.6699263",
"0.65760726",
"0.6472517",
"0.61829436",
"0.6166081",
"0.61597234",
"0.6155939",
"0.60983205",
"0.6072234",
"0.60406685",
"0.6036837",
"0.598226",
"0.5959217",
... | 0.71829987 | 5 |
Parents are selected according to fitness probability. | def add_parents(self, sample, fitness, max_parent_per_capita=1.0):
assert isinstance(max_parent_per_capita, Number) and 0 <= max_parent_per_capita <= 1.0
self.size = len(sample)
max_parent_size = int(max_parent_per_capita * self.size)
probabilities = np.cos(fitness) ** 2
r = np... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stochastic_universal_selection(self, fitness, num_parents):\n\n fitness_sum = numpy.sum(fitness)\n if fitness_sum == 0:\n self.logger.error(\"Cannot proceed because the sum of fitness values is zero. Cannot divide by zero.\")\n raise ZeroDivisionError(\"Cannot proceed becaus... | [
"0.7950645",
"0.76420844",
"0.73373795",
"0.7301062",
"0.7292271",
"0.7162419",
"0.7154131",
"0.71514004",
"0.68911153",
"0.679339",
"0.66302663",
"0.66150093",
"0.6567251",
"0.65266013",
"0.6484518",
"0.6401505",
"0.6389962",
"0.63223356",
"0.62270945",
"0.62139714",
"0.6186... | 0.62084496 | 20 |
Check empty, set, test, reset, test. | def test_credentials_set_reset(self):
empty_setting = {
'AccessKeyId': None,
'SecretAccessKey': None,
'SessionToken': None
}
nonempty_setting = {
'AccessKeyId': '1',
'SecretAccessKey': '2',
'SessionToken': '3'
}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_empty(self):\n pass",
"def _test_empty(t):\n return t.is_empty()",
"def test_empty_functions():",
"def isEmpty(self, *args):",
"def check():",
"def is_empty(self):",
"def is_empty(self):",
"def check(self) -> None:",
"def test_is_empty_methods(self):\n\n batch = Batch(Mock... | [
"0.6656806",
"0.64239687",
"0.6303982",
"0.63000506",
"0.6287836",
"0.61566705",
"0.61566705",
"0.6151039",
"0.60715675",
"0.6051508",
"0.6051508",
"0.6051508",
"0.6051508",
"0.60382605",
"0.6027669",
"0.6026403",
"0.5953078",
"0.5922615",
"0.59059507",
"0.5905704",
"0.589207... | 0.0 | -1 |
Initialize the spacecraft and set its initial position | def __init__(self, ai_settings, screen):
super(Ship, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
# Loading spacecraft image and obtaining its external rectangle
self.image = pygame.transform.rotate(pygame.image.load('images/soldier.png'), 90)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_position():\n __maze.init_position()",
"def _init(self, position):\n\t\tself._position = position",
"def __init__(self):\n self.position = 0",
"def __init__(self):\r\n self.position=(0,0)\r\n self.direction = 0.\r\n self.speed = 0\r\n self.state = 0\r\n p... | [
"0.73910457",
"0.6936796",
"0.69150186",
"0.6890182",
"0.6856978",
"0.6777854",
"0.6660125",
"0.66269314",
"0.6598146",
"0.65341693",
"0.6520882",
"0.64898777",
"0.6488802",
"0.6433804",
"0.6430992",
"0.6425387",
"0.63644",
"0.63239896",
"0.63174313",
"0.63057685",
"0.6294312... | 0.60956055 | 43 |
Adjust the position of the spacecraft according to the moving signs | def update(self):
# Update the center value of the ship instead of rect
if self.moving_right and self.rect.right < self.screen_rect.right:
self.center += self.ai_settings.ship_speed_factor
if self.moving_left and self.rect.left > 0:
self.center -= self.ai_settings.sh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_position(self):\n # clamp on upper and lower bounds\n new_pos = self.position[1] + self.velocity\n # TODO: proper centering on borders\n if new_pos >= (config['globals']['HEIGHT'] - int(config['globals']['PAD_HEIGHT'] / 2)\n or new_pos <= int(config['glo... | [
"0.69893175",
"0.6943141",
"0.69328576",
"0.685824",
"0.68279225",
"0.68111914",
"0.6796697",
"0.67530197",
"0.6751285",
"0.6731766",
"0.671755",
"0.6685444",
"0.6650916",
"0.66422963",
"0.66167086",
"0.6610373",
"0.6579091",
"0.65636206",
"0.655607",
"0.65556437",
"0.6530584... | 0.0 | -1 |
Draw the spacecraft at the designated location | def blitme(self):
self.screen.blit(self.image, self.rect) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n #for (x, y) in self.coords:\n # pyxel.rect(\n # (x + self.x) * 4,\n # (y + self.y) * 4,\n # (x + self.x) * 4 + 3,\n # (y + self.y) * 4 + 3,\n # self.color)",
"def draw(self):\n x = self.displacement.x ... | [
"0.7066118",
"0.70287776",
"0.69161975",
"0.68440825",
"0.68423927",
"0.6745069",
"0.67068917",
"0.66786164",
"0.65995675",
"0.6584293",
"0.652891",
"0.6528739",
"0.6506193",
"0.6500058",
"0.64977103",
"0.64929116",
"0.6466362",
"0.6442369",
"0.6441227",
"0.6439538",
"0.64387... | 0.0 | -1 |
Center the ship on the screen | def center_ship(self):
self.center = self.screen_rect.centerx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center_ship(self):\n self.center = self.screen_rect.centerx",
"def center_ship(self):\n self.center = self.screen_rect.centerx",
"def center_ship(self):\n self.center = self.screen_rect.centerx",
"def center_ship(self):\n # Start each new ship at the bottom center\n sel... | [
"0.90181214",
"0.90181214",
"0.90181214",
"0.8599386",
"0.77910644",
"0.761576",
"0.7553747",
"0.7458518",
"0.7252782",
"0.72375983",
"0.7168899",
"0.71423084",
"0.7113291",
"0.7064254",
"0.7018259",
"0.6994591",
"0.6934956",
"0.69271857",
"0.6910503",
"0.69049215",
"0.690492... | 0.90641564 | 1 |
Attach a lot of summaries to a Tensor (for Tensorboard visualization). | def variable_summaries(var):
with tf.name_scope('summaries'):
mean = tf.reduce_mean(var)
tf.summary.scalar('mean', mean)
with tf.name_scope('stddev'):
stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
tf.summary.scalar('stddev', stddev)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_summary(self):\n for k, v in self.metrics.items():\n tf.summary.scalar(k, v)\n \n self.summary_op = tf.summary.merge_all()",
"def build_summaries(self):\n\n # Loss summary.\n tf.summary.scalar('loss', self.loss)\n\n merged = tf.summary.merge_all()\n self.summary_op = merged\n ... | [
"0.7055453",
"0.69594884",
"0.69594884",
"0.679989",
"0.6766926",
"0.67630017",
"0.6671678",
"0.6671673",
"0.6623029",
"0.6601337",
"0.6584152",
"0.6577044",
"0.6568252",
"0.65088475",
"0.6503359",
"0.6411265",
"0.64072824",
"0.63004506",
"0.6281558",
"0.62347925",
"0.6217481... | 0.56149787 | 77 |
Computes the average precision at k. This function computes the average prescision at k between two lists of items. | def apk(actual, predicted, k=10):
if len(predicted) > k:
predicted = predicted[:k]
score = 0.0
num_hits = 0.0
for i, p in enumerate(predicted):
if p in actual and p not in predicted[:i]:
num_hits += 1.0
score += num_hits / (i + 1.0)
# if not actual:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance score length < k')\n return np.mean(r)",
"def precision_at_k(r, k):\n assert k >= 1\n r = np.asarray(r)[:k] != 0\n if r.size != k:\n raise ValueError('Relevance sco... | [
"0.7475594",
"0.74314404",
"0.7328193",
"0.7280659",
"0.7271064",
"0.7129832",
"0.7087148",
"0.6987466",
"0.69284856",
"0.6889254",
"0.68219167",
"0.6814678",
"0.68059695",
"0.6796172",
"0.6774947",
"0.6767025",
"0.6767025",
"0.676344",
"0.66914594",
"0.6675632",
"0.66103244"... | 0.6196564 | 36 |
Load npy of network weights | def load_npy(session, data_path, ignore_missing=False, ignore_params=None):
data_dict = np.load(data_path).item()
for op_name in data_dict:
if ignore_params is None or op_name not in ignore_params:
# print op_name
with tf.variable_scope(op_name, reuse=True):
for p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_weights(self):\n self.npz_weights = np.load(self._weight_file)\n self._load_byte_embedding()\n self._load_cnn_weights()\n self._load_highway()\n self._load_projection()",
"def load_weights(self, weights):\n weight = np.load(weights)\n return weight",
"... | [
"0.777255",
"0.7503046",
"0.72860277",
"0.697063",
"0.6858621",
"0.68511444",
"0.67280126",
"0.6723838",
"0.6582674",
"0.6542274",
"0.64869034",
"0.6420334",
"0.6418078",
"0.63853097",
"0.63563514",
"0.6348038",
"0.6348038",
"0.63442945",
"0.63413405",
"0.63134426",
"0.631223... | 0.5807888 | 57 |
Add headers to both force latest IE rendering engine or Chrome Frame, and also to cache the rendered page for 10 minutes. | def add_header(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, max-age=60'\n return response",
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, m... | [
"0.82235825",
"0.82227623",
"0.82227623",
"0.82227623",
"0.82227623",
"0.8196081",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",
"0.81635857",... | 0.712861 | 62 |
Calculates word frequency for a given text. We don't consider stop words when calculating frequency. | def word_frequency(text):
tokenizer = RegexpTokenizer(r'\w+')
tokens = tokenizer.tokenize(text)
stop = set(stopwords.words('english'))
tokens_without_stop = list(filter(lambda word: word.lower() not in stop, tokens))
counts = Counter(tokens_without_stop)
return counts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_word_counts(text : Text)->Counter:\n return Counter(tokenized_text(text))",
"def frequency(text):\n # TODO: change function input to a textfile?\n import collections\n freq = collections.Counter(text)\n # print freq\n return freq",
"def complexity(text:str) -> float:\n words = ... | [
"0.8071999",
"0.75517035",
"0.74244624",
"0.7402747",
"0.73363006",
"0.7313311",
"0.730345",
"0.72393984",
"0.72356933",
"0.7208666",
"0.7173497",
"0.7112697",
"0.7105219",
"0.7059449",
"0.7059299",
"0.7014396",
"0.7002395",
"0.69982463",
"0.6997513",
"0.69905484",
"0.6984714... | 0.818352 | 0 |
Returns word frequency in format suitable for d3 to use. Returns top 250 words only so that it fits on UI. This limit can be taken as an input from user in future to make this function more usable. | def word_frequency_data_for_d3(text):
counts = word_frequency(text)
list_for_d3 = [{'text': word, 'size': count} for word, count in counts.items() if len(word) > 1 and len(word) > 2]
sorted_list = sorted(list_for_d3, key=lambda item: item['size'], reverse=True)
return sorted_list[:250] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_top_n_words(total_count__of_words, n): # Considering n=10 here as specified in the requirements\n return sorted(total_count__of_words.items(), key=lambda i: i[1], reverse=True)[:n]",
"def count_words(data, number_word_frequency_results=40):\n current_max_sentence_size = 0\n count_word_freq... | [
"0.7272161",
"0.7177371",
"0.7076005",
"0.7043782",
"0.7010348",
"0.6989289",
"0.6973895",
"0.69045085",
"0.6855814",
"0.68073785",
"0.677965",
"0.67379",
"0.67073333",
"0.667007",
"0.666989",
"0.66444814",
"0.6633075",
"0.6630215",
"0.6595672",
"0.65790606",
"0.65766",
"0.... | 0.6641748 | 16 |
Check if a mol has 2D coordinates and if not, calculate them. | def check_2d_coords(mol, force=False):
if not force:
try:
mol.GetConformer()
except ValueError:
force = True # no 2D coords... calculate them
if force:
if USE_AVALON_2D:
pyAv.Generate2DCoords(mol)
else:
mol.Compute2DCoords() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_coords():\n split_coords = row[\"map_coord\"].split(',')\n map_x, map_y = [int(i) for i in split_coords]\n map_x_normed = ((map_x*2) / self.MINIMAP_DIM) - 1\n map_y_normed = -(((map_y*2) / self.MINIMAP_DIM) - 1)\n return map_x_normed, map_y_normed"... | [
"0.6219354",
"0.6077779",
"0.6013348",
"0.584337",
"0.58144647",
"0.5808867",
"0.5737401",
"0.57239455",
"0.56685406",
"0.56669194",
"0.56379074",
"0.56226474",
"0.5609471",
"0.56056577",
"0.5604061",
"0.55906796",
"0.55845845",
"0.5557084",
"0.5556743",
"0.55530614",
"0.5545... | 0.7064952 | 0 |
Returns True, if x is a number (i.e. can be converted to float). | def isnumber(x):
try:
float(x)
return True
except ValueError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_number(x):\n if isinstance(x, (int, float)):\n return True\n else:\n return False",
"def is_float(x):\r\n try:\r\n float(x)\r\n except ValueError:\r\n return False\r\n return True",
"def _is_number(value):\n try:\n float(value)\n re... | [
"0.8831771",
"0.84678894",
"0.8269232",
"0.8268981",
"0.8215385",
"0.81769127",
"0.8087828",
"0.80597544",
"0.8051537",
"0.8027391",
"0.7998552",
"0.7986285",
"0.7984602",
"0.7984602",
"0.7984602",
"0.79576087",
"0.79458576",
"0.79081887",
"0.78952646",
"0.78746027",
"0.78025... | 0.90320134 | 0 |
mode `int` displays similarities not to references but to other internal compounds (just displays the `Similarity` column). | def overview_report(df, cutoff=LIMIT_SIMILARITY_L / 100,
highlight=False, mode="cpd"):
cpp.load_resource("SIM_REFS")
sim_refs = cpp.SIM_REFS
detailed_cpds = []
if isinstance(df, cpp.DataSet):
df = df.data
t = Template(cprt.OVERVIEW_TABLE_HEADER)
if "int" in mode:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mode(self):\n return self._summarize(lambda c: c.mode)",
"def mode(self) -> int:",
"def mode(self) -> str:\r\n ...",
"def get_mode(dataframe):\n mode = lambda x: x.mode() if len(x) > 2 else np.array(x)\n print(dataframe.groupby('face color')['eye color'].agg(mode))",
"def mode(self)... | [
"0.65930176",
"0.6014257",
"0.586596",
"0.5808036",
"0.56258184",
"0.5414828",
"0.53677154",
"0.53506863",
"0.53100467",
"0.5308456",
"0.521769",
"0.5209448",
"0.5180258",
"0.5096023",
"0.5053267",
"0.50504166",
"0.5018957",
"0.5018957",
"0.50172937",
"0.50101167",
"0.4987906... | 0.48514766 | 36 |
For interactive viewing in the notebook. | def show_images(plate_full_name, well):
if not IPYTHON:
return
src_dir = op.join(cp_config["Paths"]["SrcPath"], plate_full_name)
ctrl_images = load_control_images(src_dir)
image_dir = op.join(src_dir, "images")
templ_dict = {}
for ch in range(1, 6):
im = load_image(image_dir, we... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def notebook():\n pass",
"def notebook():\n pass",
"def interactive():\n IPython.start_ipython(argv=[])",
"def jupyter():",
"def _ipython_display_(self):\n with self._sc:\n self._box._ipython_display_()",
"def output_notebook(self):\n self._notebook = True",
"def _ipyt... | [
"0.7690705",
"0.7690705",
"0.73434025",
"0.7072106",
"0.7023148",
"0.6829893",
"0.6669605",
"0.65967554",
"0.6558241",
"0.65490204",
"0.64912015",
"0.6477528",
"0.64667416",
"0.6445142",
"0.6425655",
"0.639713",
"0.639713",
"0.6380591",
"0.6327313",
"0.6292819",
"0.6233279",
... | 0.0 | -1 |
A building block for a dense block. | def conv_block(self, x, params, training, name, memory):
with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
if params.use_bc:
x1 = tf.layers.conv2d(x, 4 * params.growth_rate, kernel_size=1, padding='same', use_bias=False, name='_1_conv')
x1 = tf.layers.dropout(x1, par... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dense_block(x, blocks, name, train_bn):\r\n for i in range(blocks):\r\n x = conv_block(x, 32, name=name + '_block' + str(i + 1), train_bn=train_bn)\r\n return x",
"def _dense_block(self, input_data, name):\n block_input = input_data\n with tf.variable_scope(name):\n for ... | [
"0.66214377",
"0.6609796",
"0.6592855",
"0.6590386",
"0.6504537",
"0.63902044",
"0.62953377",
"0.6231654",
"0.612018",
"0.6036814",
"0.6024914",
"0.6012743",
"0.60080326",
"0.59583706",
"0.5917011",
"0.5887384",
"0.5836732",
"0.5834219",
"0.5789371",
"0.5787604",
"0.5748851",... | 0.0 | -1 |
Instantiates the DenseNet architecture. | def model(self, x, params, training, memory=None):
with tf.variable_scope("_densenet", reuse=tf.AUTO_REUSE):
if params.blocks_size > 0 and params.blocks_num > 0:
blocks_size = [params.blocks_size] * params.blocks_num
elif params.net_name is not None:
pass
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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.a... | [
"0.69732815",
"0.69310397",
"0.6879293",
"0.6875603",
"0.6796704",
"0.6787399",
"0.6776941",
"0.6755538",
"0.673781",
"0.67071885",
"0.66999316",
"0.6690914",
"0.6687706",
"0.6639211",
"0.6602322",
"0.65980804",
"0.6596391",
"0.65892094",
"0.65678",
"0.6567025",
"0.6549191",
... | 0.0 | -1 |
For disordered systems with relaxed atomic positions, it might be better to use initial atomic positions to use the symmetry of the structure (POSCAR_initial). | def run(self):
poscar = Poscar('POSCAR')
number_of_atoms = poscar.get_atoms().get_number_of_atoms()
dummy_symbols = self.create_dummy_symbols(number_of_atoms)
poscar.get_atoms().set_chemical_symbols(dummy_symbols)
poscar.write_poscar('POSCAR_ideal') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def propanolIntermediate():\n coords = [\n [-1.60306996, 0.10333519, 0.50792736],\n [-0.66904416, -0.46962566, -0.55371646],\n [0.67345677, 0.26436258, -0.61179298],\n [1.26292797, -0.10585085, -1.45392921],\n [0.49744830, 1.34089332, -0.75955140],\n [1.47742183, 0.0517... | [
"0.6103005",
"0.59019697",
"0.5630828",
"0.55407274",
"0.55275506",
"0.54735744",
"0.54610157",
"0.54103494",
"0.53193635",
"0.53148454",
"0.5281034",
"0.5277508",
"0.5273492",
"0.5247259",
"0.52436775",
"0.5241989",
"0.52053905",
"0.5181437",
"0.5178617",
"0.51722807",
"0.51... | 0.5067868 | 31 |
Rank points in a cluster based on their distance to the cluster centroid/medoid | def __init__(self, points, clusterer, metric='euclidean', selection_method='centroid'):
self.clusterer = clusterer
self.metric = metric
allowed_methods = ['centroid', 'medoid']
if selection_method not in allowed_methods:
raise ValueError(f'Selection method must be on... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rank_cluster_points_by_distance(self, cluster_id):\n cluster_of_interest = self.embedding_df[self.embedding_df['cluster'] == cluster_id].copy()\n \n if cluster_of_interest.empty:\n raise ValueError(f'Cluster id {cluster_id} not found')\n \n if 'dist_to_rep_poin... | [
"0.774409",
"0.7352601",
"0.6793966",
"0.6695094",
"0.6618769",
"0.66128606",
"0.647569",
"0.6447817",
"0.638387",
"0.6371435",
"0.6332436",
"0.6308149",
"0.63051474",
"0.6276134",
"0.62399524",
"0.6237592",
"0.62352484",
"0.6164116",
"0.61512566",
"0.6150622",
"0.60985726",
... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.