prob_threshold:\\n rect_box = result[0, 0, i, 3:]\\n min_x = int(rect_box[0] * width)\\n min_y = int(rect_box[1] * height)\\n max_x = int(rect_box[2] * width)\\n max_y = int(rect_box[3] * height)\\n frame = cv2.rectangle(frame, (min_x, min_y), (max_x, max_y), (255,0, 0), 1)\\n count_curr = count_curr + 1\\n\\n ### TODO: Calculate and send relevant information on ###\\n\\n ### current_count, total_count and duration to the MQTT server ###\\n ### Topic \\\"person\\\": keys of \\\"count\\\" and \\\"total\\\" ###\\n ### Topic \\\"person/duration\\\": key of \\\"duration\\\" ###\\n\\n # IF new person comes inside imapge\\n if count_curr > count_prev:\\n timer_curr_start = time.time()\\n count_total = count_total + count_curr - count_prev\\n client.publish('person', payload=json.dumps({'total': count_total}))\\n\\n # Calc Person Duration\\n if count_curr < count_prev:\\n timer_curr_delay = time.time() - timer_curr_start\\n client.publish('person/duration', payload=json.dumps({'duration': timer_curr_delay}))\\n\\n # Write out information\\n text_infer = \\\"Inference Delay: {:.3f}ms\\\".format(timer_infer_delay * 1000)\\n text_counter = \\\"Current Counter: {}\\\".format(count_curr)\\n cv2.putText(frame, text_infer, (10, 15),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 0, 0), 1)\\n cv2.putText(frame, text_counter, (10, 30),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1)\\n\\n if count_curr > 0:\\n text_duration = \\\"Current Duration: {:.1f}s\\\".format(time.time() - timer_curr_start)\\n cv2.putText(frame, text_duration, (10, 45),\\n cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 255, 0), 1)\\n\\n count_prev = count_curr\\n client.publish(\\\"person\\\", json.dumps({\\\"count\\\": count_curr}))\\n\\n\\n ### TODO: Send the frame to the FFMPEG server ###\\n sys.stdout.buffer.write(frame)\\n sys.stdout.flush()\\n # Break if escape key pressed\\n if key_pressed == 27:\\n break\\n\\n ### TODO: Write an output image if `single_image_mode` ###\\n\\n # Release the capture and destroy any OpenCV windows\\n cap.release()\\n cv2.destroyAllWindows()\\n client.disconnect()\",\n \"def detect(self, images, verbose=0):\\n assert self.mode == \\\"inference\\\", \\\"Create model in inference mode.\\\"\\n #assert len(images) == self.config.BATCH_SIZE, \\\"len(images) must be equal to BATCH_SIZE\\\"\\n\\n if verbose:\\n log(\\\"Processing {} images\\\".format(len(images)))\\n for image in images:\\n log(\\\"image\\\", image)\\n\\n # Mold inputs to format expected by the neural network\\n molded_images = []\\n for img in images:\\n molded_images.append(mold_image(img))\\n\\n # Validate image sizes\\n # All images in a batch MUST be of the same size\\n image_shape = molded_images[0].shape\\n for g in molded_images[1:]:\\n assert g.shape == image_shape,\\\\\\n \\\"After resizing, all images must have the same size. Check IMAGE_RESIZE_MODE and image sizes.\\\"\\n\\n molded_images = np.asarray(molded_images)\\n if verbose:\\n log(\\\"molded_images\\\", molded_images)\\n # Run object detection\\n y = self.keras_model.predict([molded_images], verbose=0)\\n # Process detections\\n results = []\\n for i, image in enumerate(images):\\n results.append(y[i][0][0][1])\\n return results\",\n \"def make_tflite_inference(ndvi_img_array, model_interpreter):\\n # Get input and output tensors.\\n input_details = model_interpreter.get_input_details()\\n output_details = model_interpreter.get_output_details()\\n\\n # Get Input shape\\n input_shape = input_details[0]['shape']\\n input_data = ndvi_img_array.reshape(input_shape)\\n\\n model_interpreter.set_tensor(input_details[0]['index'], input_data)\\n model_interpreter.invoke()\\n\\n outputs = []\\n\\n for tensor in output_details:\\n output_data = model_interpreter.get_tensor(tensor['index'])\\n outputs.append(output_data[0][0])\\n\\n prediction = outputs[0]\\n\\n return prediction\",\n \"def inference():\\n inf_dataset = dataset\\n net.eval()\\n frames_gen, frame_cnt, rel_props, prop_ticks, prop_scaling = inf_dataset[index]\\n \\n num_crop = args.test_crops\\n length = 3\\n if args.modality == 'Flow':\\n length = 10\\n elif args.modality == 'RGBDiff':\\n length = 18\\n \\n # First get the base_out outputs\\n base_output = torch.autograd.Variable(torch.zeros((num_crop, frame_cnt, base_out_dim)).cuda(),\\n volatile=True)\\n cnt = 0\\n for frames in frames_gen:\\n # frames.shape == [frame_batch_size * num_crops * 3, 224, 224]\\n # frame_batch_size is 4 by default\\n input_var = torch.autograd.Variable(frames.view(-1, length, frames.size(-2), frames.size(-1)).cuda(),\\n volatile=True)\\n base_out = net(input_var, None, None, None, None)\\n bsc = base_out.view(num_crop, -1, base_out_dim)\\n base_output[:, cnt:cnt+bsc.size(1), :] = bsc\\n cnt += bsc.size(1)\\n\\n n_frames = base_output.size(1)\\n assert frame_cnt == n_frames\\n # GLCU\\n step_features = base_output.mean(dim=0).mean(dim=0).unsqueeze(0)\\n gate, glcu_task_pred = net.glcu(step_features)\\n glcu_task_pred = F.softmax(glcu_task_pred.squeeze(), dim=0).data.cpu().numpy()\\n gate = gate.repeat(1, num_crop * n_frames).view(num_crop, n_frames, base_out_dim)\\n if net.additive_glcu:\\n base_output = base_output + gate\\n else:\\n base_output = base_output * gate\\n\\n # output.shape == [num_frames, 7791]\\n output = torch.zeros((frame_cnt, output_dim)).cuda()\\n cnt = 0\\n for i in range(0, frame_cnt, 4):\\n base_out = base_output[:, i:i+4, :].contiguous().view(-1, base_out_dim)\\n rst = net.test_fc(base_out)\\n sc = rst.data.view(num_crop, -1, output_dim).mean(dim=0)\\n output[cnt: cnt + sc.size(0), :] = sc\\n cnt += sc.size(0)\\n base_output = base_output.mean(dim=0).data\\n\\n # act_scores.shape == [num_proposals, K+1]\\n # comp_scores.shape == [num_proposals, K]\\n act_scores, comp_scores, reg_scores = reorg_stpp.forward(output, prop_ticks, prop_scaling)\\n act_scores = torch.autograd.Variable(act_scores, volatile=True)\\n comp_scores = torch.autograd.Variable(comp_scores, volatile=True)\\n\\n # Task Head\\n combined_scores = F.softmax(act_scores[:, 1:], dim=1) * torch.exp(comp_scores)\\n combined_scores = combined_scores.mean(dim=0).unsqueeze(0)\\n task_pred = F.softmax(net.task_head(combined_scores).squeeze(), dim=0).data.cpu().numpy()\\n\\n act_scores = act_scores.data\\n comp_scores = comp_scores.data\\n\\n if reg_scores is not None:\\n reg_scores = reg_scores.view(-1, num_class, 2)\\n reg_scores[:, :, 0] = reg_scores[:, :, 0] * stats[1, 0] + stats[0, 0]\\n reg_scores[:, :, 1] = reg_scores[:, :, 1] * stats[1, 1] + stats[0, 1]\\n\\n torch.cuda.empty_cache() # To empty the cache from previous iterations\\n\\n # perform stpp on scores\\n return ((inf_dataset.video_list[index].id,\\n (rel_props.numpy(), act_scores.cpu().numpy(), comp_scores.cpu().numpy(), reg_scores.cpu().numpy(), \\n glcu_task_pred, task_pred),\\n output.cpu().numpy(),\\n base_output.cpu().numpy()))\",\n \"def inference(self, images, inference_name, channel, mean_pixel, keep_prob):\\n print(\\\"setting up resnet101 initialized conv layers ...\\\")\\n #mean_pixel = np.mean(mean, axis=(0, 1))\\n\\n processed_images = utils.process_image(images, mean_pixel)\\n\\n processed_images = tf.nn.dropout(processed_images, self.input_keep_prob)\\n\\n with tf.variable_scope(inference_name):\\n \\n conv1 = utils_layers.conv2d_layer(processed_images, '1', [7, 7, channel, 64], pool_=3)\\n #Resnet\\n conv_final_layer, image_net = self.resnet.resnet_op(conv1, if_avg_pool=0)\\n\\n #dropout\\n conv_final_layer = tf.nn.dropout(conv_final_layer, keep_prob)\\n W_last = utils.weight_variable([1, 1, 2048, 2], name='W_last')\\n b_last = utils.bias_variable([2], name='b8')\\n conv_last = utils.conv2d_basic(conv_final_layer, W_last, b_last)\\n print('conv_last: ', conv_last.get_shape())\\n #Deconv operator\\n #1. output_shape=[self.batch_size, 14, 14, 1024]\\n conv_t1 = utils_layers.deconv2d_layer(conv_last, 't1', [4,4,1024,2], output_shape=tf.shape(image_net['block3_b22']))\\n fuse_1 = tf.add(conv_t1, image_net['block3_b22'], name=\\\"fuse_1\\\")\\n #2. output_shape=[self.batch_size, 28, 28, 512]\\n conv_t2 = utils_layers.deconv2d_layer(fuse_1, 't2', [4,4,512,1024], output_shape=tf.shape(image_net['block2_b3']))\\n fuse_2 = tf.add(conv_t2, image_net['block2_b3'], name=\\\"fuse_2\\\")\\n #3. output_shape = [self.batch_size, 56, 56, 256]\\n conv_t3 = utils_layers.deconv2d_layer(fuse_2, 't3', [4,4,256,512], output_shape=tf.shape(image_net['block1_b2']))\\n fuse_3 = tf.add(conv_t3, image_net['block1_b2'], name='fuse_3')\\n #4. output_shape=[self.batch_size, 224, 224, 2]\\n shape = tf.shape(images)\\n conv_t4 = utils_layers.deconv2d_layer(fuse_3, 't4', [16, 16, 2, 256], output_shape=[shape[0], shape[1], shape[2], 2], stride=4)\\n \\n annotation_pred = tf.argmax(conv_t4, dimension=3, name=\\\"prediction\\\")\\n\\n logits = conv_t4\\n print('logits shape', logits.shape)\\n\\n\\n return logits\",\n \"def process(self):\\n if self.images == None:\\n return None\\n\\n result = self.tf_session.run(\\n self.output_tensor,\\n feed_dict={self.input_tensor: np.array(self.images)})\\n self.images = None\\n return result\",\n \"def predict(image_data):\\n PAYLOAD = {}\\n PAYLOAD[\\\"timestamp\\\"] = str(datetime.now())\\n PAYLOAD[\\\"inference-type\\\"] = \\\"image-classification\\\"\\n PAYLOAD[\\\"inference-description\\\"] = \\\"Top {} predictions with score {} or above \\\".format(\\n config_utils.MAX_NO_OF_RESULTS, config_utils.SCORE_THRESHOLD\\n )\\n PAYLOAD[\\\"inference-results\\\"] = []\\n\\n try:\\n # Run DLR to perform inference with DLC optimized model\\n model_output = dlr_model.run(image_data)\\n config_utils.logger.info(\\\"pred shape: '{}'.\\\".format(model_output[0][0].shape)) \\n probabilities = softmax(model_output[0][0])\\n config_utils.logger.info(\\\"pred shape softmax: '{}'.\\\".format(probabilities.shape)) \\n sort_classes_by_probability = argsort(probabilities)[::-1]\\n\\n config_utils.logger.info(\\\"pred classes: '{}'.\\\".format(sort_classes_by_probability[: config_utils.MAX_NO_OF_RESULTS])) \\n\\n for i in sort_classes_by_probability[: config_utils.MAX_NO_OF_RESULTS]:\\n if probabilities[i] >= config_utils.SCORE_THRESHOLD:\\n result = {\\\"Label\\\": str(synset[i]), \\\"Score\\\": str(probabilities[i])}\\n PAYLOAD[\\\"inference-results\\\"].append(result)\\n\\n config_utils.logger.info(dumps(PAYLOAD))\\n\\n if config_utils.TOPIC.strip() != \\\"\\\":\\n ipc_utils.IPCUtils().publish_results_to_cloud(PAYLOAD)\\n else:\\n config_utils.logger.info(\\\"No topic set to publish the inference results to the cloud.\\\")\\n\\n except Exception as e:\\n config_utils.logger.error(\\\"Exception occured during prediction: {}\\\".format(e))\",\n \"def slide_inference(self, img, img_meta, rescale):\\n\\n h_stride, w_stride = self.test_cfg.stride\\n h_crop, w_crop = self.test_cfg.crop_size\\n batch_size, _, h_img, w_img = img.size()\\n assert h_crop <= h_img and w_crop <= w_img, (\\n 'crop size should not greater than image size')\\n num_classes = self.num_classes\\n h_grids = max(h_img - h_crop + h_stride - 1, 0) // h_stride + 1\\n w_grids = max(w_img - w_crop + w_stride - 1, 0) // w_stride + 1\\n preds = img.new_zeros((batch_size, num_classes, h_img, w_img))\\n count_mat = img.new_zeros((batch_size, 1, h_img, w_img))\\n for h_idx in range(h_grids):\\n for w_idx in range(w_grids):\\n y1 = h_idx * h_stride\\n x1 = w_idx * w_stride\\n y2 = min(y1 + h_crop, h_img)\\n x2 = min(x1 + w_crop, w_img)\\n y1 = max(y2 - h_crop, 0)\\n x1 = max(x2 - w_crop, 0)\\n crop_img = img[:, :, y1:y2, x1:x2]\\n crop_seg_logit = self.encode_decode(crop_img, img_meta)\\n preds += F.pad(crop_seg_logit,\\n (int(x1), int(preds.shape[3] - x2), int(y1),\\n int(preds.shape[2] - y2)))\\n\\n count_mat[:, :, y1:y2, x1:x2] += 1\\n assert (count_mat == 0).sum() == 0\\n if torch.onnx.is_in_onnx_export():\\n # cast count_mat to constant while exporting to ONNX\\n count_mat = torch.from_numpy(\\n count_mat.cpu().detach().numpy()).to(device=img.device)\\n preds = preds / count_mat\\n if rescale:\\n preds = resize(\\n preds,\\n size=img_meta[0]['ori_shape'][:2],\\n mode='bilinear',\\n align_corners=self.align_corners,\\n warning=False)\\n return preds\",\n \"def run(self, image):\\n # width, height = image.size\\n # resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n # target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n target_size = (self.INPUT_SIZE, self.INPUT_SIZE)\\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\\n net_image = resized_image\\n if params.HZ_preprocess_activate:\\n net_image = params.image_preprocess_func(resized_image)\\n net_image = np.expand_dims(net_image, axis=-1)\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(net_image)]})\\n seg_map = batch_seg_map[0]\\n return resized_image, seg_map\",\n \"def inference(images, hidden1_units, hidden2_units):\\n # Hidden 1\\n with tf.name_scope('hidden1'):\\n weights = tf.Variable(\\n tf.truncated_normal([IMAGE_PIXELS, hidden1_units],\\n stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),\\n name='weights')\\n biases = tf.Variable(tf.zeros([hidden1_units]),\\n name='biases')\\n hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)\\n # Hidden 2\\n with tf.name_scope('hidden2'):\\n weights = tf.Variable(\\n tf.truncated_normal([hidden1_units, hidden2_units],\\n stddev=1.0 / math.sqrt(float(hidden1_units))),\\n name='weights')\\n biases = tf.Variable(tf.zeros([hidden2_units]),\\n name='biases')\\n hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)\\n # Linear\\n with tf.name_scope('softmax_linear'):\\n weights = tf.Variable(\\n tf.truncated_normal([hidden2_units, NUM_CLASSES],\\n stddev=1.0 / math.sqrt(float(hidden2_units))),\\n name='weights')\\n biases = tf.Variable(tf.zeros([NUM_CLASSES]),\\n name='biases')\\n logits = tf.matmul(hidden2, weights) + biases\\n return logits\",\n \"def inference(images):\\n # We instantiate all variables using tf.get_variable() instead of\\n # tf.Variable() in order to share variables across multiple GPU training runs.\\n # If we only ran this model on a single GPU, we could simplify this function\\n # by replacing all instances of tf.get_variable() with tf.Variable().\\n #\\n # conv1\\n with tf.variable_scope('conv1') as scope:\\n kernel = _variable_with_weight_decay('weights',\\n shape=[5, 5, 3, 64],\\n stddev=5e-2,\\n wd=0.0)\\n conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')\\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.0))\\n pre_activation = tf.nn.bias_add(conv, biases)\\n conv1 = tf.nn.relu(pre_activation, name=scope.name)\\n _activation_summary(conv1)\\n\\n # pool1\\n pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\n padding='SAME', name='pool1')\\n # norm1\\n norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,\\n name='norm1')\\n\\n # conv2\\n with tf.variable_scope('conv2') as scope:\\n kernel = _variable_with_weight_decay('weights',\\n shape=[5, 5, 64, 64],\\n stddev=5e-2,\\n wd=0.0)\\n conv = tf.nn.conv2d(norm1, kernel, [1, 1, 1, 1], padding='SAME')\\n biases = _variable_on_cpu('biases', [64], tf.constant_initializer(0.1))\\n pre_activation = tf.nn.bias_add(conv, biases)\\n conv2 = tf.nn.relu(pre_activation, name=scope.name)\\n _activation_summary(conv2)\\n\\n # norm2\\n norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,\\n name='norm2')\\n # pool2\\n pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1],\\n strides=[1, 2, 2, 1], padding='SAME', name='pool2')\\n\\n # local3\\n with tf.variable_scope('local3') as scope:\\n # Move everything into depth so we can perform a single matrix multiply.\\n reshape = tf.reshape(pool2, [FLAGS.batch_size, -1])\\n dim = reshape.get_shape()[1].value\\n weights = _variable_with_weight_decay('weights', shape=[dim, 384],\\n stddev=0.04, wd=0.004)\\n biases = _variable_on_cpu('biases', [384], tf.constant_initializer(0.1))\\n local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\\n _activation_summary(local3)\\n\\n # local4\\n with tf.variable_scope('local4') as scope:\\n weights = _variable_with_weight_decay('weights', shape=[384, 192],\\n stddev=0.04, wd=0.004)\\n biases = _variable_on_cpu('biases', [192], tf.constant_initializer(0.1))\\n local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name)\\n _activation_summary(local4)\\n\\n # linear layer(WX + b),\\n # We don't apply softmax here because\\n # tf.nn.sparse_softmax_cross_entropy_with_logits accepts the unscaled logits\\n # and performs the softmax internally for efficiency.\\n with tf.variable_scope('softmax_linear') as scope:\\n weights = _variable_with_weight_decay('weights', [192, NUM_CLASSES],\\n stddev=1/192.0, wd=0.0)\\n biases = _variable_on_cpu('biases', [NUM_CLASSES],\\n tf.constant_initializer(0.0))\\n softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name)\\n _activation_summary(softmax_linear)\\n\\n return softmax_linear\",\n \"def inference2d(self, image):\\n batch_modulo = image.shape[2] % 64\\n if batch_modulo != 0:\\n batch_pad = 64 - batch_modulo\\n image = nn.ConstantPad3d((0, 0, 0, 0, batch_pad, 0), 0)(image)\\n\\n image = torch.transpose(image.squeeze(0), 0, 1)\\n preds_shape = (image.shape[0], 4, *image.shape[2:])\\n preds = torch.zeros(preds_shape, dtype=image.dtype, device=image.device)\\n for start in range(0, image.shape[0] - 64 + 1, 64):\\n end = start + 64\\n with torch.no_grad():\\n pred = self.module(image[start:end])\\n preds[start:end] = pred.data\\n if batch_modulo != 0:\\n preds = preds[batch_pad:] # type: ignore\\n return torch.transpose(preds, 0, 1).unsqueeze(0)\",\n \"def inference(self, x, inference_args, spemb=None, *args, **kwargs):\\n # setup batch axis\\n ilens = torch.tensor([x.shape[0]], dtype=torch.long, device=x.device)\\n xs = x.unsqueeze(0)\\n if spemb is not None:\\n spembs = spemb.unsqueeze(0)\\n else:\\n spembs = None\\n\\n # get option\\n alpha = getattr(inference_args, \\\"fastspeech_alpha\\\", 1.0)\\n\\n # inference\\n _, outs, _ = self._forward(\\n xs,\\n ilens,\\n spembs=spembs,\\n is_inference=True,\\n alpha=alpha,\\n ) # (1, L, odim)\\n\\n return outs[0], None, None\",\n \"def fallback_inference(self, onnx_model):\\n from polygraphy.comparator import IterationResult\\n\\n with G_LOGGER.verbosity(G_LOGGER.severity + 10):\\n load_model = onnx_backend.ModifyOutputs(onnx_model, outputs=constants.MARK_ALL, copy=True)\\n with onnxrt_backend.OnnxrtRunner(\\n onnxrt_backend.SessionFromOnnx(onnx_backend.BytesFromOnnx(load_model))\\n ) as runner:\\n # We want to set input_metadata only - not user_input_metadata, so that user_input_metadata\\n # will be populated by the --model-inputs argument.\\n data_loader = self.data_loader_args.get_data_loader()\\n data_loader.input_metadata = runner.get_input_metadata()\\n feed_dict = data_loader[0]\\n\\n with G_LOGGER.verbosity(G_LOGGER.severity - 10):\\n G_LOGGER.info(\\n \\\"Running fallback shape inference using input metadata:\\\\n{:}\\\".format(\\n TensorMetadata.from_feed_dict(feed_dict)\\n )\\n )\\n\\n outputs = runner.infer(feed_dict)\\n # We include the inputs here so that we have values for all tensors in the model.\\n outputs.update(feed_dict)\\n # Use IterationResult here since it can handle very large tensors by saving to disk.\\n # Layerwise outputs might otherwise take up too much memory.\\n return IterationResult(outputs), TensorMetadata.from_feed_dict(outputs)\",\n \"def inference(self, input: Union[str, Any]):\\n\\n _input = transform(path=input, sr=16000)\\n F, T = _input.shape\\n\\n x = torch.zeros(1, F, len(_input[0]))\\n x[0, :, :] = _input\\n x = x.unsqueeze(1)\\n \\n x = x.to(self.device)\\n \\n with torch.no_grad():\\n output = self.model(x)\\n \\n if self.model_type == 'multi_class':\\n pred = output.data.max(1, keepdim=True)[1]\\n else:\\n pred = torch.sigmoid(output)\\n pred = pred[:, -1]\\n pred = pred.view(-1).data.cpu().numpy()[0]\\n\\n return (pred, self.idx2label.get(int(pred >= 0.5)))\",\n \"def main():\\n test_image = load_image()\\n\\n pixelate_image(\\n normalize_image(test_image)\\n )\\n pass\",\n \"def inference(images):\\n # We instantiate all variables using tf.get_variable() instead of\\n # tf.Variable() in order to share variables across multiple GPU training runs.\\n # If we only ran this model on a single GPU, we could simplify this function\\n # by replacing all instances of tf.get_variable() with tf.Variable().\\n #\\n # conv1\\n with tf.variable_scope('conv1') as scope:\\n kernel = _variable_with_weight_decay('weights',\\n shape=[5, 5, 3, 64],\\n stddev=5e-2,\\n wd=None)\\n conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')\\n biases = _create_variable('biases', [64], tf.constant_initializer(0.0))\\n pre_activation = tf.nn.bias_add(conv, biases)\\n conv1 = tf.nn.relu(pre_activation, name=scope.name)\\n\\n # pool1\\n pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],\\n padding='SAME', name='pool1')\\n # norm1\\n norm1 = tf.nn.lrn(pool1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,\\n name='norm1')\\n\\n # conv2\\n with tf.variable_scope('conv2') as scope:\\n kernel = _variable_with_weight_decay('weights',\\n shape=[5, 5, 64, 64],\\n stddev=5e-2,\\n wd=None)\\n conv = tf.nn.conv2d(norm1, kernel, [1, 1, 1, 1], padding='SAME')\\n biases = _create_variable('biases', [64], tf.constant_initializer(0.1))\\n pre_activation = tf.nn.bias_add(conv, biases)\\n conv2 = tf.nn.relu(pre_activation, name=scope.name)\\n\\n # norm2\\n norm2 = tf.nn.lrn(conv2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75,\\n name='norm2')\\n # pool2\\n pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1],\\n strides=[1, 2, 2, 1], padding='SAME', name='pool2')\\n\\n # local3\\n with tf.variable_scope('local3') as scope:\\n # Move everything into depth so we can perform a single matrix multiply.\\n reshape = tf.reshape(pool2, [images.get_shape().as_list()[0], -1])\\n dim = reshape.get_shape()[1].value\\n weights = _variable_with_weight_decay('weights', shape=[dim, 384],\\n stddev=0.04, wd=0.004)\\n biases = _create_variable('biases', [384], tf.constant_initializer(0.1))\\n local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\\n\\n # local4\\n with tf.variable_scope('local4') as scope:\\n weights = _variable_with_weight_decay('weights', shape=[384, 192],\\n stddev=0.04, wd=0.004)\\n biases = _create_variable('biases', [192], tf.constant_initializer(0.1))\\n local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name=scope.name)\\n\\n # linear layer(WX + b),\\n # We don't apply softmax here because\\n # tf.nn.sparse_softmax_cross_entropy_with_logits accepts the unscaled logits\\n # and performs the softmax internally for efficiency.\\n with tf.variable_scope('softmax_linear') as scope:\\n weights = _variable_with_weight_decay('weights', [192, NUM_CLASSES],\\n stddev=1 / 192.0, wd=None)\\n biases = _create_variable('biases', [NUM_CLASSES],\\n tf.constant_initializer(0.0))\\n softmax_linear = tf.add(tf.matmul(local4, weights), biases, name=scope.name)\\n\\n return softmax_linear\",\n \"def inference_images_with_graph(graph_def, filenames):\\n\\n\\timages = [get_image_as_array(filename) for filename in filenames]\\n\\n\\twith tf.Graph().as_default() as graph:\\n\\n\\t\\twith tf.Session() as sess:\\n\\n\\t\\t\\t# Import a graph_def into the current default Graph\\n\\t\\t\\tprint(\\\"import graph\\\")\\t\\n\\t\\t\\tinput_, predictions = tf.import_graph_def(graph_def, name='', \\n\\t\\t\\t\\treturn_elements=input_output_placeholders)\\n\\t\\t\\t\\n\\t\\t\\tcamera.start_preview()\\n\\n\\t\\t\\tfor i in range(len(filenames)):\\n\\t\\t\\t\\tfilename = filenames[i]\\n\\t\\t\\t\\timage = images[i]\\n\\n\\t\\t\\t\\tp_val = predictions.eval(feed_dict={input_: [image]})\\n\\t\\t\\t\\tindex = np.argmax(p_val)\\n\\t\\t\\t\\tlabel = labels[index]\\n\\n\\t\\t\\t\\tprint('{0}: prediction={1}'.format(filename, label))\\n\\n\\t\\t\\tcamera.stop_preview()\",\n \"def infer(self, example, model):\\n asp_input = model + '\\\\n\\\\n' + example + '\\\\n\\\\n' + inference_program_ec\\n ctl = clingo.Control()\\n ctl.add(\\\"base\\\", [], asp_input)\\n ctl.ground([(\\\"base\\\", [])], context=self)\\n ctl.solve(on_model=self.show_model)\",\n \"def run_infer(infer_model, model_dir, infer_sess):\\n with infer_model.graph.as_default():\\n loaded_infer_model, global_step = model_helper.create_or_load_model(\\n model_dir, infer_model.model, infer_sess)\\n \\n output_tuple = loaded_infer_model.infer(infer_sess)\\n return output_tuple\",\n \"def inference_mode_on():\\n Layer.inference_mode = True\\n with ng.metadata(mode=\\\"inference\\\"):\\n yield\\n Layer.inference_mode = False\",\n \"def run_inference(test_loader, model, model_params, testing_params, ofolder, cuda_available,\\n i_monte_carlo=None):\\n # INIT STORAGE VARIABLES\\n preds_npy_list, gt_npy_list = [], []\\n pred_tmp_lst, z_tmp_lst, fname_tmp = [], [], ''\\n volume = None\\n weight_matrix = None\\n\\n for i, batch in enumerate(tqdm(test_loader, desc=\\\"Inference - Iteration \\\" + str(i_monte_carlo))):\\n with torch.no_grad():\\n # GET SAMPLES\\n # input_samples: list of batch_size tensors, whose size is n_channels X height X width X depth\\n # gt_samples: idem with n_labels\\n # batch['*_metadata']: list of batch_size lists, whose size is n_channels or n_labels\\n if model_params[\\\"name\\\"] == \\\"HeMISUnet\\\":\\n input_samples = imed_utils.cuda(imed_utils.unstack_tensors(batch[\\\"input\\\"]), cuda_available)\\n else:\\n input_samples = imed_utils.cuda(batch[\\\"input\\\"], cuda_available)\\n gt_samples = imed_utils.cuda(batch[\\\"gt\\\"], cuda_available, non_blocking=True)\\n\\n # EPISTEMIC UNCERTAINTY\\n if testing_params['uncertainty']['applied'] and testing_params['uncertainty']['epistemic']:\\n for m in model.modules():\\n if m.__class__.__name__.startswith('Dropout'):\\n m.train()\\n\\n # RUN MODEL\\n if model_params[\\\"name\\\"] in [\\\"HeMISUnet\\\", \\\"FiLMedUnet\\\"]:\\n metadata = get_metadata(batch[\\\"input_metadata\\\"], model_params)\\n preds = model(input_samples, metadata)\\n else:\\n preds = model(input_samples)\\n\\n if model_params[\\\"name\\\"] == \\\"HeMISUnet\\\":\\n # Reconstruct image with only one modality\\n input_samples = batch['input'][0]\\n\\n if model_params[\\\"name\\\"] == \\\"UNet3D\\\" and model_params[\\\"attention\\\"]:\\n imed_utils.save_feature_map(batch, \\\"attentionblock2\\\", os.path.dirname(ofolder), model, input_samples,\\n slice_axis=test_loader.dataset.slice_axis)\\n\\n # PREDS TO CPU\\n preds_cpu = preds.cpu()\\n\\n # RECONSTRUCT 3D IMAGE\\n last_batch_bool = (i == len(test_loader) - 1)\\n\\n slice_axis = imed_utils.AXIS_DCT[testing_params['slice_axis']]\\n\\n # LOOP ACROSS SAMPLES\\n for smp_idx in range(len(preds_cpu)):\\n if \\\"bounding_box\\\" in batch['input_metadata'][smp_idx][0]:\\n imed_obj_detect.adjust_undo_transforms(testing_params[\\\"undo_transforms\\\"].transforms, batch, smp_idx)\\n\\n if not model_params[\\\"name\\\"].endswith('3D'):\\n last_sample_bool = (last_batch_bool and smp_idx == len(preds_cpu) - 1)\\n # undo transformations\\n preds_idx_undo, metadata_idx = testing_params[\\\"undo_transforms\\\"](preds_cpu[smp_idx],\\n batch['gt_metadata'][smp_idx],\\n data_type='gt')\\n # preds_idx_undo is a list n_label arrays\\n preds_idx_arr = np.array(preds_idx_undo)\\n\\n # TODO: gt_filenames should not be a list\\n fname_ref = metadata_idx[0]['gt_filenames'][0]\\n\\n # NEW COMPLETE VOLUME\\n if pred_tmp_lst and (fname_ref != fname_tmp or last_sample_bool):\\n # save the completely processed file as a nifti file\\n fname_pred = os.path.join(ofolder, fname_tmp.split('/')[-1])\\n fname_pred = fname_pred.split(testing_params['target_suffix'][0])[0] + '_pred.nii.gz'\\n # If Uncertainty running, then we save each simulation result\\n if testing_params['uncertainty']['applied']:\\n fname_pred = fname_pred.split('.nii.gz')[0] + '_' + str(i_monte_carlo).zfill(2) + '.nii.gz'\\n\\n output_nii = imed_utils.pred_to_nib(data_lst=pred_tmp_lst,\\n z_lst=z_tmp_lst,\\n fname_ref=fname_tmp,\\n fname_out=fname_pred,\\n slice_axis=slice_axis,\\n kernel_dim='2d',\\n bin_thr=0.9 if testing_params[\\\"binarize_prediction\\\"] else -1)\\n # TODO: Adapt to multilabel\\n preds_npy_list.append(output_nii.get_fdata()[:, :, :, 0])\\n gt_npy_list.append(nib.load(fname_tmp).get_fdata())\\n\\n output_nii_shape = output_nii.get_fdata().shape\\n if len(output_nii_shape) == 4 and output_nii_shape[-1] > 1:\\n imed_utils.save_color_labels(np.stack(pred_tmp_lst, -1),\\n testing_params[\\\"binarize_prediction\\\"],\\n fname_tmp,\\n fname_pred.split(\\\".nii.gz\\\")[0] + '_color.nii.gz',\\n imed_utils.AXIS_DCT[testing_params['slice_axis']])\\n\\n # re-init pred_stack_lst\\n pred_tmp_lst, z_tmp_lst = [], []\\n\\n # add new sample to pred_tmp_lst, of size n_label X h X w ...\\n pred_tmp_lst.append(preds_idx_arr)\\n\\n # TODO: slice_index should be stored in gt_metadata as well\\n z_tmp_lst.append(int(batch['input_metadata'][smp_idx][0]['slice_index']))\\n fname_tmp = fname_ref\\n\\n else:\\n pred_undo, metadata, last_sample_bool, volume, weight_matrix = \\\\\\n imed_utils.volume_reconstruction(batch,\\n preds_cpu,\\n testing_params['undo_transforms'],\\n smp_idx, volume, weight_matrix)\\n fname_ref = metadata[0]['gt_filenames'][0]\\n # Indicator of last batch\\n if last_sample_bool:\\n pred_undo = np.array(pred_undo)\\n fname_pred = os.path.join(ofolder, fname_ref.split('/')[-1])\\n fname_pred = fname_pred.split(testing_params['target_suffix'][0])[0] + '_pred.nii.gz'\\n # If uncertainty running, then we save each simulation result\\n if testing_params['uncertainty']['applied']:\\n fname_pred = fname_pred.split('.nii.gz')[0] + '_' + str(i_monte_carlo).zfill(2) + '.nii.gz'\\n\\n # Choose only one modality\\n output_nii = imed_utils.pred_to_nib(data_lst=[pred_undo],\\n z_lst=[],\\n fname_ref=fname_ref,\\n fname_out=fname_pred,\\n slice_axis=slice_axis,\\n kernel_dim='3d',\\n bin_thr=0.5 if testing_params[\\\"binarize_prediction\\\"] else -1)\\n preds_npy_list.append(output_nii.get_fdata().transpose(3, 0, 1, 2))\\n gt_lst = []\\n for gt in metadata[0]['gt_filenames']:\\n # For multi-label, if all labels are not in every image\\n if gt is not None:\\n gt_lst.append(nib.load(gt).get_fdata())\\n else:\\n gt_lst.append(np.zeros(gt_lst[0].shape))\\n\\n gt_npy_list.append(np.array(gt_lst))\\n # Save merged labels with color\\n\\n if pred_undo.shape[0] > 1:\\n imed_utils.save_color_labels(pred_undo,\\n testing_params['binarize_prediction'],\\n batch['input_metadata'][smp_idx][0]['input_filenames'],\\n fname_pred.split(\\\".nii.gz\\\")[0] + '_color.nii.gz',\\n slice_axis)\\n\\n return preds_npy_list, gt_npy_list\",\n \"def fun(in_path, out_image_path,\\n out_info_path, in_finished_path,\\n model_path, image_resolution):\\n global model, F\\n detect_emo = True\\n\\n #save config\\n save_image = True\\n save_info = True\\n show_image = False\\n\\n #config = tf.ConfigProto()\\n # config.gpu_options.per_process_gpu_memory_fraction = 0.7\\n # config.gpu_options.allow_growth = True\\n # session = InteractiveSession(config=config)\\n #%%\\n # parameters for loading data and images\\n detection_model_path = model_path + '/haarcascade_frontalface_default.xml'\\n if detect_emo:\\n emotion_model_path = model_path + '/googlenet__googlenetwei__2020Aug29_16.21'\\n emotion_labels = get_labels('fer2013')\\n print(emotion_labels)\\n emotion_offsets = (20, 40)\\n\\n # loading models\\n model = getattr(model, 'googlenet')\\n model = model(in_channels=3, num_classes=7)\\n #print(torch.cuda.is_available())\\n #print(torch.cuda.device_count())\\n state = torch.load(emotion_model_path, map_location='cpu')\\n model.load_state_dict(state['net'])\\n\\n #model.cuda()\\n model.eval()\\n\\n # getting input model shapes for inference\\n emotion_target_size = (224,224)\\n # starting lists for calculating modes\\n emotion_window = []\\n\\n # hyper-parameters for bounding boxes shape\\n frame_window = 10\\n emotion_offsets = (20, 40)\\n\\n # loading models\\n face_detection = load_detection_model(detection_model_path)\\n\\n info_name = ['file name', 'face_x', 'face_y', 'face_w', 'face_h', 'emotion', 'angry_prob', 'disgust_prob', 'fear_prob', 'happy_prob', 'sad_prob', 'surprise_prob', 'neutral_prob']\\n\\n input_image_root = in_path\\n output_image_root = out_image_path\\n output_info_root = out_info_path\\n\\n #covert png to jpg\\n for image_path in glob.glob(input_image_root+'/**/*.png', recursive=True):\\n img_path_no_PNG = image_path.split('.png')[0]\\n image_name = image_path.split('/')[-1].split('.png')[0]\\n no_root_path = image_path[len(input_image_root):].replace(image_path.split('/')[-1], '')\\n im = Image.open(image_path)\\n rgb_im = im.convert('RGB')\\n rgb_im.save(img_path_no_PNG + '.jpg')\\n\\n #delete PNG file\\n os.remove(image_path)\\n\\n for image_path in glob.glob(input_image_root+'/**/*.jpg', recursive=True):\\n print(image_path)\\n no_root_path = image_path[len(input_image_root):].replace(image_path.split('/')[-1], '')\\n spec_csv_name = ('/' + (image_path[len(\\\"feri_input/\\\"):].replace(image_path.split('/')[-1], ''))).split('/')[-2]\\n if spec_csv_name ==\\\"\\\":\\n spec_csv_name = \\\"result.csv\\\"\\n else:\\n spec_csv_name = spec_csv_name + '.csv'\\n image_capture = cv2.imread(image_path)\\n image_cap_ori = image_capture\\n image_name = image_path.split('/')[-1].split('.jpg')[0]\\n ori_image_name = image_path.split('/')[-1]\\n size = (round(image_capture.shape[0]), round(image_capture.shape[1])) # float\\n ori_size = size\\n reduce_resolution = 0\\n first_construct_csv = False\\n scaling_factor_x = 1\\n scaling_factor_y = 1\\n\\n if image_resolution == \\\"720p\\\" and size[0] > 720 and size[1] > 1280:\\n #need to reduce resolution to 720p\\n reduce_resolution = 1\\n out_path = input_image_root + no_root_path+'resize_to_720p_'+image_path.split('/')[-1]\\n image_capture = cv2.resize(image_capture, (1280, 720), interpolation=cv2.INTER_CUBIC)\\n cv2.imwrite(out_path, image_capture)\\n\\n scaling_factor_y = size[0]/720\\n scaling_factor_x = size[1]/1280\\n\\n #original resolution image move to fer_finished dir \\n src = image_path\\n dst = in_finished_path + no_root_path + image_name + \\\".jpg\\\"\\n os.makedirs(os.path.dirname(in_finished_path + no_root_path), exist_ok=True)\\n shutil.move(src, dst)\\n\\n #capture ori resolution image to draw bounding box\\n image_cap_ori = cv2.imread(dst)\\n\\n #capture reducing resolution image to construct csv file\\n image_path = out_path\\n image_capture = cv2.imread(image_path)\\n image_name = image_path.split('/')[-1].split('.jpg')[0]\\n size = (round(image_capture.shape[0]), round(image_capture.shape[1])) # float\\n\\n if size[0] == 720 and size[1] == 1280:\\n if save_image:\\n os.makedirs(os.path.dirname(output_image_root + no_root_path), exist_ok=True)\\n out_path = output_image_root+no_root_path+ori_image_name\\n if save_info:\\n os.makedirs(os.path.dirname(output_info_root + no_root_path), exist_ok=True)\\n if os.path.isfile(output_info_root+no_root_path+spec_csv_name) == False:\\n first_construct_csv = True\\n csv_info = codecs.open(\\n output_info_root+no_root_path+spec_csv_name, 'a', encoding=\\\"utf_8_sig\\\"\\n )\\n csv_writer = csv.writer(csv_info)\\n if first_construct_csv == True:\\n csv_writer.writerow(info_name)\\n\\n st_time = time.time()\\n \\n gray_image = cv2.cvtColor(image_capture, cv2.COLOR_BGR2GRAY)\\n\\n faces = detect_faces(face_detection, gray_image)\\n if not isinstance(faces, tuple):\\n faces = faces[faces[:,0].argsort()]\\n faces = faces[faces[:,1].argsort()]\\n faces = faces[faces[:,2].argsort()]\\n faces = faces[faces[:,3].argsort()]\\n\\n for face_coordinates in faces:\\n x_1, x_2, y_1, y_2 = apply_offsets(face_coordinates, emotion_offsets)\\n\\n if detect_emo:\\n gray_face = gray_image[y_1:y_2, x_1:x_2]\\n try:\\n gray_face = cv2.resize(gray_face, (emotion_target_size))\\n except:\\n continue\\n\\n gray_face = np.dstack([gray_face] * 3)\\n \\n gray_face = transforms.Compose([ transforms.ToPILImage(),transforms.ToTensor(),])(np.uint8(gray_face))\\n \\n gray_face = torch.stack([gray_face], 0) \\n #gray_face = gray_face.cuda(non_blocking=True)\\n outputs = model(gray_face).cpu()\\n outputs = F.softmax(outputs, 1)\\n\\n emotion_prediction = torch.sum(outputs, 0).cpu().detach().numpy() # outputs.shape [tta_size, 7]\\n emotion_probability = np.max(emotion_prediction)\\n emotion_label_arg = np.argmax(emotion_prediction)\\n emotion_text = emotion_labels[emotion_label_arg]\\n emotion_window.append(emotion_text)\\n\\n if len(emotion_window) > frame_window:\\n emotion_window.pop(0)\\n '''\\n try:\\n emotion_mode = mode(emotion_window)\\n except:\\n continue\\n '''\\n x = int(float(face_coordinates[0]*scaling_factor_x))\\n y = int(float(face_coordinates[1]*scaling_factor_y))\\n w = int(float(face_coordinates[2]*scaling_factor_x))\\n h = int(float(face_coordinates[3]*scaling_factor_y))\\n if emotion_text == 'angry':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (255,0,0), 4)\\n cv2.putText(image_cap_ori, 'angry', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (255, 0, 0), 1, cv2.LINE_AA)\\n elif emotion_text == 'sad':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (0,0,255), 4)\\n cv2.putText(image_cap_ori, 'sad', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (0,0,255), 1, cv2.LINE_AA)\\n elif emotion_text == 'happy':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (255,255,0), 4)\\n cv2.putText(image_cap_ori, 'happy', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (255,255,0), 1, cv2.LINE_AA)\\n elif emotion_text == 'surprise':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (0,255,255), 4)\\n cv2.putText(image_cap_ori, 'surprise', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (0,255,255), 1, cv2.LINE_AA)\\n elif emotion_text == 'disgust':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (0,0,0), 4)\\n cv2.putText(image_cap_ori, 'disgust', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (0,0,0), 1, cv2.LINE_AA)\\n elif emotion_text == 'fear':\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (255,0,255), 4)\\n cv2.putText(image_cap_ori, 'fear', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (255,0,255), 1, cv2.LINE_AA)\\n else:\\n cv2.rectangle(image_cap_ori, (x, y), (x+w, y+h), (0,255,0), 4)\\n cv2.putText(image_cap_ori, 'neutral', (int(float(x+w/2-43)), y-10), cv2.FONT_HERSHEY_DUPLEX, 1, (0,255,0), 1, cv2.LINE_AA)\\n\\n if save_info:\\n op_info_list = [ori_image_name,\\n face_coordinates[0]*scaling_factor_x, face_coordinates[1]*scaling_factor_y,\\n face_coordinates[2]*scaling_factor_x, face_coordinates[3]*scaling_factor_y]\\n for i in range(len(op_info_list)):\\n op_info_list[i] = str(op_info_list[i])\\n if detect_emo:\\n op_info_list.append(emotion_text)\\n for prob in emotion_prediction:\\n op_info_list.append(prob)\\n csv_writer.writerow(op_info_list)\\n\\n if save_image:\\n cv2.imwrite(output_image_root + no_root_path + image_name + \\\".jpg\\\", image_cap_ori)\\n if save_info:\\n csv_info.close()\\n print(image_path+' DONE!!\\\\tSpend Time: '+str(time.time()-st_time)+'(s)')\\n\\n else:\\n os.makedirs(os.path.dirname(output_info_root + no_root_path), exist_ok=True)\\n if os.path.isfile(output_info_root+no_root_path+spec_csv_name) == False:\\n first_construct_csv = True\\n csv_info = codecs.open(output_info_root+no_root_path+spec_csv_name,\\n 'a', encoding=\\\"utf_8_sig\\\")\\n csv_writer = csv.writer(csv_info)\\n if first_construct_csv == True:\\n csv_writer.writerow(info_name)\\n err_msg = \\\"The resolution of \\\" + image_name + \\\".jpg is lower than 720p.\\\"\\n csv_writer.writerow([err_msg])\\n csv_info.close()\\n\\n src = image_path\\n dst = in_finished_path + no_root_path + image_name + \\\".jpg\\\"\\n os.makedirs(os.path.dirname(in_finished_path + no_root_path), exist_ok=True)\\n shutil.move(src, dst)\\n if reduce_resolution == 1:\\n image_ori_name = image_name[15:]\\n os.remove(dst)\\n os.rename(output_image_root+no_root_path+image_name+'.jpg', output_image_root+no_root_path+image_ori_name+'.jpg')\\n\\n shutil.rmtree(input_image_root, ignore_errors=True)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80876434","0.76775897","0.7585265","0.7361889","0.72406197","0.7163995","0.70659184","0.69971216","0.69961894","0.69929576","0.69677186","0.6897145","0.68879974","0.6879423","0.6831557","0.68114525","0.67840654","0.6757619","0.67368376","0.6732527","0.67268866","0.67017186","0.6662785","0.6653274","0.66310406","0.6604782","0.65811884","0.65485287","0.6536169","0.6522709","0.6500791","0.64554507","0.64324963","0.6431727","0.64096993","0.64047205","0.6376229","0.63734734","0.63673747","0.6365215","0.635244","0.6343389","0.6343158","0.62846243","0.62325454","0.6224693","0.61703336","0.6150855","0.6144436","0.61429274","0.6112567","0.61069363","0.61068153","0.606688","0.6066184","0.6065236","0.60645235","0.60285413","0.6022083","0.6010629","0.60090137","0.6002966","0.59990805","0.5998508","0.5997852","0.5995228","0.59920293","0.59797436","0.59784424","0.5973306","0.5969869","0.59641826","0.5956931","0.59451866","0.59291005","0.59195226","0.58969694","0.5888369","0.5872276","0.5867034","0.5857371","0.585013","0.5838858","0.5832321","0.5823838","0.5821925","0.58184576","0.5817024","0.58096176","0.5798227","0.5785909","0.5778565","0.5773748","0.5762292","0.5760771","0.57590723","0.5753651","0.5751088","0.5744394","0.5741067"],"string":"[\n \"0.80876434\",\n \"0.76775897\",\n \"0.7585265\",\n \"0.7361889\",\n \"0.72406197\",\n \"0.7163995\",\n \"0.70659184\",\n \"0.69971216\",\n \"0.69961894\",\n \"0.69929576\",\n \"0.69677186\",\n \"0.6897145\",\n \"0.68879974\",\n \"0.6879423\",\n \"0.6831557\",\n \"0.68114525\",\n \"0.67840654\",\n \"0.6757619\",\n \"0.67368376\",\n \"0.6732527\",\n \"0.67268866\",\n \"0.67017186\",\n \"0.6662785\",\n \"0.6653274\",\n \"0.66310406\",\n \"0.6604782\",\n \"0.65811884\",\n \"0.65485287\",\n \"0.6536169\",\n \"0.6522709\",\n \"0.6500791\",\n \"0.64554507\",\n \"0.64324963\",\n \"0.6431727\",\n \"0.64096993\",\n \"0.64047205\",\n \"0.6376229\",\n \"0.63734734\",\n \"0.63673747\",\n \"0.6365215\",\n \"0.635244\",\n \"0.6343389\",\n \"0.6343158\",\n \"0.62846243\",\n \"0.62325454\",\n \"0.6224693\",\n \"0.61703336\",\n \"0.6150855\",\n \"0.6144436\",\n \"0.61429274\",\n \"0.6112567\",\n \"0.61069363\",\n \"0.61068153\",\n \"0.606688\",\n \"0.6066184\",\n \"0.6065236\",\n \"0.60645235\",\n \"0.60285413\",\n \"0.6022083\",\n \"0.6010629\",\n \"0.60090137\",\n \"0.6002966\",\n \"0.59990805\",\n \"0.5998508\",\n \"0.5997852\",\n \"0.5995228\",\n \"0.59920293\",\n \"0.59797436\",\n \"0.59784424\",\n \"0.5973306\",\n \"0.5969869\",\n \"0.59641826\",\n \"0.5956931\",\n \"0.59451866\",\n \"0.59291005\",\n \"0.59195226\",\n \"0.58969694\",\n \"0.5888369\",\n \"0.5872276\",\n \"0.5867034\",\n \"0.5857371\",\n \"0.585013\",\n \"0.5838858\",\n \"0.5832321\",\n \"0.5823838\",\n \"0.5821925\",\n \"0.58184576\",\n \"0.5817024\",\n \"0.58096176\",\n \"0.5798227\",\n \"0.5785909\",\n \"0.5778565\",\n \"0.5773748\",\n \"0.5762292\",\n \"0.5760771\",\n \"0.57590723\",\n \"0.5753651\",\n \"0.5751088\",\n \"0.5744394\",\n \"0.5741067\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7535307"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":93693,"cells":{"query":{"kind":"string","value":"Download and extract model tar file."},"document":{"kind":"string","value":"def maybe_download_and_extract():\n dest_directory = FLAGS.model_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)"},"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 download_and_unpack_model(model_name, model_date='20200711'):\n\n # pretrained models\n pretrained_models_dir = os.path.join(ROOT_DIR, 'pre-trained-models')\n create_directory_if_not_exists(pretrained_models_dir)\n\n # pretrained model archives\n model_archive_dir = os.path.join(pretrained_models_dir, 'archives')\n create_directory_if_not_exists(model_archive_dir)\n\n # determine the (expected) path of the downloaded model\n model_file = f'{model_name}.tar.gz'\n model_archive_path = os.path.join(model_archive_dir, model_file)\n\n # if the tar.gz exists, try to unpack it\n retry = False\n if os.path.exists(model_archive_path):\n logger.info(f'Attempting to unpack {full_path(model_archive_path)}...')\n try:\n shutil.unpack_archive(model_archive_path, os.path.dirname(model_archive_dir))\n except EOFError:\n logger.info('Cannot unpack. Archive is corrupt. Attempting to retry...')\n retry = True\n\n # if the tar.gz does not exist or is corrupt (unpacking failed), download it, then unpack it\n if not os.path.exists(model_archive_path) or retry:\n base_url = 'http://download.tensorflow.org/models/object_detection/tf2/'\n url = base_url + model_date + '/' + model_file\n logger.info(f'Downloading from {url}...')\n\n # download file as stream\n response = requests.get(url, stream=True)\n with open(model_archive_path, 'wb') as handle:\n progress_bar = tqdm(unit=\"B\", total=int(response.headers['Content-Length']), unit_scale=True, unit_divisor=1024)\n for data in response.iter_content(chunk_size=8192):\n progress_bar.update(len(data))\n handle.write(data)\n progress_bar.close()\n\n # try to unpack tar.gz\n logger.info(f'Attempting to unpack {full_path(model_archive_path)}...')\n try:\n shutil.unpack_archive(model_archive_path, os.path.dirname(model_archive_dir))\n except EOFError:\n # give up if unpacking failed\n logger.info('Archive cannot be unpacked')\n sys.exit(1)\n\n logger.info('Successfully downloaded and unpacked model')","def download_model(\\\n download_base='http://download.tensorflow.org/models/object_detection/', \\\n model_name='ssd_mobilenet_v1_coco_11_06_2017'\\\n ):\n\n # add tar gz to the end of file name\n model_file = model_name + '.tar.gz'\n\n try:\n opener = urllib.request.URLopener()\n opener.retrieve(download_base + model_file, \\\n model_file)\n tar_file = tarfile.open(model_file)\n for f in tar_file.getmembers():\n file_name = os.path.basename(f.name)\n if 'frozen_inference_graph.pb' in file_name:\n tar_file.extract(f, os.getcwd())\n except Exception as e:\n raise","def maybe_download_and_extract():\n dest_directory = FLAGS.model_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def maybe_download_and_extract():\n dest_directory = FLAGS.model_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath,\n reporthook=_progress)\n print()\n statinfo = os.stat(filepath)\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def maybe_download_and_extract():\n dest_directory = FLAGS['model_dir']\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' %\n (filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def download_pre_trained_model (model_name):\n model_url = cfg.LIST_MODEL_TO_DOWNLOAD[model_name]\n\n file_name = (model_url.split(\"/\")[-1]).split(\".\")[0] # get file name from url\n\n # create directory if not exit\n if not os.path.exists(os.path.join(cfg.PATH_PRE_TRAINED_MODELS,file_name)):\n if not os.path.exists(cfg.PATH_PRE_TRAINED_MODELS):\n os.mkdir(cfg.PATH_PRE_TRAINED_MODELS)\n try:\n click.echo(click.style(f\"\\n Downloading the {file_name} model \\n\", bg='green', bold=True, fg='white'))\n file_location = save_zip_from_url(model_url, cfg.PATH_PRE_TRAINED_MODELS)\n \n click.echo(click.style(f'\\n Extraction of {file_name} ...\\n', bg='blue', bold=True, fg='white'))\n\n # Extract tar-file to annotation directory\n with tarfile.open(name=file_location) as tar:\n for member in tqdm(iterable=tar.getmembers(), total=len(tar.getmembers())):\n tar.extract(member=member, path=cfg.PATH_PRE_TRAINED_MODELS)\n # delete tar-file\n os.remove(file_location)\n return 0\n\n except expression as identifier:\n return -1\n else:\n click.echo(click.style(f\"\\n {file_name} have been downloaded \\n\", bg='blue', bold=True, fg='white'))\n return 1","def maybe_download_and_extract(modeldir):\n\tdest_directory = modeldir\n\tif not os.path.exists(dest_directory):\n\t\tos.makedirs(dest_directory)\n\tfilename = DATA_URL.split('/')[-1]\n\tfilepath = os.path.join(dest_directory, filename)\n\tif not os.path.exists(filepath):\n\t\tdef _progress(count, block_size, total_size):\n\t\t\tsys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n\t\t\t\t\tfilename, float(count * block_size) / float(total_size) * 100.0))\n\t\t\tsys.stdout.flush()\n\t\tfilepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n\t\tprint()\n\t\tstatinfo = os.stat(filepath)\n\t\tprint('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n\ttarfile.open(filepath, 'r:gz').extractall(dest_directory)","def maybe_download_and_extract():\n dest_directory = MODEL_DIR\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def download(self):\n if not os.path.exists(self.pkg_dir):\n os.makedirs(self.pkg_dir)\n\n url = self.metadata_pkg[\"url\"]\n\n # Download modelpkg only if not already downloaded.\n if os.path.exists(self.file_path):\n self.is_downloaded = True\n else:\n print(f\"Fetching {os.path.basename(self.file_path)} model package from {url} to {self.file_path}\", flush=True)\n r = requests.get(url, stream=True)\n with open(self.file_path, \"wb\") as file_out:\n for chunk in r.iter_content(chunk_size=2048):\n file_out.write(chunk)\n r.close()\n self.is_downloaded = True","def maybe_download_and_extract(self, DATA_URL):\n\n print('Will download the pre-trained Inception Model to the same path with this validator!')\n self.Model_Save_Path = os.path.join(\"/\",\n os.getcwd(), 'DownLoaded_Inception/')\n print('Start download to ' + self.Model_Save_Path)\n\n if not os.path.exists(self.Model_Save_Path):\n os.makedirs(self.Model_Save_Path)\n\n dest_directory = self.Model_Save_Path\n\n filename = self.DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(\n DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Succesfully downloaded', filename,\n statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def _download_zip_model(model_url: str, model_path: str) -> str:\n if os.path.exists(model_path):\n return model_path\n extract_dir = os.path.dirname(model_path)\n url_model_name = os.path.basename(urlparse(model_url).path)\n tmp_zip_file_path = os.path.join(extract_dir, url_model_name)\n _download_file(model_url, tmp_zip_file_path)\n _unzip_file(tmp_zip_file_path, extract_dir)\n return model_path","def maybe_download_and_extract(JSONE):\n print(\"maybe_download_and_extract\")\n dest_directory = JSONE['model_dir'][0]\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\n print(\"maybe_download_and_extract\")","def maybe_download_and_extract(dir_path, model_url, is_zipfile=False, is_tarfile=False):\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n filename = model_url.split('/')[-1]\n filepath = os.path.join(dir_path, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write(\n '\\r>> Download %s %.1f%%' %(filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n file_path, _ = urllib.urlretrieve(model_url, filepath, reporthook=_progress)\n print('\\n')\n statinfo = os.stat(filepath)\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n if is_zipfile:\n with zipfile.ZipFile(filepath) as zf:\n # zip_dir = zf.namelist()[0]\n zf.extractall(dir_path)\n elif is_tarfile:\n tarfile.open(file_path, 'r:gz').extractall(dir_path)","def maybe_download():\n\n print(\"Downloading Inception 5h Model ...\")\n download.maybe_download_and_extract(url=data_url, download_dir=data_dir)","def download_ckpt(model_name):\n with open (\"./utils/models.json\", \"r\") as f:\n url = json.loads(f.read())[model_name] \n model_name_tar = url.split(\"/\")[-1]\n model_name_dir = url.split(\"/\")[-1].split(\".\")[0]\n if not chk_model(model_name_dir):\n try: \n print('Downloading %s to %s...' % (url, model_name_tar))\n os.system(\"wget {}\".format(str(url))) \n os.system(\"tar xvf {}\".format(str(model_name_tar))) \n os.remove(model_name_tar)\n # assert os.path.exists()# check \n return model_name_dir\n except Exception as e:\n print(e)\n return model_name_dir","def _download(self):\n self._system.download_file(\"http://curl.haxx.se/download/\" + self._tar_name)","def _download(self):\n self._system.download(\"http://geant4.web.cern.ch/geant4/support/source/\" + self._tar_name)","def download(self, root='./'):\n dir = os.path.join(root, 'tiny-imagenet-200')\n dir_train = os.path.join(dir, 'train')\n if os.path.exists(dir) and os.path.exists(dir_train):\n print('==> Already downloaded.')\n return\n\n path = Path(os.path.join(root, 'tiny-imagenet-200.zip'))\n if not os.path.exists(path):\n os.makedirs(path.parent, exist_ok=True)\n\n print('==> Downloading TinyImagenet200...')\n with urllib.request.urlopen(self.url) as response, \\\n open(str(path), 'wb') as out_file:\n shutil.copyfileobj(response, out_file)\n\n print('==> Extracting TinyImagenet200...')\n with zipfile.ZipFile(str(path)) as zf:\n zf.extractall(root)","def downloadModel(url):\n print('Model download started...')\n fileName = url.split('/')[-1]\n filePath = f'../kerasModels/{fileName}'\n\n if not os.path.exists(os.path.dirname(filePath)):\n try:\n os.makedirs(os.path.dirname(fileName))\n except OSError as exc:\n if exc.errno != errno.EXIST:\n raise\n\n urlretrieve(url, fileName)\n print('Model download completed')\n return fileName","def download_and_extract(down_dir=download_dir, url=tuda_url):\n\n wget.download(url, down_dir) \n tar_filepath = os.path.join(down_dir, \"german-speechdata-package-v2.tar.gz\")\n #with tarfile.open(tar_filepath, \"r\") as tar:\n # tar.extractall(down_dir)","def download_model(model, model_hash, model_dir):\n if not os.path.isdir(model_dir):\n os.mkdir(model_dir)\n filename = os.path.join(model_dir, model)\n\n logger.info(f\"Downloading {model} to {filename}...\")\n urllib.request.urlretrieve(\n os.path.join(\"http://genesis.ugent.be/uvpublicdata/ms2pip/\", model), filename\n )\n if not check_model_integrity(filename, model_hash):\n raise InvalidXGBoostModelError()","def _download_model_version_files(self):\n model_version = self.client.get_model_version(name=self.model_name, version=self.model_version)\n artifact_uri = model_version.source\n return _download_artifact_from_uri(artifact_uri)","def _download_model(download_url):\n\n pip_args = [\"--no-cache-dir\"]\n cmd = [sys.executable, \"-m\", \"pip\", \"install\"] + pip_args + [download_url]\n\n return subprocess.call(cmd, env=os.environ.copy())","def download_model(model_arch, alt_model_name=None):\n\n download_base_url = 'http://download.tensorflow.org/models/object_detection/'\n \n tf_org_model_name = downloadable_models[model_arch]['tf.org.model_name']\n base_pipeline_config = downloadable_models[model_arch]['pipeline_file']\n\n model_archive_basename = tf_org_model_name + '.tar.gz'\n dst_dir = './downloaded_pretrained_models'\n model_archive_path = join(dst_dir, model_archive_basename)\n\n if not isdir(dst_dir):\n makedirs(dst_dir)\n\n # \"cache\"\n if not exists(model_archive_path):\n print(\"downloading ::\", download_base_url + model_archive_basename)\n urlretrieve(\n url=download_base_url + model_archive_basename,\n filename=model_archive_path\n )\n else:\n print(\"model archive was already downloaded yay :D\")\n\n # saves to ./output/$model_name/training\n dst = join('./output', alt_model_name) \\\n if alt_model_name is not None else join(\n './output', model_arch\n )\n \n print(\"extracting download.tensorflow.org model archive...\")\n tar = tarfile.open(model_archive_path)\n tar.extractall(path=dst)\n tar.close()\n\n if exists(join(dst, 'training')):\n raise FileExistsError(\n \"\\n\\nModel directory already exists. \\\n \\n- Overwriting models that were potentially trained is forbidden.\\\n \\n- If you want to train a new model from scratch, \\\n \\n pass a non-existent alt_model_name.\\\n \\n\\n>> These are the model names already in use:\\\n \\n {}\".format(\"\\n\".join(listdir('./output')))\n )\n\n # not elegant, but whatever works man\n shutil.move(\n src=join(dst, tf_org_model_name),\n dst=join(dst, 'training')\n )\n # store model_arch for future ref\n system(\"echo {} > {}\".format(model_arch, join(\n dst,\n 'training/model.arch')\n )\n )\n # make sure its integrity checks out\n assert_ckpt(join(dst, 'training'))\n \n # make export directory for inference executables\n model_name = model_arch if alt_model_name is None else alt_model_name\n export_dir = join('./output', model_name, 'export')\n if not exists(export_dir):\n makedirs(export_dir)\n\n # rename `checkpoint` file so that training can actually take off...\n # don't ask, but... \n # https://github.com/tensorflow/models/issues/5053#issuecomment-441423962\n shutil.move(join(dst, 'training/checkpoint'), join(dst, 'training/old_checkpoint'))\n \n # path to training dir and path to base training pipeline config\n return join(dst, 'training'), export_dir, base_pipeline_config","def download_tf_params():\n\n if not os.path.exists(MODEL_DIR):\n os.makedirs(MODEL_DIR)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(MODEL_DIR, filename)\n\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n statinfo = os.stat(filepath)\n print()\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\n\n tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR)","def download_zipped_model(manifest, assert_hash=False):\n zipped_model_path = manifest[\"model_filepath\"]\n zipped_model = client.file(zipped_model_path).getFile().name\n if assert_hash:\n assert_model_md5(zipped_model)\n return zipped_model_path","def download_model():\n logging.info(\"[genreml] Downloading model...\")\n with urllib.request.urlopen(config.FMAModelConfig.FMA_MODEL_URL) as f:\n data = f.read()\n open(config.FMAModelConfig.FMA_MODEL_PATH, 'wb').write(data)\n logging.info(\"[genreml] Model download complete\")","def download_model(name: str) -> str:\n model_name, model_type, model_url = ModelInfo.get_model_info(name)\n model_path = _create_dirs(model_name)\n if model_type == \"single\":\n model_path = _download_file(model_url, model_path)\n elif model_type == \"zip\":\n model_path = _download_zip_model(model_url, model_path)\n else:\n print(f\"model type {model_type} not yet implemented\")\n model_path = \"\"\n return model_path","def download_model_from_url(\n url: str = typer.Argument(..., help='The link to a model'),\n path: Path = typer.Argument(..., file_okay=True, help='The saved path and file name.')\n):\n\n from modelci.hub.registrar import download_model_from_url\n\n download_model_from_url(url, path)\n typer.echo(f'{path} model downloaded successfully.')","def download_model(source, target, filename):\n if not os.path.exists(target):\n os.mkdir(target) \n target_file = str(Path(target).joinpath(filename))\n if os.path.exists(target_file):\n print('model already exists, skipping download')\n return\n print(\"Downloading from {} to {}\".format(source, target))\n wget.download(source, target_file) \n print(\"\\nDone!\")","def download(self):\n if not self.url:\n raise RuntimeError(self.tips)\n\n download_file_name = os.path.join(\n self.raw_path, os.path.splitext(os.path.basename(self.url))[0]\n )\n file_format = self.url.split(\".\")[-1]\n if \"amazon\" in self.url:\n raw_file_path = os.path.join(\n self.raw_path, f\"{self.dataset_name}.json.{file_format}\"\n )\n else:\n raw_file_path = os.path.join(\n self.raw_path, f\"{self.dataset_name}.{file_format}\"\n )\n if \"1drv.ms\" in self.url:\n file_format = \"zip\"\n raw_file_path = os.path.join(\n self.raw_path, f\"{self.dataset_name}.{file_format}\"\n )\n if not os.path.exists(raw_file_path):\n print(f\"download_file: url: {self.url}, raw_file_path: {raw_file_path}\")\n download_file(self.url, raw_file_path)\n if \"amazon\" in raw_file_path:\n # amazon dataset do not unzip\n print(\"amazon dataset do not decompress\")\n return\n elif file_format == \"gz\":\n file_name = raw_file_path.replace(\".gz\", \"\")\n with gzip.open(raw_file_path, \"rb\") as fin:\n with open(file_name, \"wb\") as fout:\n shutil.copyfileobj(fin, fout)\n else:\n shutil.unpack_archive(\n raw_file_path, self.raw_path, format=get_format(file_format)\n )\n\n if not os.path.exists(download_file_name):\n return\n elif os.path.isdir(download_file_name):\n os.rename(\n download_file_name, os.path.join(self.raw_path, self.dataset_name)\n )\n else:\n os.rename(\n download_file_name,\n os.path.join(\n self.raw_path,\n f'{self.dataset_name}.{download_file_name.split(\".\")[-1]}',\n ),\n )","def download():\n base_loc = DATA_DIR + '/raw/human_activity'\n loc = base_loc + '/human_activity.zip'\n if os.path.exists(loc):\n print('Path already exists at {}. If you wish to re-download you must delete this folder.'.format(loc))\n return\n if not os.path.exists(base_loc):\n os.mkdir(base_loc)\n\n url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/00341/HAPT%20Data%20Set.zip'\n urllib.request.urlretrieve(url, loc)\n\n with zipfile.ZipFile(loc, 'r') as zip_ref:\n zip_ref.extractall(base_loc)","def get_file(\n fname,\n origin,\n untar=False,\n cache_subdir=\"datasets\",\n extract=False,\n archive_format=\"auto\",\n cache_dir=None,\n):\n if cache_dir is None:\n cache_dir = os.path.join(os.path.expanduser(\"~\"), \".keras\")\n datadir_base = os.path.expanduser(cache_dir)\n if not os.access(datadir_base, os.W_OK):\n datadir_base = os.path.join(\"/tmp\", \".keras\")\n datadir = os.path.join(datadir_base, cache_subdir)\n if not os.path.exists(datadir):\n os.makedirs(datadir)\n\n if untar:\n untar_fpath = os.path.join(datadir, fname)\n fpath = untar_fpath + \".tar.gz\"\n else:\n fpath = os.path.join(datadir, fname)\n\n download = False\n if os.path.exists(fpath):\n download = False\n else:\n download = True\n\n if download:\n print(\"Downloading data from\", origin)\n\n class ProgressTracker(object):\n # Maintain progbar for the lifetime of download.\n # This design was chosen for Python 2.7 compatibility.\n progbar = None\n\n def dl_progress(count, block_size, total_size):\n if ProgressTracker.progbar is None:\n if total_size == -1:\n total_size = None\n ProgressTracker.progbar = Progbar(total_size)\n else:\n ProgressTracker.progbar.update(count * block_size)\n\n error_msg = \"URL fetch failure on {}: {} -- {}\"\n try:\n try:\n urlretrieve(origin, fpath, dl_progress)\n except HTTPError as e:\n raise Exception(error_msg.format(origin, e.code, e.msg))\n except URLError as e:\n raise Exception(error_msg.format(origin, e.errno, e.reason))\n except (Exception, KeyboardInterrupt) as e:\n if os.path.exists(fpath):\n os.remove(fpath)\n raise\n ProgressTracker.progbar = None\n\n if untar:\n if not os.path.exists(untar_fpath):\n _extract_archive(fpath, datadir, archive_format=\"tar\")\n return untar_fpath\n\n if extract:\n _extract_archive(fpath, datadir, archive_format)\n\n return fpath","def download_data():\n url = 'https://www.dropbox.com/s/xk4glpk61q3qrg2/imdb.tgz?dl=1'\n urllib.request.urlretrieve(url, 'imdb.tgz')\n tar = tarfile.open(\"imdb.tgz\")\n tar.extractall()\n tar.close()","def download_data():\n url = 'https://www.dropbox.com/s/8oehplrobcgi9cq/imdb.tgz?dl=1'\n urllib.request.urlretrieve(url, 'imdb.tgz')\n tar = tarfile.open(\"imdb.tgz\")\n tar.extractall()\n tar.close()","def download_caffe_model(model_name, meta_info, dst_dir='./model'):\n if not os.path.isdir(dst_dir):\n os.mkdir(dst_dir)\n model_name = os.path.join(dst_dir, model_name)\n assert 'prototxt' in meta_info, \"missing prototxt url\"\n prototxt = mx.test_utils.download(meta_info['prototxt'], model_name+'_deploy.prototxt')\n assert 'caffemodel' in meta_info, \"mssing caffemodel url\"\n caffemodel = mx.test_utils.download(meta_info['caffemodel'], model_name+'.caffemodel')\n assert 'mean' in meta_info, 'no mean info'\n mean = meta_info['mean']\n if isinstance(mean, str):\n mean = mx.test_utils.download(mean, model_name+'_mean.binaryproto')\n return (prototxt, caffemodel, mean)","def maybe_download_and_extract():\n dest_directory = FLAGS.data_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n r = requests.Session().get(DATA_URL)\n with open(filepath, 'wb') as fd:\n for chunk in r.iter_content(500):\n fd.write(chunk)\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n extracted_dir_path = os.path.join(dest_directory, 'cifar-10-batches-bin')\n if not os.path.exists(extracted_dir_path):\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def download_and_unzip_data(\n url=\"https://storage.googleapis.com/simpeg/em_examples/tdem_groundedsource/tdem_groundedsource.tar\",\n):\n # download the data\n downloads = utils.download(url)\n\n # directory where the downloaded files are\n directory = downloads.split(\".\")[0]\n\n # unzip the tarfile\n tar = tarfile.open(downloads, \"r\")\n tar.extractall()\n tar.close()\n\n return downloads, directory","def _download(self) -> None:\n download_url(\n self.url,\n self.root,\n filename=self.data_dir,\n md5=self.md5 if self.checksum else None,\n )\n self._extract()","def maybe_download_and_extract():\n dest_directory = FLAGS.data_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (filename,\n float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n extracted_dir_path = os.path.join(dest_directory, 'cifar-10-batches-bin')\n if not os.path.exists(extracted_dir_path):\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)","def download_model(\n self, model_name: str, save_path: Union[str, Path] = \"./zoo/model.pth\"\n ):\n # check if the model name is valide\n assert model_name in list(\n self.meta.name\n ), f\"requested model {model_name} does not exist\"\n # TODO: fix, using pathlib\n # check if save_path already has the model\n save_dir = os.path.dirname(save_path)\n if not os.path.exists(save_dir):\n os.mkdir(save_dir)\n else:\n assert not os.path.exists(\n save_path\n ), f\"the save_path {save_path} is already used\"\n\n # fetch the model file\n model_id = self.meta[self.meta[\"name\"] == model_name][\"models\"].iloc[0]\n model_path = model_id.split(\"/\")\n self.pkg[model_path[0]][model_path[1]].fetch(save_path)","def download(self, force: bool = False):\n # hide this import, since we'll only ever need it _once_ (per model version)\n from .. import io as tio\n\n model_fname = self.model_fpath.name\n url = urllib.parse.urljoin(\n \"https://github.com/bdewilde/textacy-data/releases/download/\",\n self.model_id + \"/\" + model_fname,\n )\n tio.utils.download_file(\n url, filename=model_fname, dirpath=self.data_dir, force=force,\n )","def download(fnames):\n download_path = Path('./models')\n if not download_path.exists() or not download_path.is_dir():\n print('The directory \\'models\\' does not exist!')\n print('Please ensure you are in the top level of the visual-attention-networks repository')\n print(' and that the \\'models\\' directory exists')\n sys.exit()\n\n server_url = 'https://github.com/davidmascharka/tbd-nets/releases/download/v1.0/'\n if isinstance(fnames, str): # a single file\n fnames = [fnames]\n for fname in fnames:\n if (download_path / fname).exists():\n print('Skipping {}: the file already exists'.format(fname))\n continue\n\n print('Downloading {}'.format(fname))\n urlretrieve(server_url + fname, str((download_path/fname).absolute()), _download_info)\n print('Finished')","def get_pretrained_model(destination):\n url = \"https://storage.googleapis.com/download.magenta.tensorflow.org/models/ \\\n arbitrary_style_transfer.tar.gz\"\n\n os.system(\"curl -o arbitrary_style_transfer.tar.gz {0}\".format(url))\n with tarfile.open(\"arbitrary_style_transfer.tar.gz\") as tar:\n if not os.path.exists(destination):\n os.makedirs(destination)\n tar.extractall(destination)","def download_model(key, output_path):\n print(\"Looking fro model in {}\".format(output_path))\n if os.path.exists(output_path):\n print('File at: {} already exists'.format(output_path))\n else:\n download_file_from_s3(key, output_path)","def download_model_from_gcs(self):\n # download model\n download_file_from_gcs(self.config.model_bucket_name,\n self.config.model_gcs_path,\n self.config.model_local_path)\n\n # download lable columns\n download_file_from_gcs(self.config.model_bucket_name,\n self.config.labels_gcs_path,\n self.config.labels_local_path)","def download(self) -> None:\n os.makedirs(self.root, exist_ok=True)\n\n for subset in self.subsets:\n if self._check_subset_integrity(subset):\n print(f\"{subset} already downloaded and verified\")\n continue\n path = os.path.join(self.root, subset + \".tar.gz\")\n\n already_present = os.path.isfile(path)\n if not already_present:\n subset_url = self.openslr_url + subset + \".tar.gz\"\n with requests.get(subset_url, stream=True) as r:\n r.raise_for_status()\n with open(path, \"wb\") as f:\n shutil.copyfileobj(r.raw, f)\n\n archive_md5 = self.data_files[subset][\"archive_md5\"]\n if utils.checksum_file(path, \"md5\") != archive_md5:\n raise utils.DownloadError(f\"invalid checksum for {path}\")\n\n with tarfile.open(path, mode=\"r|gz\") as tar:\n tar.extractall(self.root)\n\n if not already_present:\n os.remove(path)","def download(self):\n\n with open(self.dataset_path) as dataset_file:\n dataset = json.load(dataset_file)\n\n path = \"\".join([POST_HIT_PATH, dataset[\"dataset\"][\"data_path\"]])\n if not os.path.exists(path):\n os.makedirs(path)\n\n protocole = dataset[\"dataset\"][\"protocole\"]\n\n download_links = []\n\n for resource in dataset[\"dataset\"][\"resources\"]:\n file_path = \"\".join([path, resource[\"filename\"]])\n\n #Check if the the download link has not been used before (One download link for all)\n if resource[\"download_link\"] not in download_links:\n \n print(\"DOWNLOADING : {}\".format(resource[\"filename\"]))\n f = urllib.request.urlopen(resource[\"download_link\"])\n data = f.read()\n with open(file_path, \"wb\") as donwload_file:\n donwload_file.write(data)\n\n download_links.append(resource[\"download_link\"])\n\n \n #Extract all files from the tar archives if necessary\n if tarfile.is_tarfile(file_path):\n tf = tarfile.open(file_path)\n tf.exractall()","def fetch(self) -> None:\n workflow_spec_path = os.path.join(self._output_dir, self._spec)\n self._download_file(self._parsed_url.original_url, workflow_spec_path)","def download_and_extract(self, package_name):\n self.download(package_name)\n self.extract(package_name)","def load_model(self, model_name, model_url):\n\n fname = join(self.root, model_name)\n if not isfile(fname):\n if self.verbose:\n print(\"Could not find \" + fname + \".. attempt download\")\n with urllib.request.urlopen(model_url) as res, open(fname, 'wb') as f:\n shutil.copyfileobj(res, f)\n if self.verbose:\n print(\"Download complete.. model: \" + fname)\n elif self.verbose:\n print(\"Found model \" + fname + \"! :)\")\n\n model = load_model(fname)\n self.model = model","def get_file(fname,\n origin,\n untar=False,\n md5_hash=None,\n file_hash=None,\n cache_subdir='datasets',\n hash_algorithm='auto',\n extract=False,\n archive_format='auto',\n cache_dir=None):\n if cache_dir is None:\n cache_dir = os.path.join(os.path.expanduser('~'), '.keras')\n if md5_hash is not None and file_hash is None:\n file_hash = md5_hash\n hash_algorithm = 'md5'\n datadir_base = os.path.expanduser(cache_dir)\n if not os.access(datadir_base, os.W_OK):\n datadir_base = os.path.join('/tmp', '.keras')\n datadir = os.path.join(datadir_base, cache_subdir)\n _makedirs_exist_ok(datadir)\n\n fname = path_to_string(fname)\n\n if untar:\n untar_fpath = os.path.join(datadir, fname)\n fpath = untar_fpath + '.tar.gz'\n else:\n fpath = os.path.join(datadir, fname)\n\n download = False\n if os.path.exists(fpath):\n # File found; verify integrity if a hash was provided.\n if file_hash is not None:\n if not validate_file(fpath, file_hash, algorithm=hash_algorithm):\n print('A local file was found, but it seems to be '\n 'incomplete or outdated because the ' + hash_algorithm +\n ' file hash does not match the original value of ' + file_hash +\n ' so we will re-download the data.')\n download = True\n else:\n download = True\n\n if download:\n print('Downloading data from', origin)\n\n class ProgressTracker(object):\n # Maintain progbar for the lifetime of download.\n # This design was chosen for Python 2.7 compatibility.\n progbar = None\n\n def dl_progress(count, block_size, total_size):\n if ProgressTracker.progbar is None:\n if total_size == -1:\n total_size = None\n ProgressTracker.progbar = Progbar(total_size)\n else:\n ProgressTracker.progbar.update(count * block_size)\n\n error_msg = 'URL fetch failure on {}: {} -- {}'\n try:\n try:\n urlretrieve(origin, fpath, dl_progress)\n except urllib.error.HTTPError as e:\n raise Exception(error_msg.format(origin, e.code, e.msg))\n except urllib.error.URLError as e:\n raise Exception(error_msg.format(origin, e.errno, e.reason))\n except (Exception, KeyboardInterrupt) as e:\n if os.path.exists(fpath):\n os.remove(fpath)\n raise\n ProgressTracker.progbar = None\n\n if untar:\n if not os.path.exists(untar_fpath):\n _extract_archive(fpath, datadir, archive_format='tar')\n return untar_fpath\n\n if extract:\n _extract_archive(fpath, datadir, archive_format)\n\n return fpath","def _download_untar(self, dep):\n tar = sh.Command(\"tar\")\n download_url = self.dependency_dict[dep][\"tarball\"]\n dlname = download_url.split(\"/\")[-1]\n download_path = Path(\".\") / dlname\n logger.debug(f\"downloading {dep} at {download_url} to {dlname}\")\n if self.quiet:\n trackers = ()\n else:\n trackers = (ProgressTracker(DataTransferBar()),)\n request_download(download_url, download_path, trackers=trackers)\n logger.debug(\n f\"downloaded file {download_path}, size\"\n f\" {download_path.stat().st_size}\"\n )\n try:\n tar(\"xvf\", download_path, **self.output_kwargs)\n except:\n logger.error(f\"untar of {download_path} failed\")\n sys.exit(1)","def download_data():\n url = 'https://www.dropbox.com/s/h9ubx22ftdkyvd5/ml-latest-small.zip?dl=1'\n urllib.request.urlretrieve(url, 'ml-latest-small.zip')\n zfile = zipfile.ZipFile('ml-latest-small.zip')\n zfile.extractall()\n zfile.close()","def download(uri: str) -> None:\n logger = logging.getLogger(__name__)\n logger.info('Download the dataset')\n\n # create destination dirs\n destination = project_dir / 'data' / 'raw'\n destination.mkdir(exist_ok=True, parents=True)\n\n # download the file\n urllib.request.urlretrieve(uri, destination / \"original.zip\")","def get_file(fname,\n origin,\n untar=False,\n md5_hash=None,\n file_hash=None,\n cache_subdir='datasets',\n hash_algorithm='auto',\n extract=False,\n archive_format='auto',\n cache_dir=None):\n if cache_dir is None:\n cache_dir = os.path.join(os.path.expanduser('~'), '.keras')\n if md5_hash is not None and file_hash is None:\n file_hash = md5_hash\n hash_algorithm = 'md5'\n datadir_base = os.path.expanduser(cache_dir)\n if not os.access(datadir_base, os.W_OK):\n datadir_base = os.path.join('/tmp', '.keras')\n datadir = os.path.join(datadir_base, cache_subdir)\n _makedirs_exist_ok(datadir)\n\n if untar:\n untar_fpath = os.path.join(datadir, fname)\n fpath = untar_fpath + '.tar.gz'\n else:\n fpath = os.path.join(datadir, fname)\n\n download = False\n if os.path.exists(fpath):\n # File found; verify integrity if a hash was provided.\n if file_hash is not None:\n if not validate_file(fpath, file_hash, algorithm=hash_algorithm):\n print('A local file was found, but {} file hash not match original value of {}.'.format(\n hash_algorithm, file_hash))\n download = True\n else:\n download = True\n\n if download:\n print('Downloading data from', origin)\n\n class ProgressTracker(object):\n # Maintain progbar for the lifetime of download.\n # This design was chosen for Python 2.7 compatibility.\n progbar = None\n\n def dl_progress(count, block_size, total_size):\n if ProgressTracker.progbar is None:\n if total_size == -1:\n total_size = None\n ProgressTracker.progbar = Progbar(total_size)\n else:\n ProgressTracker.progbar.update(count * block_size)\n\n error_msg = 'URL fetch failure on {}: {} -- {}'\n try:\n try:\n urlretrieve(origin, fpath, dl_progress)\n except HTTPError as e:\n raise Exception(error_msg.format(origin, e.code, e.msg))\n except URLError as e:\n raise Exception(error_msg.format(origin, e.errno, e.reason))\n except (Exception, KeyboardInterrupt) as e:\n if os.path.exists(fpath):\n os.remove(fpath)\n raise e\n ProgressTracker.progbar = None\n\n if untar:\n if not os.path.exists(untar_fpath):\n _extract_archive(fpath, datadir, archive_format='tar')\n return untar_fpath\n\n if extract:\n _extract_archive(fpath, datadir, archive_format)\n\n return fpath","def download_models_and_data():\n\n for file in DATA_FILES:\n download_file(file[\"url\"], file[\"path\"])","def fetch_and_extract(self, filename):\n # type: (Text) -> None\n\n with io.open(filename, 'wb') as f:\n self.bucket.download_fileobj(filename, f)\n with tarfile.open(filename, \"r:gz\") as tar:\n tar.extractall(self.data_dir)","def fetch_and_extract(self, model_dir):\n # type: (Text) -> None\n\n model_name = os.path.basename(model_dir)\n base_dir = os.path.dirname(model_dir)\n data_dict = self.collection.find_one({'model_name': model_name})\n if not data_dict:\n raise ValueError(\"Collection does not contain a model for given name '{}'\".format(model_name))\n data_dict.pop('_id')\n data_dict.pop('model_name')\n for (file_name, data) in data_dict.items():\n _, file_extension = os.path.splitext(file_name)\n file_loc = \"{0}/{1}/{2}\".format(base_dir, model_name, file_name)\n model_base_dir = os.path.dirname(file_loc)\n if not os.path.exists(model_base_dir):\n os.makedirs(model_base_dir)\n if file_extension == '.json':\n with open(file_loc, 'w') as json_file:\n json.dump(data, json_file)\n else:\n with open(file_loc, 'wb') as pickle_file:\n pickle_file.write(data)","def download_and_extract_data(tmp_dir, dataset):\n url = dataset[0]\n print(dataset)\n compressed_filename = os.path.basename(url)\n compressed_file = generator_utils.maybe_download(\n tmp_dir, compressed_filename, url)\n\n for file in dataset[1]:\n tf.logging.info(\"Reading file: %s\" % file)\n filepath = os.path.join(tmp_dir, file)\n\n # Extract from tar if needed.\n if not tf.gfile.Exists(filepath):\n with tarfile.open(compressed_file, \"r:gz\") as corpus_tar:\n corpus_tar.extractall(tmp_dir)\n\n documents_filename, labels_filename = dataset[1]\n documents_filepath = os.path.join(tmp_dir, documents_filename)\n labels_filepath = os.path.join(tmp_dir, labels_filename)\n return documents_filepath, labels_filepath","def download_untar(url, download_path, extract_path=None):\n file_name = url.split('/')[-1]\n if extract_path is None:\n extract_path = download_path\n tar_file_path = os.path.join(download_path, file_name)\n download(tar_file_path, url)\n sys.stdout.flush()\n print('Extracting {} archive into {}'.format(tar_file_path, extract_path))\n untar(tar_file_path, extract_path)\n os.remove(tar_file_path)","def fetch(self) -> None:\n archive_path = os.path.join(self._output_dir, self._archive_name)\n self._download_file(self._parsed_url.original_url, archive_path)\n try:\n with zipfile.ZipFile(archive_path, \"r\") as zip_file:\n zip_file.extractall(path=self._output_dir)\n except zipfile.BadZipfile:\n raise REANAFetcherError(\"The provided zip file is not valid\")\n\n os.remove(archive_path)\n\n if not self._discover_workflow_specs():\n top_level_entries = [\n os.path.join(self._output_dir, entry)\n for entry in os.listdir(self._output_dir)\n ]\n # Some zip archives contain a single directory with all the files.\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\n top_level_dir = top_level_entries[0]\n # Move all entries inside the top level directory\n # to the output directory.\n for entry in os.listdir(top_level_dir):\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\n os.rmdir(top_level_dir)","def get_data():\n\n url = 'http://www.cs.cmu.edu/~dbamman/data/booksummaries.tar.gz'\n target_path = 'books.tar.gz'\n if not os.path.isfile(target_path):\n response = requests.get(url, stream=True)\n if response.status_code == 200:\n open(target_path, 'wb').write(response.content)\n\n # open tar zip file file\n file = tarfile.open(target_path)\n # extracting the tar zip file\n file.extractall('.')\n file.close()\n return True","def download(self):\n\n if self._check_exists():\n return\n\n os.makedirs(self.raw_folder, exist_ok=True)\n os.makedirs(self.processed_folder, exist_ok=True)\n\n # download files\n for url in self.resources:\n filename = url.rpartition('/')[2]\n download_and_extract_archive(url, download_root=self.raw_folder, filename=filename, md5=None)\n\n print('Processing...')\n\n training_set = (\n self.read_image_label_file(os.path.join(self.raw_folder, 'mnist_all_rotation_normalized_float_train_valid.amat'))\n )\n test_set = (\n self.read_image_label_file(os.path.join(self.raw_folder, 'mnist_all_rotation_normalized_float_test.amat'))\n )\n\n with open(os.path.join(self.processed_folder, self.training_file), 'wb') as f:\n torch.save(training_set, f)\n with open(os.path.join(self.processed_folder, self.test_file), 'wb') as f:\n torch.save(test_set, f)\n\n print('Done!')","def __download(self):\n\n # Use the default repository if set to True\n if self.repository is True:\n self.repository = self.__default_repository\n\n if not self.repository and not self.url:\n tarball = 'ucx-{}.tar.gz'.format(self.__version)\n self.url = '{0}/v{1}/{2}'.format(self.__baseurl, self.__version,\n tarball)","def download_dataset(dataset):\n\n if dataset not in URLS:\n print(f\"unknown dataset {dataset}\")\n sys.exit(0)\n\n filename = f'{dataset}.tar.gz'\n url = URLS[dataset]\n\n if not os.path.exists(filename):\n print(f'downloading dataset \"{dataset}\"')\n os.system(f'curl \"{url}\" -o {filename}')\n else:\n print(f'zipfile \"{filename}\" already exists, remove it if you want to re-download.')\n\n if not os.path.exists(dataset):\n print(f'extracting \"{filename}\"')\n os.system(f'tar -xvf {filename}')\n else:\n print(f'folder \"{dataset}\" already exists, remove it if you want to re-create.')\n\n image_chips = f'{dataset}/image-chips'\n label_chips = f'{dataset}/label-chips'\n if not os.path.exists(image_chips) and not os.path.exists(label_chips):\n print(\"creating chips\")\n libs.images2chips.run(dataset)\n else:\n print(f'chip folders \"{image_chips}\" and \"{label_chips}\" already exist, remove them to recreate chips.')","def maybe_download_pretrained_vgg(self):\n DESTINATION_MODEL_TAR_PATH = self.PATH_TO_MODEL + self.MODEL_FILE\n\n # Check if model downloaded\n if not os.path.exists (self.PATH_TO_MODEL + self.MODEL_NAME + '/frozen_inference_graph.pb'):\n\n # Download model\n print 'Downloading pre-trained model...'\n opener = urllib.request.URLopener()\n opener.retrieve(self.DOWNLOAD_BASE + self.MODEL_FILE, DESTINATION_MODEL_TAR_PATH)\n\n # Extracting model\n print 'Extracting model...'\n tar_file = tarfile.open(DESTINATION_MODEL_TAR_PATH)\n\n for file in tar_file.getmembers():\n file_name = os.path.basename(file.name)\n if 'frozen_inference_graph.pb' in file_name:\n tar_file.extract(file, self.PATH_TO_MODEL)\n\n self.maybe_download_model = True","def download(self):\n file_url = posixpath.join(self.mirrors, self.resources)\n _urlretrieve(file_url, os.path.join(self.root, self.resources))","def download(self):\n file_url = posixpath.join(self.mirrors, self.resources)\n _urlretrieve(file_url, os.path.join(self.root, self.resources))","def unzip() -> None:\n logger = logging.getLogger(__name__)\n logger.info('Download the dataset')\n\n # define the destination\n destination = project_dir / 'data' / 'raw'\n\n # extract zip\n zip_file = ZipFile(destination / \"original.zip\")\n zip_file.extractall(destination)","def _download(self, url, rel_path):\n \n tmp_dir = \"TMP_DIR=`mktemp -d`;\"\n wget_cmd = [ tmp_dir, \"wget\", \"-nv\", \"-O\", \"$TMP_DIR/archive.tgz\", url, \";\" ]\n wget_cmd = ' '.join(wget_cmd)\n \n mkdir_cmd = \"mkdir -p %s ;\" % (\"./remote_resources/\" + rel_path)\n \n cleandir_cmd = \"rm -Rf %s/* ;\" % (\"./remote_resources/\" + rel_path)\n \n untar_cmd = [ \"tar\", \"xf\", \"$TMP_DIR/archive.tgz\", \"-C\", \"./remote_resources/%s\" % rel_path, \";\" ]\n untar_cmd = ' '.join(untar_cmd)\n \n remove_cmd = \"rm -Rf $TMP_DIR;\"\n \n return self._ssh(' '.join([ wget_cmd, mkdir_cmd, cleandir_cmd, untar_cmd, remove_cmd ]))","def download():\n raise NotImplementedError","def download_and_extract(self, data_path=None):\n if data_path is None:\n data_path = 'data'\n\n if not os.path.exists(data_path):\n os.makedirs(data_path)\n\n filename = self.DATA_URL.split('/')[-1]\n filepath = os.path.join(data_path, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (\n filename,\n float(count * block_size) / float(total_size) * 100.0)\n )\n\n sys.stdout.flush()\n\n filepath, _ = urllib.request.urlretrieve(CifarData.DATA_URL,\n filepath,\n _progress)\n statinfo = os.stat(filepath)\n self._verbose_print('Successfully downloaded', filename,\n statinfo.st_size, 'bytes.')\n\n with tarfile.open(filepath, 'r:gz') as t:\n dataset_dir = os.path.join(data_path, t.getmembers()[0].name)\n t.extractall(data_path)\n\n return dataset_dir","def _retrieve_models(local=True):\n # Check if the download folder exists\n def _get_meta_data(model_name, file):\n return {\n \"data\": {\n \"id\": model_name,\n \"name\": model_name,\n \"description\": model_name,\n \"filename\": os.path.join(\n app.config[\"DOWNLOAD_DIR\"], file),\n \"created\": time.ctime(os.path.getctime(\n os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n file))),\n \"modified\": time.ctime(os.path.getmtime(\n os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n file)))\n }\n }\n\n if not os.path.exists(app.config[\"DOWNLOAD_DIR\"]):\n os.makedirs(app.config[\"DOWNLOAD_DIR\"])\n\n if not local:\n # Fetch from a Nexus-hosted catalog\n resources = app.forge.search({\"type\": \"EmbeddingModel\"})\n for resource in resources:\n app.models[resource.name] = {\n \"data\": digest_model_data(resource),\n }\n app.forge.download(\n resource, \"distribution.contentUrl\",\n app.config[\"DOWNLOAD_DIR\"])\n\n pipeline_path = os.path.join(\n app.config[\"DOWNLOAD_DIR\"],\n resource.distribution.name)\n app.models[resource.name][\"object\"] = EmbeddingPipeline.load(\n pipeline_path,\n embedder_interface=GraphElementEmbedder,\n embedder_ext=\"zip\")\n\n # Clear the downloads dir\n for f in os.listdir(app.config[\"DOWNLOAD_DIR\"]):\n try:\n os.remove(os.path.join(app.config[\"DOWNLOAD_DIR\"], f))\n except Exception:\n shutil.rmtree(os.path.join(app.config[\"DOWNLOAD_DIR\"], f))\n else:\n # Fetch from a local dir\n for (_, dirs, files) in os.walk(app.config[\"DOWNLOAD_DIR\"]):\n for path in dirs + files:\n if path[0] != \".\":\n match = re.match(r\"(.*)\\.zip\", path)\n if match:\n model_name = match.groups()[0]\n else:\n model_name = path\n app.models[model_name] = _get_meta_data(model_name, path)\n pipeline_path = os.path.join(\n app.config[\"DOWNLOAD_DIR\"], path)\n app.models[model_name][\"object\"] = EmbeddingPipeline.load(\n pipeline_path,\n embedder_interface=GraphElementEmbedder,\n embedder_ext=\"zip\")\n break","def download_data():\r\n print('Downloading cifar-10 data...')\r\n request.urlretrieve(dataurl)\r\n print('Done')\r\n print('Please unzip files. command is:')\r\n print('gzip -d cifar-10-python.tar.gz')\r\n print('tar -xf cifar-10-python.tar')\r\n exit()","def _save_tar(self, path: Path, metadata: Dict, model: Model) -> NoReturn:\n model_file_name = self.repo_config.model_file_name\n\n try:\n # Create a tmp directory\n with tempfile.TemporaryDirectory() as tmp_path:\n os.chdir(tmp_path)\n\n # Save to file the dat\n with open(model_file_name, 'wb') as f:\n pickle.dump(model, f)\n\n with open(self._METADATA_FILENAME, 'w') as f:\n json.dump(metadata, f)\n\n # Tar the tmp directory with all the files\n with tarfile.open(self._TAR_FILE_NAME, \"w\") as tar:\n for file in os.listdir(tmp_path):\n tar.add(file)\n\n # Upload the tar file to S3\n s3_file_path = str(Path(str(path) + '/' + self._TAR_FILE_NAME))\n tmp_file_path = tmp_path + '/' + self._TAR_FILE_NAME\n self.s3_client.upload_file(tmp_file_path, self.s3_bucket, s3_file_path)\n finally:\n del tmp_path","def download(self):\n logger.info(f\"downloading project {self}\")\n self.project.storage.download(f\"{self.path}/releasemanifest\", None)\n self.extract()","def _get_download_url(model_name, version=__version__):\n\n version = \"0.0.0\" if \"vectors\" in model_name else version\n\n return (\n f\"https://github.com/mauna-ai/spacy-numberbatch/releases/download/\"\n f\"{version}/{model_name}-{version}.tar.gz\" )","def fetch_and_extract(self, filename):\n # type: (Text) -> None\n\n blob = self.bucket.blob(filename)\n blob.download_to_filename(filename)\n\n with tarfile.open(filename, \"r:gz\") as tar:\n tar.extractall(self.data_dir)","def _download(self) -> None:\n if self._check_integrity():\n print(\"Files already downloaded and verified\")\n return\n\n download_and_extract_archive(\n self.url,\n self.root,\n filename=self.filename,\n md5=self.md5 if self.checksum else None,\n )\n\n # Generate train/val/test splits\n # Always check the sha256 of this file before executing\n # to avoid malicious code injection\n with working_dir(self.root):\n with open(\"split.py\") as f:\n split = f.read().encode(\"utf-8\")\n assert hashlib.sha256(split).hexdigest() == self.sha256\n exec(split)","def download_and_extract(self, package_name):\n raise NotImplementedError('Implement this method.')","def download_kitti(\n root_dir : str,\n keep_zip: bool = True\n) -> None:\n \n # URL's to .zip files\n kitti_raw_lidar_fname = 'data_depth_velodyne.zip'\n kitti_depth_annot_fname = 'data_depth_annotated.zip'\n kitti_test_set_fname = 'data_depth_selection.zip'\n kitti_calib_fnames = ['2011_09_26_calib.zip',\n '2011_09_28_calib.zip',\n '2011_09_29_calib.zip', \n '2011_09_30_calib.zip', \n '2011_10_03_calib.zip']\n \n kitti_base_url = 'http://s3.eu-central-1.amazonaws.com/avg-kitti'\n kitti_raw_data_base_url = '/'.join([kitti_base_url, 'raw_data'])\n kitti_raw_lidar_url = '/'.join([kitti_base_url, kitti_raw_lidar_fname])\n kitti_depth_annot_url = '/'.join([kitti_base_url, kitti_depth_annot_fname])\n kitti_test_set_url = '/'.join([kitti_base_url, kitti_test_set_fname])\n\n # Local path\n dest_dir = os.path.join(root_dir, 'kitti_depth_completion')\n\n # Check if output directory exist\n if not(os.path.isdir(dest_dir)):\n os.makedirs(dest_dir, exist_ok=True)\n print('Destination diectory does not exist, created new directory at: {}'.format(dest_dir))\n\n # Make temporary directory\n tmp_dir = '/'.join([dest_dir, 'tmp'])\n if not(os.path.isdir(tmp_dir)):\n os.makedirs(tmp_dir, exist_ok=True)\n\n # Directories name\n # lidar_raw_dir = 'velodyne_raw'\n # ground_truth_dir = 'groundtruth'\n rgb_dir = 'image'\n intrinsics_dir = 'intrinsics'\n \n # Raw lidar\n dest_zip_file = '/'.join([tmp_dir, kitti_raw_lidar_fname])\n\n if not os.path.isfile(dest_zip_file):\n # Check in case the files was donwloaded and previous run didn't complete.\n download_file(kitti_raw_lidar_url, dest_zip_file, verbose=True)\n else:\n print('Destination file already exist, skip downloading')\n\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\n \n # Groundtruh (annotations)\n dest_zip_file = '/'.join([tmp_dir, kitti_depth_annot_fname])\n\n if not os.path.isfile(dest_zip_file):\n # Check in case the files was donwloaded and previous run didn't complete.\n download_file(kitti_depth_annot_url, dest_zip_file, verbose=True)\n else:\n print('Destination file already exist, skip downloading')\n\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\n\n # Test/val selection data\n dest_zip_file = '/'.join([tmp_dir, kitti_test_set_fname])\n if not os.path.isfile(dest_zip_file):\n # Check in case the files was donwloaded and previous run didn't complete.\n download_file(kitti_test_set_url, dest_zip_file, verbose=True)\n else:\n print('Destination file already exist, skip downloading')\n\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\n \n # Move test set and validation select sets to place\n depth_sel_path = \"/\".join([dest_dir, 'depth_selection'])\n shutil.move(\"/\".join([depth_sel_path, \"val_selection_cropped\"]), \"/\".join([dest_dir, \"val_selection_cropped\"]))\n shutil.move(\"/\".join([depth_sel_path, \"test_depth_completion_anonymous\"]), \"/\".join([dest_dir, \"test_depth_completion_anonymous\"]))\n shutil.rmtree(depth_sel_path)\n\n # Calibration files\n calib_dest_dir = '/'.join([dest_dir, intrinsics_dir])\n\n for calib_file in kitti_calib_fnames:\n calib_file_url = '/'.join([kitti_raw_data_base_url, calib_file])\n dest_zip_file = '/'.join([tmp_dir, calib_file])\n if not os.path.isfile(dest_zip_file):\n download_file(calib_file_url, dest_zip_file, verbose=True)\n else:\n print('Destination file already exist')\n\n unzip_file(dest_zip_file, calib_dest_dir, keep_zip=keep_zip)\n \n # RGB images for train and validation \n # (test and val select are downloaded with RGB iamges)\n print('Downloading RGB images\\n')\n for split in ['train', 'val']:\n # List all depth maps\n split_root_path = '/'.join([dest_dir, split])\n depth_map_list = os.listdir(split_root_path)\n print(f'-Split type: {split}, Split size: {len(depth_map_list)} [depth map]\\n')\n\n # Iterate over depth maps in split\n for depth_map_name in depth_map_list[0:1]:\n # Initialize\n zip_file_name = depth_map_name + '.zip'\n orig_file_url = '/'.join([kitti_raw_data_base_url, depth_map_name[:-5], zip_file_name])\n rgb_dest_path = '/'.join([split_root_path, depth_map_name, rgb_dir])\n dest_zip_file = '/'.join([tmp_dir, zip_file_name])\n tmp_depth_map_path = '/'.join([tmp_dir, depth_map_name])\n tmp_depth_map_img_path = '/'.join([tmp_depth_map_path, rgb_dir])\n\n # Check if destination file or .zip file already exist\n if os.path.isdir(rgb_dest_path):\n print('{} : destination files already exist, skipping\\n'.format(depth_map_name))\n continue\n\n # Check if already exist\n if os.path.exists(dest_zip_file): \n print('{} : file already exist, skipping\\n'.format(depth_map_name))\n else:\n # Download\n download_file(orig_file_url, dest_zip_file, verbose=True)\n \n # Unzip\n unzip_file(dest_zip_file, tmp_dir, rgb_raw_zip=True, keep_zip=keep_zip)\n\n # Move images to correct directory\n shutil.move(tmp_depth_map_img_path, rgb_dest_path)\n shutil.rmtree(tmp_depth_map_path)\n \n # Remove temporary directory\n if not keep_zip:\n shutil.rmtree(tmp_dir)","def download(self):\n pass","def download(self):\n pass","def _get_or_download_model(self, download: bool) -> Optional[str]:\n home_dir = home_directory()\n downloaded_models_dir = os.path.join(home_dir, MODELS_DIR)\n\n if not os.path.exists(downloaded_models_dir):\n os.makedirs(downloaded_models_dir)\n\n model_hashed_name = get_hashed_name(self.embedding + self.model)\n model_path = os.path.join(downloaded_models_dir, model_hashed_name)\n\n if not os.path.exists(model_path):\n if not download:\n return\n\n model_download_path = model_path + '.' + self.embedding_cls.EMBEDDING_MODELS[self.model].format\n model_download_url = self.embedding_cls.EMBEDDING_MODELS[self.model].download_url\n print(f\"Model does not exists, Downloading model: {self.model}\")\n download_from_url(model_download_url, model_download_path)\n extract_file(model_download_path, model_path)\n if os.path.exists(model_download_path):\n os.remove(model_download_path)\n print(f\"Model downloaded successfully!\")\n return model_path","def download(\n self,\n overwrite: bool = False,\n refresh_token: bool = False,\n show_progress: bool = True,\n ):\n _LOGGER.info(f\"Downloading model {self.stub}\")\n\n if self.card_file:\n _LOGGER.info(f\"Downloading model card {self.stub}\")\n self.card_file.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n if self.onnx_file:\n _LOGGER.info(f\"Downloading model onnx {self.stub}\")\n self.onnx_file.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n if self.onnx_file_gz:\n _LOGGER.info(f\"Downloading model onnx gz {self.stub}\")\n self.onnx_file_gz.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n self.download_framework_files(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n for data in self._data.values():\n _LOGGER.info(f\"Downloading model data {data.name} {self.stub}\")\n data.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )\n\n for recipe in self._recipes:\n _LOGGER.info(f\"Downloading model recipe {recipe.display_name} {self.stub}\")\n recipe.download(\n overwrite=overwrite,\n refresh_token=refresh_token,\n show_progress=show_progress,\n )","def do_download_model_job(self):\n\n # time the download\n download_start = time.time()\n\n # sanity check on version is implicit in send\n reply = self.channel.DownloadModel(ModelDownloadRequest(header=self.create_message_header(), model_header=self.model_header))\n received_model_proto = reply.model\n received_model_version = received_model_proto.header.version\n\n # handling possability that the recieved model is delta\n received_model_is_delta = received_model_proto.header.is_delta\n received_model_delta_from_version = received_model_proto.header.delta_from_version\n\n\n self.logger.info(\"{} took {} seconds to download the model\".format(self, round(time.time() - download_start, 3)))\n\n self.validate_header(reply)\n self.logger.info(\"{} - Completed the model downloading job.\".format(self))\n\n check_type(reply, GlobalModelUpdate, self.logger)\n\n # ensure we actually got a new model version\n check_not_equal(received_model_version, self.model_header.version, self.logger)\n\n # set our model header\n self.model_header = received_model_proto.header\n\n # compute the aggregated tensors dict from the model proto\n agg_tensor_dict = deconstruct_proto(model_proto=received_model_proto, compression_pipeline=self.compression_pipeline)\n\n # TODO: If updating of base is not done every round, we will no longer be able to use the base to get\n # the current global values of the shared tensors.\n if self.send_model_deltas:\n self.update_base_for_deltas(tensor_dict=agg_tensor_dict,\n delta_from_version=received_model_delta_from_version,\n version=received_model_version,\n is_delta=received_model_is_delta)\n # base_for_deltas can provide the global shared tensor values here\n agg_tensor_dict = self.base_for_deltas[\"tensor_dict\"]\n\n # restore any tensors held out from aggregation\n tensor_dict = {**agg_tensor_dict, **self.holdout_tensors}\n\n if self.opt_treatment == OptTreatment.CONTINUE_GLOBAL:\n with_opt_vars = True\n else:\n with_opt_vars = False\n\n # Ensuring proper initialization regardless of model state. Initial global models\n # do not contain optimizer state, and so cannot be used to reset the optimizer params.\n if reply.model.header.version == 0:\n with_opt_vars = False\n self.wrapped_model.reset_opt_vars()\n\n self.wrapped_model.set_tensor_dict(tensor_dict, with_opt_vars=with_opt_vars)\n self.logger.debug(\"Loaded the model.\")\n\n # if we are supposed to save the best model and the model is the best, we save it\n if reply.is_global_best and self.save_best_native_path:\n self.wrapped_model.save_native(self.save_best_native_path, self.save_best_native_kwargs)\n self.logger.info(\"Saving best model to {}\".format(self.save_best_native_path))\n\n # if we should save metadata and have meta in protobuf\n if self.save_metadata_path is not None and reply.metadata_yaml is not None:\n with open(self.save_metadata_path, 'w') as f:\n f.write(reply.metadata_yaml)\n self.logger.info(\"Wrote metadata to {}\".format(self.save_metadata_path))\n\n # FIXME: for the CONTINUE_LOCAL treatment, we need to store the status in case of a crash.\n if self.opt_treatment == OptTreatment.RESET:\n try:\n self.wrapped_model.reset_opt_vars()\n except:\n self.logger.exception(\"Failed to reset the optimization variables.\")\n raise\n else:\n self.logger.debug(\"Reset the optimization variables.\")","def fetch_the_data():\n subprocess.run([\"wget\", \"https://storage.googleapis.com/recipe-box/recipes_raw.zip\"])\n subprocess.run([\"unzip\", \"recipes_raw.zip\", \"-d\", RECIPES_DIRPATH])\n subprocess.run([\"rm\", \"recipes_raw.zip\"])","def download_tar_file(tar_remote, save_dir, force_overwrite, cleanup=False):\n tar_download_path = download_from_remote(tar_remote, save_dir, force_overwrite)\n untar(tar_download_path, cleanup=cleanup)","def download(self):\n cloud_path = f\"gs://{const.GCS_BUCKET}/{self.GCS_PATH}\"\n # download label file\n label_zip = download_file_from_gcs(\n cloud_path, self.root, self.LABEL_ZIP\n )\n with zipfile.ZipFile(label_zip, \"r\") as zip_dir:\n zip_dir.extractall(self.root)\n\n # download tfexamples for a dataset split\n tfexamples_zip = download_file_from_gcs(\n cloud_path, self.root, self.SPLITS_ZIP.get(self.split)\n )\n with zipfile.ZipFile(tfexamples_zip, \"r\") as zip_dir:\n zip_dir.extractall(self.root)","def download_and_unzip_dataset(url, path):\n dl = urllib.urlretrieve(url)\n zf = zipfile.ZipFile(dl[0])\n zf.extractall(path)\n return zf","def download_and_prepare(self):\n self._download_and_prepare()","def download(self, session: Session = None):\n\n def dont_skip_download():\n return not self.skip_download\n\n def archive_path_does_not_exist():\n return not os.path.exists(self.archive_path)\n\n # Check to see if the dataset already exists.\n if self._does_not_exist_or_forced():\n if dont_skip_download() or archive_path_does_not_exist():\n self._download()\n else:\n logger.info(f\"Download skipped.\")\n\n with unknown_progress(f\"Extracting\"):\n self._extract()\n\n # Clean-up archive file if -c/--clean is used.\n if self.clean:\n logger.info(f\"Removing archive file.\")\n os.remove(self.archive_path)\n\n with unknown_progress(f\"Parsing metadata\"):\n self._save_metadata()\n\n with unknown_progress(f\"Moving images\"):\n self._move_images()\n\n with unknown_progress(f\"Cleaning up\"):\n self._clean_up()","def _search_model_extractor(self, repo_url):\n # Find model folder\n # The model name is the name of the author of the repository\n model_name = 'snippet_model_%s' % repo_url.split('/')[-2]\n # It is stored in the models_data folder\n models_data = Path(pkg_resources.resource_filename('credentialdigger',\n 'models_data'))\n dev_model = models_data / model_name\n\n # Find extractor binary\n # Get name and version from the metafile\n with open(dev_model / 'meta.json', 'r') as f:\n meta = json.loads(f.read())\n inner_folder = dev_model / ('%s-%s' % (meta['name'], meta['version']))\n # There should be only one binary in the inner folder\n extractor_file = list(inner_folder.glob('**/*.bin'))[0]\n\n return dev_model.name, extractor_file.name","def prepare_sagemaker_model(self):\n try:\n sagemaker_session = sagemaker.Session()\n bucket = sagemaker_session.default_bucket() # you can specify other bucket name here\n prefix = f'mlflow_model/{self.model_name}-{self.model_version}'\n tmp_file = '/tmp/model.tar.gz'\n\n model_local_path = self._download_model_version_files()\n self._make_tar_gz_file(tmp_file, model_local_path)\n tar_gz_s3_location = sagemaker_session.upload_data(path=tmp_file, bucket=bucket, key_prefix=prefix)\n logging.info(f'model.tar.gz upload to {tar_gz_s3_location}')\n\n return tar_gz_s3_location\n\n except Exception as e:\n logging.error(e)","def download_pretrained_models(\n models_root_dir='/tmp/sketch_rnn/models',\n pretrained_models_url=PRETRAINED_MODELS_URL):\n tf.gfile.MakeDirs(models_root_dir)\n zip_path = os.path.join(\n models_root_dir, os.path.basename(pretrained_models_url))\n if os.path.isfile(zip_path):\n tf.logging.info('%s already exists, using cached copy', zip_path)\n else:\n tf.logging.info('Downloading pretrained models from %s...',\n pretrained_models_url)\n urlretrieve(pretrained_models_url, zip_path)\n tf.logging.info('Download complete.')\n tf.logging.info('Unzipping %s...', zip_path)\n with zipfile.ZipFile(zip_path) as models_zip:\n models_zip.extractall(models_root_dir)\n tf.logging.info('Unzipping complete.')","def download_and_install(self, version=\"latest\", os_name=None, bitness=None, show_progress_bar=True):\n filename_with_path = self.download(version,\n os_name=os_name,\n bitness=bitness,\n show_progress_bar=show_progress_bar)\n filename = os.path.split(filename_with_path)[1]\n if filename.lower().endswith(\".tar.gz\"):\n extract_dir = os.path.join(self.get_download_path(version), filename[:-7])\n elif filename.lower().endswith(\".zip\"):\n extract_dir = os.path.join(self.get_download_path(version), filename[:-4])\n else:\n error_message = \"Unknown archive format: {0}\".format(filename)\n logger.error(error_message)\n raise RuntimeError(error_message)\n if not os.path.isdir(extract_dir):\n os.makedirs(extract_dir)\n logger.debug(\"Created directory: {0}\".format(extract_dir))\n if filename.lower().endswith(\".tar.gz\"):\n with tarfile.open(os.path.join(self.get_download_path(version), filename), mode=\"r:*\") as tar:\n tar.extractall(extract_dir)\n logger.debug(\"Extracted files: {0}\".format(\", \".join(tar.getnames())))\n elif filename.lower().endswith(\".zip\"):\n with zipfile.ZipFile(os.path.join(self.get_download_path(version), filename), mode=\"r\") as driver_zipfile:\n driver_zipfile.extractall(extract_dir)\n driver_filename = self.get_driver_filename(os_name=os_name)\n for root, dirs, files in os.walk(extract_dir):\n for curr_file in files:\n if curr_file == driver_filename:\n actual_driver_filename = os.path.join(root, curr_file)\n break\n if os_name is None:\n os_name = platform.system()\n if os_name in ['Darwin', 'Linux']:\n symlink_src = actual_driver_filename\n symlink_target = os.path.join(self.link_path, driver_filename)\n if os.path.islink(symlink_target):\n if os.path.samefile(symlink_src, symlink_target):\n logger.info(\"Symlink already exists: {0} -> {1}\".format(symlink_target, symlink_src))\n return tuple([symlink_src, symlink_target])\n else:\n logger.warning(\"Symlink {0} already exists and will be overwritten.\".format(symlink_target))\n os.unlink(symlink_target)\n os.symlink(symlink_src, symlink_target)\n logger.info(\"Created symlink: {0} -> {1}\".format(symlink_target, symlink_src))\n st = os.stat(symlink_src)\n os.chmod(symlink_src, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)\n return tuple([symlink_src, symlink_target])\n elif os_name == \"Windows\":\n src_file = actual_driver_filename\n dest_file = os.path.join(self.link_path, driver_filename)\n if os.path.isfile(dest_file):\n logger.info(\"File {0} already exists and will be overwritten.\".format(dest_file))\n shutil.copy2(src_file, dest_file)\n return tuple([src_file, dest_file])","def _download_chieffi04():\n url = 'http://cdsarc.u-strasbg.fr/viz-bin/nph-Cat/tar.gz?J%2FApJ%2F608%2F405'\n import urllib\n print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')\n if os.path.exists(MASTERFILE):\n os.remove(MASTERFILE)\n urllib.urlretrieve(url,MASTERFILE)\n\n import tarfile\n tar = tarfile.open(MASTERFILE)\n tar.extractall(path=DATADIR)\n tar.close()","def _download_chieffi04():\n url = 'http://cdsarc.u-strasbg.fr/viz-bin/nph-Cat/tar.gz?J%2FApJ%2F608%2F405'\n import urllib\n print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')\n if os.path.exists(MASTERFILE):\n os.remove(MASTERFILE)\n urllib.urlretrieve(url,MASTERFILE)\n\n import tarfile\n tar = tarfile.open(MASTERFILE)\n tar.extractall(path=DATADIR)\n tar.close()","def download_model(\n model: str,\n force: bool = False,\n) -> str:\n if model in {\"small\", \"medium\", \"large\"}:\n latest_version = get_latest_version(model)\n model = f\"da_dacy_{model}_trf-{latest_version}\"\n mdl_version = model.split(\"-\")[-1]\n\n if model not in models_url:\n raise ValueError(\n f\"The model '{model}' is not available in DaCy. Please use dacy.models() to see a\"\n + \" list of all models\",\n )\n\n mdl = model.split(\"-\")[0]\n if mdl in get_installed_models() and not force and version(mdl) == mdl_version:\n return mdl\n install(models_url[model])\n return mdl"],"string":"[\n \"def download_and_unpack_model(model_name, model_date='20200711'):\\n\\n # pretrained models\\n pretrained_models_dir = os.path.join(ROOT_DIR, 'pre-trained-models')\\n create_directory_if_not_exists(pretrained_models_dir)\\n\\n # pretrained model archives\\n model_archive_dir = os.path.join(pretrained_models_dir, 'archives')\\n create_directory_if_not_exists(model_archive_dir)\\n\\n # determine the (expected) path of the downloaded model\\n model_file = f'{model_name}.tar.gz'\\n model_archive_path = os.path.join(model_archive_dir, model_file)\\n\\n # if the tar.gz exists, try to unpack it\\n retry = False\\n if os.path.exists(model_archive_path):\\n logger.info(f'Attempting to unpack {full_path(model_archive_path)}...')\\n try:\\n shutil.unpack_archive(model_archive_path, os.path.dirname(model_archive_dir))\\n except EOFError:\\n logger.info('Cannot unpack. Archive is corrupt. Attempting to retry...')\\n retry = True\\n\\n # if the tar.gz does not exist or is corrupt (unpacking failed), download it, then unpack it\\n if not os.path.exists(model_archive_path) or retry:\\n base_url = 'http://download.tensorflow.org/models/object_detection/tf2/'\\n url = base_url + model_date + '/' + model_file\\n logger.info(f'Downloading from {url}...')\\n\\n # download file as stream\\n response = requests.get(url, stream=True)\\n with open(model_archive_path, 'wb') as handle:\\n progress_bar = tqdm(unit=\\\"B\\\", total=int(response.headers['Content-Length']), unit_scale=True, unit_divisor=1024)\\n for data in response.iter_content(chunk_size=8192):\\n progress_bar.update(len(data))\\n handle.write(data)\\n progress_bar.close()\\n\\n # try to unpack tar.gz\\n logger.info(f'Attempting to unpack {full_path(model_archive_path)}...')\\n try:\\n shutil.unpack_archive(model_archive_path, os.path.dirname(model_archive_dir))\\n except EOFError:\\n # give up if unpacking failed\\n logger.info('Archive cannot be unpacked')\\n sys.exit(1)\\n\\n logger.info('Successfully downloaded and unpacked model')\",\n \"def download_model(\\\\\\n download_base='http://download.tensorflow.org/models/object_detection/', \\\\\\n model_name='ssd_mobilenet_v1_coco_11_06_2017'\\\\\\n ):\\n\\n # add tar gz to the end of file name\\n model_file = model_name + '.tar.gz'\\n\\n try:\\n opener = urllib.request.URLopener()\\n opener.retrieve(download_base + model_file, \\\\\\n model_file)\\n tar_file = tarfile.open(model_file)\\n for f in tar_file.getmembers():\\n file_name = os.path.basename(f.name)\\n if 'frozen_inference_graph.pb' in file_name:\\n tar_file.extract(f, os.getcwd())\\n except Exception as e:\\n raise\",\n \"def maybe_download_and_extract():\\n dest_directory = FLAGS.model_dir\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def maybe_download_and_extract():\\n dest_directory = FLAGS.model_dir\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath,\\n reporthook=_progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def maybe_download_and_extract():\\n dest_directory = FLAGS['model_dir']\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' %\\n (filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def download_pre_trained_model (model_name):\\n model_url = cfg.LIST_MODEL_TO_DOWNLOAD[model_name]\\n\\n file_name = (model_url.split(\\\"/\\\")[-1]).split(\\\".\\\")[0] # get file name from url\\n\\n # create directory if not exit\\n if not os.path.exists(os.path.join(cfg.PATH_PRE_TRAINED_MODELS,file_name)):\\n if not os.path.exists(cfg.PATH_PRE_TRAINED_MODELS):\\n os.mkdir(cfg.PATH_PRE_TRAINED_MODELS)\\n try:\\n click.echo(click.style(f\\\"\\\\n Downloading the {file_name} model \\\\n\\\", bg='green', bold=True, fg='white'))\\n file_location = save_zip_from_url(model_url, cfg.PATH_PRE_TRAINED_MODELS)\\n \\n click.echo(click.style(f'\\\\n Extraction of {file_name} ...\\\\n', bg='blue', bold=True, fg='white'))\\n\\n # Extract tar-file to annotation directory\\n with tarfile.open(name=file_location) as tar:\\n for member in tqdm(iterable=tar.getmembers(), total=len(tar.getmembers())):\\n tar.extract(member=member, path=cfg.PATH_PRE_TRAINED_MODELS)\\n # delete tar-file\\n os.remove(file_location)\\n return 0\\n\\n except expression as identifier:\\n return -1\\n else:\\n click.echo(click.style(f\\\"\\\\n {file_name} have been downloaded \\\\n\\\", bg='blue', bold=True, fg='white'))\\n return 1\",\n \"def maybe_download_and_extract(modeldir):\\n\\tdest_directory = modeldir\\n\\tif not os.path.exists(dest_directory):\\n\\t\\tos.makedirs(dest_directory)\\n\\tfilename = DATA_URL.split('/')[-1]\\n\\tfilepath = os.path.join(dest_directory, filename)\\n\\tif not os.path.exists(filepath):\\n\\t\\tdef _progress(count, block_size, total_size):\\n\\t\\t\\tsys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n\\t\\t\\t\\t\\tfilename, float(count * block_size) / float(total_size) * 100.0))\\n\\t\\t\\tsys.stdout.flush()\\n\\t\\tfilepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n\\t\\tprint()\\n\\t\\tstatinfo = os.stat(filepath)\\n\\t\\tprint('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n\\ttarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def maybe_download_and_extract():\\n dest_directory = MODEL_DIR\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def download(self):\\n if not os.path.exists(self.pkg_dir):\\n os.makedirs(self.pkg_dir)\\n\\n url = self.metadata_pkg[\\\"url\\\"]\\n\\n # Download modelpkg only if not already downloaded.\\n if os.path.exists(self.file_path):\\n self.is_downloaded = True\\n else:\\n print(f\\\"Fetching {os.path.basename(self.file_path)} model package from {url} to {self.file_path}\\\", flush=True)\\n r = requests.get(url, stream=True)\\n with open(self.file_path, \\\"wb\\\") as file_out:\\n for chunk in r.iter_content(chunk_size=2048):\\n file_out.write(chunk)\\n r.close()\\n self.is_downloaded = True\",\n \"def maybe_download_and_extract(self, DATA_URL):\\n\\n print('Will download the pre-trained Inception Model to the same path with this validator!')\\n self.Model_Save_Path = os.path.join(\\\"/\\\",\\n os.getcwd(), 'DownLoaded_Inception/')\\n print('Start download to ' + self.Model_Save_Path)\\n\\n if not os.path.exists(self.Model_Save_Path):\\n os.makedirs(self.Model_Save_Path)\\n\\n dest_directory = self.Model_Save_Path\\n\\n filename = self.DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n filepath, _ = urllib.request.urlretrieve(\\n DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Succesfully downloaded', filename,\\n statinfo.st_size, 'bytes.')\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def _download_zip_model(model_url: str, model_path: str) -> str:\\n if os.path.exists(model_path):\\n return model_path\\n extract_dir = os.path.dirname(model_path)\\n url_model_name = os.path.basename(urlparse(model_url).path)\\n tmp_zip_file_path = os.path.join(extract_dir, url_model_name)\\n _download_file(model_url, tmp_zip_file_path)\\n _unzip_file(tmp_zip_file_path, extract_dir)\\n return model_path\",\n \"def maybe_download_and_extract(JSONE):\\n print(\\\"maybe_download_and_extract\\\")\\n dest_directory = JSONE['model_dir'][0]\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\\n print(\\\"maybe_download_and_extract\\\")\",\n \"def maybe_download_and_extract(dir_path, model_url, is_zipfile=False, is_tarfile=False):\\n if not os.path.exists(dir_path):\\n os.makedirs(dir_path)\\n filename = model_url.split('/')[-1]\\n filepath = os.path.join(dir_path, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write(\\n '\\\\r>> Download %s %.1f%%' %(filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n file_path, _ = urllib.urlretrieve(model_url, filepath, reporthook=_progress)\\n print('\\\\n')\\n statinfo = os.stat(filepath)\\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\\n if is_zipfile:\\n with zipfile.ZipFile(filepath) as zf:\\n # zip_dir = zf.namelist()[0]\\n zf.extractall(dir_path)\\n elif is_tarfile:\\n tarfile.open(file_path, 'r:gz').extractall(dir_path)\",\n \"def maybe_download():\\n\\n print(\\\"Downloading Inception 5h Model ...\\\")\\n download.maybe_download_and_extract(url=data_url, download_dir=data_dir)\",\n \"def download_ckpt(model_name):\\n with open (\\\"./utils/models.json\\\", \\\"r\\\") as f:\\n url = json.loads(f.read())[model_name] \\n model_name_tar = url.split(\\\"/\\\")[-1]\\n model_name_dir = url.split(\\\"/\\\")[-1].split(\\\".\\\")[0]\\n if not chk_model(model_name_dir):\\n try: \\n print('Downloading %s to %s...' % (url, model_name_tar))\\n os.system(\\\"wget {}\\\".format(str(url))) \\n os.system(\\\"tar xvf {}\\\".format(str(model_name_tar))) \\n os.remove(model_name_tar)\\n # assert os.path.exists()# check \\n return model_name_dir\\n except Exception as e:\\n print(e)\\n return model_name_dir\",\n \"def _download(self):\\n self._system.download_file(\\\"http://curl.haxx.se/download/\\\" + self._tar_name)\",\n \"def _download(self):\\n self._system.download(\\\"http://geant4.web.cern.ch/geant4/support/source/\\\" + self._tar_name)\",\n \"def download(self, root='./'):\\n dir = os.path.join(root, 'tiny-imagenet-200')\\n dir_train = os.path.join(dir, 'train')\\n if os.path.exists(dir) and os.path.exists(dir_train):\\n print('==> Already downloaded.')\\n return\\n\\n path = Path(os.path.join(root, 'tiny-imagenet-200.zip'))\\n if not os.path.exists(path):\\n os.makedirs(path.parent, exist_ok=True)\\n\\n print('==> Downloading TinyImagenet200...')\\n with urllib.request.urlopen(self.url) as response, \\\\\\n open(str(path), 'wb') as out_file:\\n shutil.copyfileobj(response, out_file)\\n\\n print('==> Extracting TinyImagenet200...')\\n with zipfile.ZipFile(str(path)) as zf:\\n zf.extractall(root)\",\n \"def downloadModel(url):\\n print('Model download started...')\\n fileName = url.split('/')[-1]\\n filePath = f'../kerasModels/{fileName}'\\n\\n if not os.path.exists(os.path.dirname(filePath)):\\n try:\\n os.makedirs(os.path.dirname(fileName))\\n except OSError as exc:\\n if exc.errno != errno.EXIST:\\n raise\\n\\n urlretrieve(url, fileName)\\n print('Model download completed')\\n return fileName\",\n \"def download_and_extract(down_dir=download_dir, url=tuda_url):\\n\\n wget.download(url, down_dir) \\n tar_filepath = os.path.join(down_dir, \\\"german-speechdata-package-v2.tar.gz\\\")\\n #with tarfile.open(tar_filepath, \\\"r\\\") as tar:\\n # tar.extractall(down_dir)\",\n \"def download_model(model, model_hash, model_dir):\\n if not os.path.isdir(model_dir):\\n os.mkdir(model_dir)\\n filename = os.path.join(model_dir, model)\\n\\n logger.info(f\\\"Downloading {model} to {filename}...\\\")\\n urllib.request.urlretrieve(\\n os.path.join(\\\"http://genesis.ugent.be/uvpublicdata/ms2pip/\\\", model), filename\\n )\\n if not check_model_integrity(filename, model_hash):\\n raise InvalidXGBoostModelError()\",\n \"def _download_model_version_files(self):\\n model_version = self.client.get_model_version(name=self.model_name, version=self.model_version)\\n artifact_uri = model_version.source\\n return _download_artifact_from_uri(artifact_uri)\",\n \"def _download_model(download_url):\\n\\n pip_args = [\\\"--no-cache-dir\\\"]\\n cmd = [sys.executable, \\\"-m\\\", \\\"pip\\\", \\\"install\\\"] + pip_args + [download_url]\\n\\n return subprocess.call(cmd, env=os.environ.copy())\",\n \"def download_model(model_arch, alt_model_name=None):\\n\\n download_base_url = 'http://download.tensorflow.org/models/object_detection/'\\n \\n tf_org_model_name = downloadable_models[model_arch]['tf.org.model_name']\\n base_pipeline_config = downloadable_models[model_arch]['pipeline_file']\\n\\n model_archive_basename = tf_org_model_name + '.tar.gz'\\n dst_dir = './downloaded_pretrained_models'\\n model_archive_path = join(dst_dir, model_archive_basename)\\n\\n if not isdir(dst_dir):\\n makedirs(dst_dir)\\n\\n # \\\"cache\\\"\\n if not exists(model_archive_path):\\n print(\\\"downloading ::\\\", download_base_url + model_archive_basename)\\n urlretrieve(\\n url=download_base_url + model_archive_basename,\\n filename=model_archive_path\\n )\\n else:\\n print(\\\"model archive was already downloaded yay :D\\\")\\n\\n # saves to ./output/$model_name/training\\n dst = join('./output', alt_model_name) \\\\\\n if alt_model_name is not None else join(\\n './output', model_arch\\n )\\n \\n print(\\\"extracting download.tensorflow.org model archive...\\\")\\n tar = tarfile.open(model_archive_path)\\n tar.extractall(path=dst)\\n tar.close()\\n\\n if exists(join(dst, 'training')):\\n raise FileExistsError(\\n \\\"\\\\n\\\\nModel directory already exists. \\\\\\n \\\\n- Overwriting models that were potentially trained is forbidden.\\\\\\n \\\\n- If you want to train a new model from scratch, \\\\\\n \\\\n pass a non-existent alt_model_name.\\\\\\n \\\\n\\\\n>> These are the model names already in use:\\\\\\n \\\\n {}\\\".format(\\\"\\\\n\\\".join(listdir('./output')))\\n )\\n\\n # not elegant, but whatever works man\\n shutil.move(\\n src=join(dst, tf_org_model_name),\\n dst=join(dst, 'training')\\n )\\n # store model_arch for future ref\\n system(\\\"echo {} > {}\\\".format(model_arch, join(\\n dst,\\n 'training/model.arch')\\n )\\n )\\n # make sure its integrity checks out\\n assert_ckpt(join(dst, 'training'))\\n \\n # make export directory for inference executables\\n model_name = model_arch if alt_model_name is None else alt_model_name\\n export_dir = join('./output', model_name, 'export')\\n if not exists(export_dir):\\n makedirs(export_dir)\\n\\n # rename `checkpoint` file so that training can actually take off...\\n # don't ask, but... \\n # https://github.com/tensorflow/models/issues/5053#issuecomment-441423962\\n shutil.move(join(dst, 'training/checkpoint'), join(dst, 'training/old_checkpoint'))\\n \\n # path to training dir and path to base training pipeline config\\n return join(dst, 'training'), export_dir, base_pipeline_config\",\n \"def download_tf_params():\\n\\n if not os.path.exists(MODEL_DIR):\\n os.makedirs(MODEL_DIR)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(MODEL_DIR, filename)\\n\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename, float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n statinfo = os.stat(filepath)\\n print()\\n print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.')\\n\\n tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR)\",\n \"def download_zipped_model(manifest, assert_hash=False):\\n zipped_model_path = manifest[\\\"model_filepath\\\"]\\n zipped_model = client.file(zipped_model_path).getFile().name\\n if assert_hash:\\n assert_model_md5(zipped_model)\\n return zipped_model_path\",\n \"def download_model():\\n logging.info(\\\"[genreml] Downloading model...\\\")\\n with urllib.request.urlopen(config.FMAModelConfig.FMA_MODEL_URL) as f:\\n data = f.read()\\n open(config.FMAModelConfig.FMA_MODEL_PATH, 'wb').write(data)\\n logging.info(\\\"[genreml] Model download complete\\\")\",\n \"def download_model(name: str) -> str:\\n model_name, model_type, model_url = ModelInfo.get_model_info(name)\\n model_path = _create_dirs(model_name)\\n if model_type == \\\"single\\\":\\n model_path = _download_file(model_url, model_path)\\n elif model_type == \\\"zip\\\":\\n model_path = _download_zip_model(model_url, model_path)\\n else:\\n print(f\\\"model type {model_type} not yet implemented\\\")\\n model_path = \\\"\\\"\\n return model_path\",\n \"def download_model_from_url(\\n url: str = typer.Argument(..., help='The link to a model'),\\n path: Path = typer.Argument(..., file_okay=True, help='The saved path and file name.')\\n):\\n\\n from modelci.hub.registrar import download_model_from_url\\n\\n download_model_from_url(url, path)\\n typer.echo(f'{path} model downloaded successfully.')\",\n \"def download_model(source, target, filename):\\n if not os.path.exists(target):\\n os.mkdir(target) \\n target_file = str(Path(target).joinpath(filename))\\n if os.path.exists(target_file):\\n print('model already exists, skipping download')\\n return\\n print(\\\"Downloading from {} to {}\\\".format(source, target))\\n wget.download(source, target_file) \\n print(\\\"\\\\nDone!\\\")\",\n \"def download(self):\\n if not self.url:\\n raise RuntimeError(self.tips)\\n\\n download_file_name = os.path.join(\\n self.raw_path, os.path.splitext(os.path.basename(self.url))[0]\\n )\\n file_format = self.url.split(\\\".\\\")[-1]\\n if \\\"amazon\\\" in self.url:\\n raw_file_path = os.path.join(\\n self.raw_path, f\\\"{self.dataset_name}.json.{file_format}\\\"\\n )\\n else:\\n raw_file_path = os.path.join(\\n self.raw_path, f\\\"{self.dataset_name}.{file_format}\\\"\\n )\\n if \\\"1drv.ms\\\" in self.url:\\n file_format = \\\"zip\\\"\\n raw_file_path = os.path.join(\\n self.raw_path, f\\\"{self.dataset_name}.{file_format}\\\"\\n )\\n if not os.path.exists(raw_file_path):\\n print(f\\\"download_file: url: {self.url}, raw_file_path: {raw_file_path}\\\")\\n download_file(self.url, raw_file_path)\\n if \\\"amazon\\\" in raw_file_path:\\n # amazon dataset do not unzip\\n print(\\\"amazon dataset do not decompress\\\")\\n return\\n elif file_format == \\\"gz\\\":\\n file_name = raw_file_path.replace(\\\".gz\\\", \\\"\\\")\\n with gzip.open(raw_file_path, \\\"rb\\\") as fin:\\n with open(file_name, \\\"wb\\\") as fout:\\n shutil.copyfileobj(fin, fout)\\n else:\\n shutil.unpack_archive(\\n raw_file_path, self.raw_path, format=get_format(file_format)\\n )\\n\\n if not os.path.exists(download_file_name):\\n return\\n elif os.path.isdir(download_file_name):\\n os.rename(\\n download_file_name, os.path.join(self.raw_path, self.dataset_name)\\n )\\n else:\\n os.rename(\\n download_file_name,\\n os.path.join(\\n self.raw_path,\\n f'{self.dataset_name}.{download_file_name.split(\\\".\\\")[-1]}',\\n ),\\n )\",\n \"def download():\\n base_loc = DATA_DIR + '/raw/human_activity'\\n loc = base_loc + '/human_activity.zip'\\n if os.path.exists(loc):\\n print('Path already exists at {}. If you wish to re-download you must delete this folder.'.format(loc))\\n return\\n if not os.path.exists(base_loc):\\n os.mkdir(base_loc)\\n\\n url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/00341/HAPT%20Data%20Set.zip'\\n urllib.request.urlretrieve(url, loc)\\n\\n with zipfile.ZipFile(loc, 'r') as zip_ref:\\n zip_ref.extractall(base_loc)\",\n \"def get_file(\\n fname,\\n origin,\\n untar=False,\\n cache_subdir=\\\"datasets\\\",\\n extract=False,\\n archive_format=\\\"auto\\\",\\n cache_dir=None,\\n):\\n if cache_dir is None:\\n cache_dir = os.path.join(os.path.expanduser(\\\"~\\\"), \\\".keras\\\")\\n datadir_base = os.path.expanduser(cache_dir)\\n if not os.access(datadir_base, os.W_OK):\\n datadir_base = os.path.join(\\\"/tmp\\\", \\\".keras\\\")\\n datadir = os.path.join(datadir_base, cache_subdir)\\n if not os.path.exists(datadir):\\n os.makedirs(datadir)\\n\\n if untar:\\n untar_fpath = os.path.join(datadir, fname)\\n fpath = untar_fpath + \\\".tar.gz\\\"\\n else:\\n fpath = os.path.join(datadir, fname)\\n\\n download = False\\n if os.path.exists(fpath):\\n download = False\\n else:\\n download = True\\n\\n if download:\\n print(\\\"Downloading data from\\\", origin)\\n\\n class ProgressTracker(object):\\n # Maintain progbar for the lifetime of download.\\n # This design was chosen for Python 2.7 compatibility.\\n progbar = None\\n\\n def dl_progress(count, block_size, total_size):\\n if ProgressTracker.progbar is None:\\n if total_size == -1:\\n total_size = None\\n ProgressTracker.progbar = Progbar(total_size)\\n else:\\n ProgressTracker.progbar.update(count * block_size)\\n\\n error_msg = \\\"URL fetch failure on {}: {} -- {}\\\"\\n try:\\n try:\\n urlretrieve(origin, fpath, dl_progress)\\n except HTTPError as e:\\n raise Exception(error_msg.format(origin, e.code, e.msg))\\n except URLError as e:\\n raise Exception(error_msg.format(origin, e.errno, e.reason))\\n except (Exception, KeyboardInterrupt) as e:\\n if os.path.exists(fpath):\\n os.remove(fpath)\\n raise\\n ProgressTracker.progbar = None\\n\\n if untar:\\n if not os.path.exists(untar_fpath):\\n _extract_archive(fpath, datadir, archive_format=\\\"tar\\\")\\n return untar_fpath\\n\\n if extract:\\n _extract_archive(fpath, datadir, archive_format)\\n\\n return fpath\",\n \"def download_data():\\n url = 'https://www.dropbox.com/s/xk4glpk61q3qrg2/imdb.tgz?dl=1'\\n urllib.request.urlretrieve(url, 'imdb.tgz')\\n tar = tarfile.open(\\\"imdb.tgz\\\")\\n tar.extractall()\\n tar.close()\",\n \"def download_data():\\n url = 'https://www.dropbox.com/s/8oehplrobcgi9cq/imdb.tgz?dl=1'\\n urllib.request.urlretrieve(url, 'imdb.tgz')\\n tar = tarfile.open(\\\"imdb.tgz\\\")\\n tar.extractall()\\n tar.close()\",\n \"def download_caffe_model(model_name, meta_info, dst_dir='./model'):\\n if not os.path.isdir(dst_dir):\\n os.mkdir(dst_dir)\\n model_name = os.path.join(dst_dir, model_name)\\n assert 'prototxt' in meta_info, \\\"missing prototxt url\\\"\\n prototxt = mx.test_utils.download(meta_info['prototxt'], model_name+'_deploy.prototxt')\\n assert 'caffemodel' in meta_info, \\\"mssing caffemodel url\\\"\\n caffemodel = mx.test_utils.download(meta_info['caffemodel'], model_name+'.caffemodel')\\n assert 'mean' in meta_info, 'no mean info'\\n mean = meta_info['mean']\\n if isinstance(mean, str):\\n mean = mx.test_utils.download(mean, model_name+'_mean.binaryproto')\\n return (prototxt, caffemodel, mean)\",\n \"def maybe_download_and_extract():\\n dest_directory = FLAGS.data_dir\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n r = requests.Session().get(DATA_URL)\\n with open(filepath, 'wb') as fd:\\n for chunk in r.iter_content(500):\\n fd.write(chunk)\\n statinfo = os.stat(filepath)\\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n extracted_dir_path = os.path.join(dest_directory, 'cifar-10-batches-bin')\\n if not os.path.exists(extracted_dir_path):\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def download_and_unzip_data(\\n url=\\\"https://storage.googleapis.com/simpeg/em_examples/tdem_groundedsource/tdem_groundedsource.tar\\\",\\n):\\n # download the data\\n downloads = utils.download(url)\\n\\n # directory where the downloaded files are\\n directory = downloads.split(\\\".\\\")[0]\\n\\n # unzip the tarfile\\n tar = tarfile.open(downloads, \\\"r\\\")\\n tar.extractall()\\n tar.close()\\n\\n return downloads, directory\",\n \"def _download(self) -> None:\\n download_url(\\n self.url,\\n self.root,\\n filename=self.data_dir,\\n md5=self.md5 if self.checksum else None,\\n )\\n self._extract()\",\n \"def maybe_download_and_extract():\\n dest_directory = FLAGS.data_dir\\n if not os.path.exists(dest_directory):\\n os.makedirs(dest_directory)\\n filename = DATA_URL.split('/')[-1]\\n filepath = os.path.join(dest_directory, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (filename,\\n float(count * block_size) / float(total_size) * 100.0))\\n sys.stdout.flush()\\n\\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\\n print()\\n statinfo = os.stat(filepath)\\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\\n extracted_dir_path = os.path.join(dest_directory, 'cifar-10-batches-bin')\\n if not os.path.exists(extracted_dir_path):\\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\",\n \"def download_model(\\n self, model_name: str, save_path: Union[str, Path] = \\\"./zoo/model.pth\\\"\\n ):\\n # check if the model name is valide\\n assert model_name in list(\\n self.meta.name\\n ), f\\\"requested model {model_name} does not exist\\\"\\n # TODO: fix, using pathlib\\n # check if save_path already has the model\\n save_dir = os.path.dirname(save_path)\\n if not os.path.exists(save_dir):\\n os.mkdir(save_dir)\\n else:\\n assert not os.path.exists(\\n save_path\\n ), f\\\"the save_path {save_path} is already used\\\"\\n\\n # fetch the model file\\n model_id = self.meta[self.meta[\\\"name\\\"] == model_name][\\\"models\\\"].iloc[0]\\n model_path = model_id.split(\\\"/\\\")\\n self.pkg[model_path[0]][model_path[1]].fetch(save_path)\",\n \"def download(self, force: bool = False):\\n # hide this import, since we'll only ever need it _once_ (per model version)\\n from .. import io as tio\\n\\n model_fname = self.model_fpath.name\\n url = urllib.parse.urljoin(\\n \\\"https://github.com/bdewilde/textacy-data/releases/download/\\\",\\n self.model_id + \\\"/\\\" + model_fname,\\n )\\n tio.utils.download_file(\\n url, filename=model_fname, dirpath=self.data_dir, force=force,\\n )\",\n \"def download(fnames):\\n download_path = Path('./models')\\n if not download_path.exists() or not download_path.is_dir():\\n print('The directory \\\\'models\\\\' does not exist!')\\n print('Please ensure you are in the top level of the visual-attention-networks repository')\\n print(' and that the \\\\'models\\\\' directory exists')\\n sys.exit()\\n\\n server_url = 'https://github.com/davidmascharka/tbd-nets/releases/download/v1.0/'\\n if isinstance(fnames, str): # a single file\\n fnames = [fnames]\\n for fname in fnames:\\n if (download_path / fname).exists():\\n print('Skipping {}: the file already exists'.format(fname))\\n continue\\n\\n print('Downloading {}'.format(fname))\\n urlretrieve(server_url + fname, str((download_path/fname).absolute()), _download_info)\\n print('Finished')\",\n \"def get_pretrained_model(destination):\\n url = \\\"https://storage.googleapis.com/download.magenta.tensorflow.org/models/ \\\\\\n arbitrary_style_transfer.tar.gz\\\"\\n\\n os.system(\\\"curl -o arbitrary_style_transfer.tar.gz {0}\\\".format(url))\\n with tarfile.open(\\\"arbitrary_style_transfer.tar.gz\\\") as tar:\\n if not os.path.exists(destination):\\n os.makedirs(destination)\\n tar.extractall(destination)\",\n \"def download_model(key, output_path):\\n print(\\\"Looking fro model in {}\\\".format(output_path))\\n if os.path.exists(output_path):\\n print('File at: {} already exists'.format(output_path))\\n else:\\n download_file_from_s3(key, output_path)\",\n \"def download_model_from_gcs(self):\\n # download model\\n download_file_from_gcs(self.config.model_bucket_name,\\n self.config.model_gcs_path,\\n self.config.model_local_path)\\n\\n # download lable columns\\n download_file_from_gcs(self.config.model_bucket_name,\\n self.config.labels_gcs_path,\\n self.config.labels_local_path)\",\n \"def download(self) -> None:\\n os.makedirs(self.root, exist_ok=True)\\n\\n for subset in self.subsets:\\n if self._check_subset_integrity(subset):\\n print(f\\\"{subset} already downloaded and verified\\\")\\n continue\\n path = os.path.join(self.root, subset + \\\".tar.gz\\\")\\n\\n already_present = os.path.isfile(path)\\n if not already_present:\\n subset_url = self.openslr_url + subset + \\\".tar.gz\\\"\\n with requests.get(subset_url, stream=True) as r:\\n r.raise_for_status()\\n with open(path, \\\"wb\\\") as f:\\n shutil.copyfileobj(r.raw, f)\\n\\n archive_md5 = self.data_files[subset][\\\"archive_md5\\\"]\\n if utils.checksum_file(path, \\\"md5\\\") != archive_md5:\\n raise utils.DownloadError(f\\\"invalid checksum for {path}\\\")\\n\\n with tarfile.open(path, mode=\\\"r|gz\\\") as tar:\\n tar.extractall(self.root)\\n\\n if not already_present:\\n os.remove(path)\",\n \"def download(self):\\n\\n with open(self.dataset_path) as dataset_file:\\n dataset = json.load(dataset_file)\\n\\n path = \\\"\\\".join([POST_HIT_PATH, dataset[\\\"dataset\\\"][\\\"data_path\\\"]])\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n protocole = dataset[\\\"dataset\\\"][\\\"protocole\\\"]\\n\\n download_links = []\\n\\n for resource in dataset[\\\"dataset\\\"][\\\"resources\\\"]:\\n file_path = \\\"\\\".join([path, resource[\\\"filename\\\"]])\\n\\n #Check if the the download link has not been used before (One download link for all)\\n if resource[\\\"download_link\\\"] not in download_links:\\n \\n print(\\\"DOWNLOADING : {}\\\".format(resource[\\\"filename\\\"]))\\n f = urllib.request.urlopen(resource[\\\"download_link\\\"])\\n data = f.read()\\n with open(file_path, \\\"wb\\\") as donwload_file:\\n donwload_file.write(data)\\n\\n download_links.append(resource[\\\"download_link\\\"])\\n\\n \\n #Extract all files from the tar archives if necessary\\n if tarfile.is_tarfile(file_path):\\n tf = tarfile.open(file_path)\\n tf.exractall()\",\n \"def fetch(self) -> None:\\n workflow_spec_path = os.path.join(self._output_dir, self._spec)\\n self._download_file(self._parsed_url.original_url, workflow_spec_path)\",\n \"def download_and_extract(self, package_name):\\n self.download(package_name)\\n self.extract(package_name)\",\n \"def load_model(self, model_name, model_url):\\n\\n fname = join(self.root, model_name)\\n if not isfile(fname):\\n if self.verbose:\\n print(\\\"Could not find \\\" + fname + \\\".. attempt download\\\")\\n with urllib.request.urlopen(model_url) as res, open(fname, 'wb') as f:\\n shutil.copyfileobj(res, f)\\n if self.verbose:\\n print(\\\"Download complete.. model: \\\" + fname)\\n elif self.verbose:\\n print(\\\"Found model \\\" + fname + \\\"! :)\\\")\\n\\n model = load_model(fname)\\n self.model = model\",\n \"def get_file(fname,\\n origin,\\n untar=False,\\n md5_hash=None,\\n file_hash=None,\\n cache_subdir='datasets',\\n hash_algorithm='auto',\\n extract=False,\\n archive_format='auto',\\n cache_dir=None):\\n if cache_dir is None:\\n cache_dir = os.path.join(os.path.expanduser('~'), '.keras')\\n if md5_hash is not None and file_hash is None:\\n file_hash = md5_hash\\n hash_algorithm = 'md5'\\n datadir_base = os.path.expanduser(cache_dir)\\n if not os.access(datadir_base, os.W_OK):\\n datadir_base = os.path.join('/tmp', '.keras')\\n datadir = os.path.join(datadir_base, cache_subdir)\\n _makedirs_exist_ok(datadir)\\n\\n fname = path_to_string(fname)\\n\\n if untar:\\n untar_fpath = os.path.join(datadir, fname)\\n fpath = untar_fpath + '.tar.gz'\\n else:\\n fpath = os.path.join(datadir, fname)\\n\\n download = False\\n if os.path.exists(fpath):\\n # File found; verify integrity if a hash was provided.\\n if file_hash is not None:\\n if not validate_file(fpath, file_hash, algorithm=hash_algorithm):\\n print('A local file was found, but it seems to be '\\n 'incomplete or outdated because the ' + hash_algorithm +\\n ' file hash does not match the original value of ' + file_hash +\\n ' so we will re-download the data.')\\n download = True\\n else:\\n download = True\\n\\n if download:\\n print('Downloading data from', origin)\\n\\n class ProgressTracker(object):\\n # Maintain progbar for the lifetime of download.\\n # This design was chosen for Python 2.7 compatibility.\\n progbar = None\\n\\n def dl_progress(count, block_size, total_size):\\n if ProgressTracker.progbar is None:\\n if total_size == -1:\\n total_size = None\\n ProgressTracker.progbar = Progbar(total_size)\\n else:\\n ProgressTracker.progbar.update(count * block_size)\\n\\n error_msg = 'URL fetch failure on {}: {} -- {}'\\n try:\\n try:\\n urlretrieve(origin, fpath, dl_progress)\\n except urllib.error.HTTPError as e:\\n raise Exception(error_msg.format(origin, e.code, e.msg))\\n except urllib.error.URLError as e:\\n raise Exception(error_msg.format(origin, e.errno, e.reason))\\n except (Exception, KeyboardInterrupt) as e:\\n if os.path.exists(fpath):\\n os.remove(fpath)\\n raise\\n ProgressTracker.progbar = None\\n\\n if untar:\\n if not os.path.exists(untar_fpath):\\n _extract_archive(fpath, datadir, archive_format='tar')\\n return untar_fpath\\n\\n if extract:\\n _extract_archive(fpath, datadir, archive_format)\\n\\n return fpath\",\n \"def _download_untar(self, dep):\\n tar = sh.Command(\\\"tar\\\")\\n download_url = self.dependency_dict[dep][\\\"tarball\\\"]\\n dlname = download_url.split(\\\"/\\\")[-1]\\n download_path = Path(\\\".\\\") / dlname\\n logger.debug(f\\\"downloading {dep} at {download_url} to {dlname}\\\")\\n if self.quiet:\\n trackers = ()\\n else:\\n trackers = (ProgressTracker(DataTransferBar()),)\\n request_download(download_url, download_path, trackers=trackers)\\n logger.debug(\\n f\\\"downloaded file {download_path}, size\\\"\\n f\\\" {download_path.stat().st_size}\\\"\\n )\\n try:\\n tar(\\\"xvf\\\", download_path, **self.output_kwargs)\\n except:\\n logger.error(f\\\"untar of {download_path} failed\\\")\\n sys.exit(1)\",\n \"def download_data():\\n url = 'https://www.dropbox.com/s/h9ubx22ftdkyvd5/ml-latest-small.zip?dl=1'\\n urllib.request.urlretrieve(url, 'ml-latest-small.zip')\\n zfile = zipfile.ZipFile('ml-latest-small.zip')\\n zfile.extractall()\\n zfile.close()\",\n \"def download(uri: str) -> None:\\n logger = logging.getLogger(__name__)\\n logger.info('Download the dataset')\\n\\n # create destination dirs\\n destination = project_dir / 'data' / 'raw'\\n destination.mkdir(exist_ok=True, parents=True)\\n\\n # download the file\\n urllib.request.urlretrieve(uri, destination / \\\"original.zip\\\")\",\n \"def get_file(fname,\\n origin,\\n untar=False,\\n md5_hash=None,\\n file_hash=None,\\n cache_subdir='datasets',\\n hash_algorithm='auto',\\n extract=False,\\n archive_format='auto',\\n cache_dir=None):\\n if cache_dir is None:\\n cache_dir = os.path.join(os.path.expanduser('~'), '.keras')\\n if md5_hash is not None and file_hash is None:\\n file_hash = md5_hash\\n hash_algorithm = 'md5'\\n datadir_base = os.path.expanduser(cache_dir)\\n if not os.access(datadir_base, os.W_OK):\\n datadir_base = os.path.join('/tmp', '.keras')\\n datadir = os.path.join(datadir_base, cache_subdir)\\n _makedirs_exist_ok(datadir)\\n\\n if untar:\\n untar_fpath = os.path.join(datadir, fname)\\n fpath = untar_fpath + '.tar.gz'\\n else:\\n fpath = os.path.join(datadir, fname)\\n\\n download = False\\n if os.path.exists(fpath):\\n # File found; verify integrity if a hash was provided.\\n if file_hash is not None:\\n if not validate_file(fpath, file_hash, algorithm=hash_algorithm):\\n print('A local file was found, but {} file hash not match original value of {}.'.format(\\n hash_algorithm, file_hash))\\n download = True\\n else:\\n download = True\\n\\n if download:\\n print('Downloading data from', origin)\\n\\n class ProgressTracker(object):\\n # Maintain progbar for the lifetime of download.\\n # This design was chosen for Python 2.7 compatibility.\\n progbar = None\\n\\n def dl_progress(count, block_size, total_size):\\n if ProgressTracker.progbar is None:\\n if total_size == -1:\\n total_size = None\\n ProgressTracker.progbar = Progbar(total_size)\\n else:\\n ProgressTracker.progbar.update(count * block_size)\\n\\n error_msg = 'URL fetch failure on {}: {} -- {}'\\n try:\\n try:\\n urlretrieve(origin, fpath, dl_progress)\\n except HTTPError as e:\\n raise Exception(error_msg.format(origin, e.code, e.msg))\\n except URLError as e:\\n raise Exception(error_msg.format(origin, e.errno, e.reason))\\n except (Exception, KeyboardInterrupt) as e:\\n if os.path.exists(fpath):\\n os.remove(fpath)\\n raise e\\n ProgressTracker.progbar = None\\n\\n if untar:\\n if not os.path.exists(untar_fpath):\\n _extract_archive(fpath, datadir, archive_format='tar')\\n return untar_fpath\\n\\n if extract:\\n _extract_archive(fpath, datadir, archive_format)\\n\\n return fpath\",\n \"def download_models_and_data():\\n\\n for file in DATA_FILES:\\n download_file(file[\\\"url\\\"], file[\\\"path\\\"])\",\n \"def fetch_and_extract(self, filename):\\n # type: (Text) -> None\\n\\n with io.open(filename, 'wb') as f:\\n self.bucket.download_fileobj(filename, f)\\n with tarfile.open(filename, \\\"r:gz\\\") as tar:\\n tar.extractall(self.data_dir)\",\n \"def fetch_and_extract(self, model_dir):\\n # type: (Text) -> None\\n\\n model_name = os.path.basename(model_dir)\\n base_dir = os.path.dirname(model_dir)\\n data_dict = self.collection.find_one({'model_name': model_name})\\n if not data_dict:\\n raise ValueError(\\\"Collection does not contain a model for given name '{}'\\\".format(model_name))\\n data_dict.pop('_id')\\n data_dict.pop('model_name')\\n for (file_name, data) in data_dict.items():\\n _, file_extension = os.path.splitext(file_name)\\n file_loc = \\\"{0}/{1}/{2}\\\".format(base_dir, model_name, file_name)\\n model_base_dir = os.path.dirname(file_loc)\\n if not os.path.exists(model_base_dir):\\n os.makedirs(model_base_dir)\\n if file_extension == '.json':\\n with open(file_loc, 'w') as json_file:\\n json.dump(data, json_file)\\n else:\\n with open(file_loc, 'wb') as pickle_file:\\n pickle_file.write(data)\",\n \"def download_and_extract_data(tmp_dir, dataset):\\n url = dataset[0]\\n print(dataset)\\n compressed_filename = os.path.basename(url)\\n compressed_file = generator_utils.maybe_download(\\n tmp_dir, compressed_filename, url)\\n\\n for file in dataset[1]:\\n tf.logging.info(\\\"Reading file: %s\\\" % file)\\n filepath = os.path.join(tmp_dir, file)\\n\\n # Extract from tar if needed.\\n if not tf.gfile.Exists(filepath):\\n with tarfile.open(compressed_file, \\\"r:gz\\\") as corpus_tar:\\n corpus_tar.extractall(tmp_dir)\\n\\n documents_filename, labels_filename = dataset[1]\\n documents_filepath = os.path.join(tmp_dir, documents_filename)\\n labels_filepath = os.path.join(tmp_dir, labels_filename)\\n return documents_filepath, labels_filepath\",\n \"def download_untar(url, download_path, extract_path=None):\\n file_name = url.split('/')[-1]\\n if extract_path is None:\\n extract_path = download_path\\n tar_file_path = os.path.join(download_path, file_name)\\n download(tar_file_path, url)\\n sys.stdout.flush()\\n print('Extracting {} archive into {}'.format(tar_file_path, extract_path))\\n untar(tar_file_path, extract_path)\\n os.remove(tar_file_path)\",\n \"def fetch(self) -> None:\\n archive_path = os.path.join(self._output_dir, self._archive_name)\\n self._download_file(self._parsed_url.original_url, archive_path)\\n try:\\n with zipfile.ZipFile(archive_path, \\\"r\\\") as zip_file:\\n zip_file.extractall(path=self._output_dir)\\n except zipfile.BadZipfile:\\n raise REANAFetcherError(\\\"The provided zip file is not valid\\\")\\n\\n os.remove(archive_path)\\n\\n if not self._discover_workflow_specs():\\n top_level_entries = [\\n os.path.join(self._output_dir, entry)\\n for entry in os.listdir(self._output_dir)\\n ]\\n # Some zip archives contain a single directory with all the files.\\n if len(top_level_entries) == 1 and os.path.isdir(top_level_entries[0]):\\n top_level_dir = top_level_entries[0]\\n # Move all entries inside the top level directory\\n # to the output directory.\\n for entry in os.listdir(top_level_dir):\\n shutil.move(os.path.join(top_level_dir, entry), self._output_dir)\\n os.rmdir(top_level_dir)\",\n \"def get_data():\\n\\n url = 'http://www.cs.cmu.edu/~dbamman/data/booksummaries.tar.gz'\\n target_path = 'books.tar.gz'\\n if not os.path.isfile(target_path):\\n response = requests.get(url, stream=True)\\n if response.status_code == 200:\\n open(target_path, 'wb').write(response.content)\\n\\n # open tar zip file file\\n file = tarfile.open(target_path)\\n # extracting the tar zip file\\n file.extractall('.')\\n file.close()\\n return True\",\n \"def download(self):\\n\\n if self._check_exists():\\n return\\n\\n os.makedirs(self.raw_folder, exist_ok=True)\\n os.makedirs(self.processed_folder, exist_ok=True)\\n\\n # download files\\n for url in self.resources:\\n filename = url.rpartition('/')[2]\\n download_and_extract_archive(url, download_root=self.raw_folder, filename=filename, md5=None)\\n\\n print('Processing...')\\n\\n training_set = (\\n self.read_image_label_file(os.path.join(self.raw_folder, 'mnist_all_rotation_normalized_float_train_valid.amat'))\\n )\\n test_set = (\\n self.read_image_label_file(os.path.join(self.raw_folder, 'mnist_all_rotation_normalized_float_test.amat'))\\n )\\n\\n with open(os.path.join(self.processed_folder, self.training_file), 'wb') as f:\\n torch.save(training_set, f)\\n with open(os.path.join(self.processed_folder, self.test_file), 'wb') as f:\\n torch.save(test_set, f)\\n\\n print('Done!')\",\n \"def __download(self):\\n\\n # Use the default repository if set to True\\n if self.repository is True:\\n self.repository = self.__default_repository\\n\\n if not self.repository and not self.url:\\n tarball = 'ucx-{}.tar.gz'.format(self.__version)\\n self.url = '{0}/v{1}/{2}'.format(self.__baseurl, self.__version,\\n tarball)\",\n \"def download_dataset(dataset):\\n\\n if dataset not in URLS:\\n print(f\\\"unknown dataset {dataset}\\\")\\n sys.exit(0)\\n\\n filename = f'{dataset}.tar.gz'\\n url = URLS[dataset]\\n\\n if not os.path.exists(filename):\\n print(f'downloading dataset \\\"{dataset}\\\"')\\n os.system(f'curl \\\"{url}\\\" -o {filename}')\\n else:\\n print(f'zipfile \\\"{filename}\\\" already exists, remove it if you want to re-download.')\\n\\n if not os.path.exists(dataset):\\n print(f'extracting \\\"{filename}\\\"')\\n os.system(f'tar -xvf {filename}')\\n else:\\n print(f'folder \\\"{dataset}\\\" already exists, remove it if you want to re-create.')\\n\\n image_chips = f'{dataset}/image-chips'\\n label_chips = f'{dataset}/label-chips'\\n if not os.path.exists(image_chips) and not os.path.exists(label_chips):\\n print(\\\"creating chips\\\")\\n libs.images2chips.run(dataset)\\n else:\\n print(f'chip folders \\\"{image_chips}\\\" and \\\"{label_chips}\\\" already exist, remove them to recreate chips.')\",\n \"def maybe_download_pretrained_vgg(self):\\n DESTINATION_MODEL_TAR_PATH = self.PATH_TO_MODEL + self.MODEL_FILE\\n\\n # Check if model downloaded\\n if not os.path.exists (self.PATH_TO_MODEL + self.MODEL_NAME + '/frozen_inference_graph.pb'):\\n\\n # Download model\\n print 'Downloading pre-trained model...'\\n opener = urllib.request.URLopener()\\n opener.retrieve(self.DOWNLOAD_BASE + self.MODEL_FILE, DESTINATION_MODEL_TAR_PATH)\\n\\n # Extracting model\\n print 'Extracting model...'\\n tar_file = tarfile.open(DESTINATION_MODEL_TAR_PATH)\\n\\n for file in tar_file.getmembers():\\n file_name = os.path.basename(file.name)\\n if 'frozen_inference_graph.pb' in file_name:\\n tar_file.extract(file, self.PATH_TO_MODEL)\\n\\n self.maybe_download_model = True\",\n \"def download(self):\\n file_url = posixpath.join(self.mirrors, self.resources)\\n _urlretrieve(file_url, os.path.join(self.root, self.resources))\",\n \"def download(self):\\n file_url = posixpath.join(self.mirrors, self.resources)\\n _urlretrieve(file_url, os.path.join(self.root, self.resources))\",\n \"def unzip() -> None:\\n logger = logging.getLogger(__name__)\\n logger.info('Download the dataset')\\n\\n # define the destination\\n destination = project_dir / 'data' / 'raw'\\n\\n # extract zip\\n zip_file = ZipFile(destination / \\\"original.zip\\\")\\n zip_file.extractall(destination)\",\n \"def _download(self, url, rel_path):\\n \\n tmp_dir = \\\"TMP_DIR=`mktemp -d`;\\\"\\n wget_cmd = [ tmp_dir, \\\"wget\\\", \\\"-nv\\\", \\\"-O\\\", \\\"$TMP_DIR/archive.tgz\\\", url, \\\";\\\" ]\\n wget_cmd = ' '.join(wget_cmd)\\n \\n mkdir_cmd = \\\"mkdir -p %s ;\\\" % (\\\"./remote_resources/\\\" + rel_path)\\n \\n cleandir_cmd = \\\"rm -Rf %s/* ;\\\" % (\\\"./remote_resources/\\\" + rel_path)\\n \\n untar_cmd = [ \\\"tar\\\", \\\"xf\\\", \\\"$TMP_DIR/archive.tgz\\\", \\\"-C\\\", \\\"./remote_resources/%s\\\" % rel_path, \\\";\\\" ]\\n untar_cmd = ' '.join(untar_cmd)\\n \\n remove_cmd = \\\"rm -Rf $TMP_DIR;\\\"\\n \\n return self._ssh(' '.join([ wget_cmd, mkdir_cmd, cleandir_cmd, untar_cmd, remove_cmd ]))\",\n \"def download():\\n raise NotImplementedError\",\n \"def download_and_extract(self, data_path=None):\\n if data_path is None:\\n data_path = 'data'\\n\\n if not os.path.exists(data_path):\\n os.makedirs(data_path)\\n\\n filename = self.DATA_URL.split('/')[-1]\\n filepath = os.path.join(data_path, filename)\\n if not os.path.exists(filepath):\\n def _progress(count, block_size, total_size):\\n sys.stdout.write('\\\\r>> Downloading %s %.1f%%' % (\\n filename,\\n float(count * block_size) / float(total_size) * 100.0)\\n )\\n\\n sys.stdout.flush()\\n\\n filepath, _ = urllib.request.urlretrieve(CifarData.DATA_URL,\\n filepath,\\n _progress)\\n statinfo = os.stat(filepath)\\n self._verbose_print('Successfully downloaded', filename,\\n statinfo.st_size, 'bytes.')\\n\\n with tarfile.open(filepath, 'r:gz') as t:\\n dataset_dir = os.path.join(data_path, t.getmembers()[0].name)\\n t.extractall(data_path)\\n\\n return dataset_dir\",\n \"def _retrieve_models(local=True):\\n # Check if the download folder exists\\n def _get_meta_data(model_name, file):\\n return {\\n \\\"data\\\": {\\n \\\"id\\\": model_name,\\n \\\"name\\\": model_name,\\n \\\"description\\\": model_name,\\n \\\"filename\\\": os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"], file),\\n \\\"created\\\": time.ctime(os.path.getctime(\\n os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n file))),\\n \\\"modified\\\": time.ctime(os.path.getmtime(\\n os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n file)))\\n }\\n }\\n\\n if not os.path.exists(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n os.makedirs(app.config[\\\"DOWNLOAD_DIR\\\"])\\n\\n if not local:\\n # Fetch from a Nexus-hosted catalog\\n resources = app.forge.search({\\\"type\\\": \\\"EmbeddingModel\\\"})\\n for resource in resources:\\n app.models[resource.name] = {\\n \\\"data\\\": digest_model_data(resource),\\n }\\n app.forge.download(\\n resource, \\\"distribution.contentUrl\\\",\\n app.config[\\\"DOWNLOAD_DIR\\\"])\\n\\n pipeline_path = os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"],\\n resource.distribution.name)\\n app.models[resource.name][\\\"object\\\"] = EmbeddingPipeline.load(\\n pipeline_path,\\n embedder_interface=GraphElementEmbedder,\\n embedder_ext=\\\"zip\\\")\\n\\n # Clear the downloads dir\\n for f in os.listdir(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n try:\\n os.remove(os.path.join(app.config[\\\"DOWNLOAD_DIR\\\"], f))\\n except Exception:\\n shutil.rmtree(os.path.join(app.config[\\\"DOWNLOAD_DIR\\\"], f))\\n else:\\n # Fetch from a local dir\\n for (_, dirs, files) in os.walk(app.config[\\\"DOWNLOAD_DIR\\\"]):\\n for path in dirs + files:\\n if path[0] != \\\".\\\":\\n match = re.match(r\\\"(.*)\\\\.zip\\\", path)\\n if match:\\n model_name = match.groups()[0]\\n else:\\n model_name = path\\n app.models[model_name] = _get_meta_data(model_name, path)\\n pipeline_path = os.path.join(\\n app.config[\\\"DOWNLOAD_DIR\\\"], path)\\n app.models[model_name][\\\"object\\\"] = EmbeddingPipeline.load(\\n pipeline_path,\\n embedder_interface=GraphElementEmbedder,\\n embedder_ext=\\\"zip\\\")\\n break\",\n \"def download_data():\\r\\n print('Downloading cifar-10 data...')\\r\\n request.urlretrieve(dataurl)\\r\\n print('Done')\\r\\n print('Please unzip files. command is:')\\r\\n print('gzip -d cifar-10-python.tar.gz')\\r\\n print('tar -xf cifar-10-python.tar')\\r\\n exit()\",\n \"def _save_tar(self, path: Path, metadata: Dict, model: Model) -> NoReturn:\\n model_file_name = self.repo_config.model_file_name\\n\\n try:\\n # Create a tmp directory\\n with tempfile.TemporaryDirectory() as tmp_path:\\n os.chdir(tmp_path)\\n\\n # Save to file the dat\\n with open(model_file_name, 'wb') as f:\\n pickle.dump(model, f)\\n\\n with open(self._METADATA_FILENAME, 'w') as f:\\n json.dump(metadata, f)\\n\\n # Tar the tmp directory with all the files\\n with tarfile.open(self._TAR_FILE_NAME, \\\"w\\\") as tar:\\n for file in os.listdir(tmp_path):\\n tar.add(file)\\n\\n # Upload the tar file to S3\\n s3_file_path = str(Path(str(path) + '/' + self._TAR_FILE_NAME))\\n tmp_file_path = tmp_path + '/' + self._TAR_FILE_NAME\\n self.s3_client.upload_file(tmp_file_path, self.s3_bucket, s3_file_path)\\n finally:\\n del tmp_path\",\n \"def download(self):\\n logger.info(f\\\"downloading project {self}\\\")\\n self.project.storage.download(f\\\"{self.path}/releasemanifest\\\", None)\\n self.extract()\",\n \"def _get_download_url(model_name, version=__version__):\\n\\n version = \\\"0.0.0\\\" if \\\"vectors\\\" in model_name else version\\n\\n return (\\n f\\\"https://github.com/mauna-ai/spacy-numberbatch/releases/download/\\\"\\n f\\\"{version}/{model_name}-{version}.tar.gz\\\" )\",\n \"def fetch_and_extract(self, filename):\\n # type: (Text) -> None\\n\\n blob = self.bucket.blob(filename)\\n blob.download_to_filename(filename)\\n\\n with tarfile.open(filename, \\\"r:gz\\\") as tar:\\n tar.extractall(self.data_dir)\",\n \"def _download(self) -> None:\\n if self._check_integrity():\\n print(\\\"Files already downloaded and verified\\\")\\n return\\n\\n download_and_extract_archive(\\n self.url,\\n self.root,\\n filename=self.filename,\\n md5=self.md5 if self.checksum else None,\\n )\\n\\n # Generate train/val/test splits\\n # Always check the sha256 of this file before executing\\n # to avoid malicious code injection\\n with working_dir(self.root):\\n with open(\\\"split.py\\\") as f:\\n split = f.read().encode(\\\"utf-8\\\")\\n assert hashlib.sha256(split).hexdigest() == self.sha256\\n exec(split)\",\n \"def download_and_extract(self, package_name):\\n raise NotImplementedError('Implement this method.')\",\n \"def download_kitti(\\n root_dir : str,\\n keep_zip: bool = True\\n) -> None:\\n \\n # URL's to .zip files\\n kitti_raw_lidar_fname = 'data_depth_velodyne.zip'\\n kitti_depth_annot_fname = 'data_depth_annotated.zip'\\n kitti_test_set_fname = 'data_depth_selection.zip'\\n kitti_calib_fnames = ['2011_09_26_calib.zip',\\n '2011_09_28_calib.zip',\\n '2011_09_29_calib.zip', \\n '2011_09_30_calib.zip', \\n '2011_10_03_calib.zip']\\n \\n kitti_base_url = 'http://s3.eu-central-1.amazonaws.com/avg-kitti'\\n kitti_raw_data_base_url = '/'.join([kitti_base_url, 'raw_data'])\\n kitti_raw_lidar_url = '/'.join([kitti_base_url, kitti_raw_lidar_fname])\\n kitti_depth_annot_url = '/'.join([kitti_base_url, kitti_depth_annot_fname])\\n kitti_test_set_url = '/'.join([kitti_base_url, kitti_test_set_fname])\\n\\n # Local path\\n dest_dir = os.path.join(root_dir, 'kitti_depth_completion')\\n\\n # Check if output directory exist\\n if not(os.path.isdir(dest_dir)):\\n os.makedirs(dest_dir, exist_ok=True)\\n print('Destination diectory does not exist, created new directory at: {}'.format(dest_dir))\\n\\n # Make temporary directory\\n tmp_dir = '/'.join([dest_dir, 'tmp'])\\n if not(os.path.isdir(tmp_dir)):\\n os.makedirs(tmp_dir, exist_ok=True)\\n\\n # Directories name\\n # lidar_raw_dir = 'velodyne_raw'\\n # ground_truth_dir = 'groundtruth'\\n rgb_dir = 'image'\\n intrinsics_dir = 'intrinsics'\\n \\n # Raw lidar\\n dest_zip_file = '/'.join([tmp_dir, kitti_raw_lidar_fname])\\n\\n if not os.path.isfile(dest_zip_file):\\n # Check in case the files was donwloaded and previous run didn't complete.\\n download_file(kitti_raw_lidar_url, dest_zip_file, verbose=True)\\n else:\\n print('Destination file already exist, skip downloading')\\n\\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\\n \\n # Groundtruh (annotations)\\n dest_zip_file = '/'.join([tmp_dir, kitti_depth_annot_fname])\\n\\n if not os.path.isfile(dest_zip_file):\\n # Check in case the files was donwloaded and previous run didn't complete.\\n download_file(kitti_depth_annot_url, dest_zip_file, verbose=True)\\n else:\\n print('Destination file already exist, skip downloading')\\n\\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\\n\\n # Test/val selection data\\n dest_zip_file = '/'.join([tmp_dir, kitti_test_set_fname])\\n if not os.path.isfile(dest_zip_file):\\n # Check in case the files was donwloaded and previous run didn't complete.\\n download_file(kitti_test_set_url, dest_zip_file, verbose=True)\\n else:\\n print('Destination file already exist, skip downloading')\\n\\n unzip_file(dest_zip_file, dest_dir, keep_zip=keep_zip)\\n \\n # Move test set and validation select sets to place\\n depth_sel_path = \\\"/\\\".join([dest_dir, 'depth_selection'])\\n shutil.move(\\\"/\\\".join([depth_sel_path, \\\"val_selection_cropped\\\"]), \\\"/\\\".join([dest_dir, \\\"val_selection_cropped\\\"]))\\n shutil.move(\\\"/\\\".join([depth_sel_path, \\\"test_depth_completion_anonymous\\\"]), \\\"/\\\".join([dest_dir, \\\"test_depth_completion_anonymous\\\"]))\\n shutil.rmtree(depth_sel_path)\\n\\n # Calibration files\\n calib_dest_dir = '/'.join([dest_dir, intrinsics_dir])\\n\\n for calib_file in kitti_calib_fnames:\\n calib_file_url = '/'.join([kitti_raw_data_base_url, calib_file])\\n dest_zip_file = '/'.join([tmp_dir, calib_file])\\n if not os.path.isfile(dest_zip_file):\\n download_file(calib_file_url, dest_zip_file, verbose=True)\\n else:\\n print('Destination file already exist')\\n\\n unzip_file(dest_zip_file, calib_dest_dir, keep_zip=keep_zip)\\n \\n # RGB images for train and validation \\n # (test and val select are downloaded with RGB iamges)\\n print('Downloading RGB images\\\\n')\\n for split in ['train', 'val']:\\n # List all depth maps\\n split_root_path = '/'.join([dest_dir, split])\\n depth_map_list = os.listdir(split_root_path)\\n print(f'-Split type: {split}, Split size: {len(depth_map_list)} [depth map]\\\\n')\\n\\n # Iterate over depth maps in split\\n for depth_map_name in depth_map_list[0:1]:\\n # Initialize\\n zip_file_name = depth_map_name + '.zip'\\n orig_file_url = '/'.join([kitti_raw_data_base_url, depth_map_name[:-5], zip_file_name])\\n rgb_dest_path = '/'.join([split_root_path, depth_map_name, rgb_dir])\\n dest_zip_file = '/'.join([tmp_dir, zip_file_name])\\n tmp_depth_map_path = '/'.join([tmp_dir, depth_map_name])\\n tmp_depth_map_img_path = '/'.join([tmp_depth_map_path, rgb_dir])\\n\\n # Check if destination file or .zip file already exist\\n if os.path.isdir(rgb_dest_path):\\n print('{} : destination files already exist, skipping\\\\n'.format(depth_map_name))\\n continue\\n\\n # Check if already exist\\n if os.path.exists(dest_zip_file): \\n print('{} : file already exist, skipping\\\\n'.format(depth_map_name))\\n else:\\n # Download\\n download_file(orig_file_url, dest_zip_file, verbose=True)\\n \\n # Unzip\\n unzip_file(dest_zip_file, tmp_dir, rgb_raw_zip=True, keep_zip=keep_zip)\\n\\n # Move images to correct directory\\n shutil.move(tmp_depth_map_img_path, rgb_dest_path)\\n shutil.rmtree(tmp_depth_map_path)\\n \\n # Remove temporary directory\\n if not keep_zip:\\n shutil.rmtree(tmp_dir)\",\n \"def download(self):\\n pass\",\n \"def download(self):\\n pass\",\n \"def _get_or_download_model(self, download: bool) -> Optional[str]:\\n home_dir = home_directory()\\n downloaded_models_dir = os.path.join(home_dir, MODELS_DIR)\\n\\n if not os.path.exists(downloaded_models_dir):\\n os.makedirs(downloaded_models_dir)\\n\\n model_hashed_name = get_hashed_name(self.embedding + self.model)\\n model_path = os.path.join(downloaded_models_dir, model_hashed_name)\\n\\n if not os.path.exists(model_path):\\n if not download:\\n return\\n\\n model_download_path = model_path + '.' + self.embedding_cls.EMBEDDING_MODELS[self.model].format\\n model_download_url = self.embedding_cls.EMBEDDING_MODELS[self.model].download_url\\n print(f\\\"Model does not exists, Downloading model: {self.model}\\\")\\n download_from_url(model_download_url, model_download_path)\\n extract_file(model_download_path, model_path)\\n if os.path.exists(model_download_path):\\n os.remove(model_download_path)\\n print(f\\\"Model downloaded successfully!\\\")\\n return model_path\",\n \"def download(\\n self,\\n overwrite: bool = False,\\n refresh_token: bool = False,\\n show_progress: bool = True,\\n ):\\n _LOGGER.info(f\\\"Downloading model {self.stub}\\\")\\n\\n if self.card_file:\\n _LOGGER.info(f\\\"Downloading model card {self.stub}\\\")\\n self.card_file.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n if self.onnx_file:\\n _LOGGER.info(f\\\"Downloading model onnx {self.stub}\\\")\\n self.onnx_file.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n if self.onnx_file_gz:\\n _LOGGER.info(f\\\"Downloading model onnx gz {self.stub}\\\")\\n self.onnx_file_gz.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n self.download_framework_files(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n for data in self._data.values():\\n _LOGGER.info(f\\\"Downloading model data {data.name} {self.stub}\\\")\\n data.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\\n\\n for recipe in self._recipes:\\n _LOGGER.info(f\\\"Downloading model recipe {recipe.display_name} {self.stub}\\\")\\n recipe.download(\\n overwrite=overwrite,\\n refresh_token=refresh_token,\\n show_progress=show_progress,\\n )\",\n \"def do_download_model_job(self):\\n\\n # time the download\\n download_start = time.time()\\n\\n # sanity check on version is implicit in send\\n reply = self.channel.DownloadModel(ModelDownloadRequest(header=self.create_message_header(), model_header=self.model_header))\\n received_model_proto = reply.model\\n received_model_version = received_model_proto.header.version\\n\\n # handling possability that the recieved model is delta\\n received_model_is_delta = received_model_proto.header.is_delta\\n received_model_delta_from_version = received_model_proto.header.delta_from_version\\n\\n\\n self.logger.info(\\\"{} took {} seconds to download the model\\\".format(self, round(time.time() - download_start, 3)))\\n\\n self.validate_header(reply)\\n self.logger.info(\\\"{} - Completed the model downloading job.\\\".format(self))\\n\\n check_type(reply, GlobalModelUpdate, self.logger)\\n\\n # ensure we actually got a new model version\\n check_not_equal(received_model_version, self.model_header.version, self.logger)\\n\\n # set our model header\\n self.model_header = received_model_proto.header\\n\\n # compute the aggregated tensors dict from the model proto\\n agg_tensor_dict = deconstruct_proto(model_proto=received_model_proto, compression_pipeline=self.compression_pipeline)\\n\\n # TODO: If updating of base is not done every round, we will no longer be able to use the base to get\\n # the current global values of the shared tensors.\\n if self.send_model_deltas:\\n self.update_base_for_deltas(tensor_dict=agg_tensor_dict,\\n delta_from_version=received_model_delta_from_version,\\n version=received_model_version,\\n is_delta=received_model_is_delta)\\n # base_for_deltas can provide the global shared tensor values here\\n agg_tensor_dict = self.base_for_deltas[\\\"tensor_dict\\\"]\\n\\n # restore any tensors held out from aggregation\\n tensor_dict = {**agg_tensor_dict, **self.holdout_tensors}\\n\\n if self.opt_treatment == OptTreatment.CONTINUE_GLOBAL:\\n with_opt_vars = True\\n else:\\n with_opt_vars = False\\n\\n # Ensuring proper initialization regardless of model state. Initial global models\\n # do not contain optimizer state, and so cannot be used to reset the optimizer params.\\n if reply.model.header.version == 0:\\n with_opt_vars = False\\n self.wrapped_model.reset_opt_vars()\\n\\n self.wrapped_model.set_tensor_dict(tensor_dict, with_opt_vars=with_opt_vars)\\n self.logger.debug(\\\"Loaded the model.\\\")\\n\\n # if we are supposed to save the best model and the model is the best, we save it\\n if reply.is_global_best and self.save_best_native_path:\\n self.wrapped_model.save_native(self.save_best_native_path, self.save_best_native_kwargs)\\n self.logger.info(\\\"Saving best model to {}\\\".format(self.save_best_native_path))\\n\\n # if we should save metadata and have meta in protobuf\\n if self.save_metadata_path is not None and reply.metadata_yaml is not None:\\n with open(self.save_metadata_path, 'w') as f:\\n f.write(reply.metadata_yaml)\\n self.logger.info(\\\"Wrote metadata to {}\\\".format(self.save_metadata_path))\\n\\n # FIXME: for the CONTINUE_LOCAL treatment, we need to store the status in case of a crash.\\n if self.opt_treatment == OptTreatment.RESET:\\n try:\\n self.wrapped_model.reset_opt_vars()\\n except:\\n self.logger.exception(\\\"Failed to reset the optimization variables.\\\")\\n raise\\n else:\\n self.logger.debug(\\\"Reset the optimization variables.\\\")\",\n \"def fetch_the_data():\\n subprocess.run([\\\"wget\\\", \\\"https://storage.googleapis.com/recipe-box/recipes_raw.zip\\\"])\\n subprocess.run([\\\"unzip\\\", \\\"recipes_raw.zip\\\", \\\"-d\\\", RECIPES_DIRPATH])\\n subprocess.run([\\\"rm\\\", \\\"recipes_raw.zip\\\"])\",\n \"def download_tar_file(tar_remote, save_dir, force_overwrite, cleanup=False):\\n tar_download_path = download_from_remote(tar_remote, save_dir, force_overwrite)\\n untar(tar_download_path, cleanup=cleanup)\",\n \"def download(self):\\n cloud_path = f\\\"gs://{const.GCS_BUCKET}/{self.GCS_PATH}\\\"\\n # download label file\\n label_zip = download_file_from_gcs(\\n cloud_path, self.root, self.LABEL_ZIP\\n )\\n with zipfile.ZipFile(label_zip, \\\"r\\\") as zip_dir:\\n zip_dir.extractall(self.root)\\n\\n # download tfexamples for a dataset split\\n tfexamples_zip = download_file_from_gcs(\\n cloud_path, self.root, self.SPLITS_ZIP.get(self.split)\\n )\\n with zipfile.ZipFile(tfexamples_zip, \\\"r\\\") as zip_dir:\\n zip_dir.extractall(self.root)\",\n \"def download_and_unzip_dataset(url, path):\\n dl = urllib.urlretrieve(url)\\n zf = zipfile.ZipFile(dl[0])\\n zf.extractall(path)\\n return zf\",\n \"def download_and_prepare(self):\\n self._download_and_prepare()\",\n \"def download(self, session: Session = None):\\n\\n def dont_skip_download():\\n return not self.skip_download\\n\\n def archive_path_does_not_exist():\\n return not os.path.exists(self.archive_path)\\n\\n # Check to see if the dataset already exists.\\n if self._does_not_exist_or_forced():\\n if dont_skip_download() or archive_path_does_not_exist():\\n self._download()\\n else:\\n logger.info(f\\\"Download skipped.\\\")\\n\\n with unknown_progress(f\\\"Extracting\\\"):\\n self._extract()\\n\\n # Clean-up archive file if -c/--clean is used.\\n if self.clean:\\n logger.info(f\\\"Removing archive file.\\\")\\n os.remove(self.archive_path)\\n\\n with unknown_progress(f\\\"Parsing metadata\\\"):\\n self._save_metadata()\\n\\n with unknown_progress(f\\\"Moving images\\\"):\\n self._move_images()\\n\\n with unknown_progress(f\\\"Cleaning up\\\"):\\n self._clean_up()\",\n \"def _search_model_extractor(self, repo_url):\\n # Find model folder\\n # The model name is the name of the author of the repository\\n model_name = 'snippet_model_%s' % repo_url.split('/')[-2]\\n # It is stored in the models_data folder\\n models_data = Path(pkg_resources.resource_filename('credentialdigger',\\n 'models_data'))\\n dev_model = models_data / model_name\\n\\n # Find extractor binary\\n # Get name and version from the metafile\\n with open(dev_model / 'meta.json', 'r') as f:\\n meta = json.loads(f.read())\\n inner_folder = dev_model / ('%s-%s' % (meta['name'], meta['version']))\\n # There should be only one binary in the inner folder\\n extractor_file = list(inner_folder.glob('**/*.bin'))[0]\\n\\n return dev_model.name, extractor_file.name\",\n \"def prepare_sagemaker_model(self):\\n try:\\n sagemaker_session = sagemaker.Session()\\n bucket = sagemaker_session.default_bucket() # you can specify other bucket name here\\n prefix = f'mlflow_model/{self.model_name}-{self.model_version}'\\n tmp_file = '/tmp/model.tar.gz'\\n\\n model_local_path = self._download_model_version_files()\\n self._make_tar_gz_file(tmp_file, model_local_path)\\n tar_gz_s3_location = sagemaker_session.upload_data(path=tmp_file, bucket=bucket, key_prefix=prefix)\\n logging.info(f'model.tar.gz upload to {tar_gz_s3_location}')\\n\\n return tar_gz_s3_location\\n\\n except Exception as e:\\n logging.error(e)\",\n \"def download_pretrained_models(\\n models_root_dir='/tmp/sketch_rnn/models',\\n pretrained_models_url=PRETRAINED_MODELS_URL):\\n tf.gfile.MakeDirs(models_root_dir)\\n zip_path = os.path.join(\\n models_root_dir, os.path.basename(pretrained_models_url))\\n if os.path.isfile(zip_path):\\n tf.logging.info('%s already exists, using cached copy', zip_path)\\n else:\\n tf.logging.info('Downloading pretrained models from %s...',\\n pretrained_models_url)\\n urlretrieve(pretrained_models_url, zip_path)\\n tf.logging.info('Download complete.')\\n tf.logging.info('Unzipping %s...', zip_path)\\n with zipfile.ZipFile(zip_path) as models_zip:\\n models_zip.extractall(models_root_dir)\\n tf.logging.info('Unzipping complete.')\",\n \"def download_and_install(self, version=\\\"latest\\\", os_name=None, bitness=None, show_progress_bar=True):\\n filename_with_path = self.download(version,\\n os_name=os_name,\\n bitness=bitness,\\n show_progress_bar=show_progress_bar)\\n filename = os.path.split(filename_with_path)[1]\\n if filename.lower().endswith(\\\".tar.gz\\\"):\\n extract_dir = os.path.join(self.get_download_path(version), filename[:-7])\\n elif filename.lower().endswith(\\\".zip\\\"):\\n extract_dir = os.path.join(self.get_download_path(version), filename[:-4])\\n else:\\n error_message = \\\"Unknown archive format: {0}\\\".format(filename)\\n logger.error(error_message)\\n raise RuntimeError(error_message)\\n if not os.path.isdir(extract_dir):\\n os.makedirs(extract_dir)\\n logger.debug(\\\"Created directory: {0}\\\".format(extract_dir))\\n if filename.lower().endswith(\\\".tar.gz\\\"):\\n with tarfile.open(os.path.join(self.get_download_path(version), filename), mode=\\\"r:*\\\") as tar:\\n tar.extractall(extract_dir)\\n logger.debug(\\\"Extracted files: {0}\\\".format(\\\", \\\".join(tar.getnames())))\\n elif filename.lower().endswith(\\\".zip\\\"):\\n with zipfile.ZipFile(os.path.join(self.get_download_path(version), filename), mode=\\\"r\\\") as driver_zipfile:\\n driver_zipfile.extractall(extract_dir)\\n driver_filename = self.get_driver_filename(os_name=os_name)\\n for root, dirs, files in os.walk(extract_dir):\\n for curr_file in files:\\n if curr_file == driver_filename:\\n actual_driver_filename = os.path.join(root, curr_file)\\n break\\n if os_name is None:\\n os_name = platform.system()\\n if os_name in ['Darwin', 'Linux']:\\n symlink_src = actual_driver_filename\\n symlink_target = os.path.join(self.link_path, driver_filename)\\n if os.path.islink(symlink_target):\\n if os.path.samefile(symlink_src, symlink_target):\\n logger.info(\\\"Symlink already exists: {0} -> {1}\\\".format(symlink_target, symlink_src))\\n return tuple([symlink_src, symlink_target])\\n else:\\n logger.warning(\\\"Symlink {0} already exists and will be overwritten.\\\".format(symlink_target))\\n os.unlink(symlink_target)\\n os.symlink(symlink_src, symlink_target)\\n logger.info(\\\"Created symlink: {0} -> {1}\\\".format(symlink_target, symlink_src))\\n st = os.stat(symlink_src)\\n os.chmod(symlink_src, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)\\n return tuple([symlink_src, symlink_target])\\n elif os_name == \\\"Windows\\\":\\n src_file = actual_driver_filename\\n dest_file = os.path.join(self.link_path, driver_filename)\\n if os.path.isfile(dest_file):\\n logger.info(\\\"File {0} already exists and will be overwritten.\\\".format(dest_file))\\n shutil.copy2(src_file, dest_file)\\n return tuple([src_file, dest_file])\",\n \"def _download_chieffi04():\\n url = 'http://cdsarc.u-strasbg.fr/viz-bin/nph-Cat/tar.gz?J%2FApJ%2F608%2F405'\\n import urllib\\n print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')\\n if os.path.exists(MASTERFILE):\\n os.remove(MASTERFILE)\\n urllib.urlretrieve(url,MASTERFILE)\\n\\n import tarfile\\n tar = tarfile.open(MASTERFILE)\\n tar.extractall(path=DATADIR)\\n tar.close()\",\n \"def _download_chieffi04():\\n url = 'http://cdsarc.u-strasbg.fr/viz-bin/nph-Cat/tar.gz?J%2FApJ%2F608%2F405'\\n import urllib\\n print('Downloading Chieffi 04 yield tables from Vizier (should happen only at the first time)...')\\n if os.path.exists(MASTERFILE):\\n os.remove(MASTERFILE)\\n urllib.urlretrieve(url,MASTERFILE)\\n\\n import tarfile\\n tar = tarfile.open(MASTERFILE)\\n tar.extractall(path=DATADIR)\\n tar.close()\",\n \"def download_model(\\n model: str,\\n force: bool = False,\\n) -> str:\\n if model in {\\\"small\\\", \\\"medium\\\", \\\"large\\\"}:\\n latest_version = get_latest_version(model)\\n model = f\\\"da_dacy_{model}_trf-{latest_version}\\\"\\n mdl_version = model.split(\\\"-\\\")[-1]\\n\\n if model not in models_url:\\n raise ValueError(\\n f\\\"The model '{model}' is not available in DaCy. Please use dacy.models() to see a\\\"\\n + \\\" list of all models\\\",\\n )\\n\\n mdl = model.split(\\\"-\\\")[0]\\n if mdl in get_installed_models() and not force and version(mdl) == mdl_version:\\n return mdl\\n install(models_url[model])\\n return mdl\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.783391","0.77010363","0.7660963","0.7633819","0.7511147","0.7439116","0.7427492","0.73181266","0.71618634","0.70268524","0.700018","0.6992704","0.6983917","0.6976861","0.68549454","0.6840488","0.68346643","0.6769262","0.67121315","0.67109853","0.66834044","0.6682882","0.6671073","0.66690767","0.66466475","0.6626019","0.6595852","0.65887606","0.6571819","0.6504043","0.6497305","0.6468926","0.63317126","0.6331145","0.6324461","0.6319318","0.629759","0.6238619","0.6196145","0.618423","0.6168536","0.61679804","0.61600256","0.612695","0.6113542","0.61093074","0.60634434","0.6049753","0.6045032","0.6044892","0.6023749","0.6020354","0.6018673","0.6013674","0.5987382","0.5962838","0.5958262","0.59413934","0.5913395","0.5910717","0.5898041","0.5892571","0.58837825","0.58818364","0.588154","0.58799404","0.58735514","0.5869316","0.5869316","0.5865686","0.5862906","0.58544075","0.58481467","0.58453554","0.5825917","0.58240855","0.5818053","0.5816417","0.58111066","0.58062","0.5787313","0.5786314","0.5768111","0.5768111","0.5766512","0.57616997","0.57466143","0.574111","0.5738437","0.573755","0.5734177","0.57188493","0.57112324","0.5709073","0.5697128","0.56868255","0.56788737","0.56706774","0.56706774","0.56683177"],"string":"[\n \"0.783391\",\n \"0.77010363\",\n \"0.7660963\",\n \"0.7633819\",\n \"0.7511147\",\n \"0.7439116\",\n \"0.7427492\",\n \"0.73181266\",\n \"0.71618634\",\n \"0.70268524\",\n \"0.700018\",\n \"0.6992704\",\n \"0.6983917\",\n \"0.6976861\",\n \"0.68549454\",\n \"0.6840488\",\n \"0.68346643\",\n \"0.6769262\",\n \"0.67121315\",\n \"0.67109853\",\n \"0.66834044\",\n \"0.6682882\",\n \"0.6671073\",\n \"0.66690767\",\n \"0.66466475\",\n \"0.6626019\",\n \"0.6595852\",\n \"0.65887606\",\n \"0.6571819\",\n \"0.6504043\",\n \"0.6497305\",\n \"0.6468926\",\n \"0.63317126\",\n \"0.6331145\",\n \"0.6324461\",\n \"0.6319318\",\n \"0.629759\",\n \"0.6238619\",\n \"0.6196145\",\n \"0.618423\",\n \"0.6168536\",\n \"0.61679804\",\n \"0.61600256\",\n \"0.612695\",\n \"0.6113542\",\n \"0.61093074\",\n \"0.60634434\",\n \"0.6049753\",\n \"0.6045032\",\n \"0.6044892\",\n \"0.6023749\",\n \"0.6020354\",\n \"0.6018673\",\n \"0.6013674\",\n \"0.5987382\",\n \"0.5962838\",\n \"0.5958262\",\n \"0.59413934\",\n \"0.5913395\",\n \"0.5910717\",\n \"0.5898041\",\n \"0.5892571\",\n \"0.58837825\",\n \"0.58818364\",\n \"0.588154\",\n \"0.58799404\",\n \"0.58735514\",\n \"0.5869316\",\n \"0.5869316\",\n \"0.5865686\",\n \"0.5862906\",\n \"0.58544075\",\n \"0.58481467\",\n \"0.58453554\",\n \"0.5825917\",\n \"0.58240855\",\n \"0.5818053\",\n \"0.5816417\",\n \"0.58111066\",\n \"0.58062\",\n \"0.5787313\",\n \"0.5786314\",\n \"0.5768111\",\n \"0.5768111\",\n \"0.5766512\",\n \"0.57616997\",\n \"0.57466143\",\n \"0.574111\",\n \"0.5738437\",\n \"0.573755\",\n \"0.5734177\",\n \"0.57188493\",\n \"0.57112324\",\n \"0.5709073\",\n \"0.5697128\",\n \"0.56868255\",\n \"0.56788737\",\n \"0.56706774\",\n \"0.56706774\",\n \"0.56683177\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7627266"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":93694,"cells":{"query":{"kind":"string","value":"Builds a random function of depth at least min_depth and depth at most max_depth (see assignment writeup for definition of depth in this context)"},"document":{"kind":"string","value":"def build_random_function(min_depth, max_depth):\n listoffunctions = [ [\"x\"] , [\"y\"] , [\"\"] ]\n\n var = random.randrange(0,7) #this is not inclusive at the upper end\n halfvar = random.randrange(0,2)\n otherhalfvar = random.randrange(0,2)\n if max_depth == 0: # if you get the the max depth it ends\n if halfvar == 0:\n return [\"x\"]\n else:\n return [\"y\"]\n if min_depth == 0: # if you get to the the minimum recursion length\n if max_depth != 0: # There is a 1/2 possibility it will end there\n if halfvar == 0: \n if otherhalfvar == 0: \n return [\"x\"] \n else: \n return [\"y\"]\n\n # some of the below return two so that they cna evaluate more than onne value\n\n if var == 0:\n return [\"sin_pi\", build_random_function(min_depth-1, max_depth-1)]\n if var == 1:\n return [\"cos_pi\", build_random_function(min_depth-1, max_depth-1)]\n if var == 2:\n return [\"prod\", build_random_function(min_depth-1, max_depth-1) , build_random_function(min_depth-1, max_depth-1)]\n if var == 3:\n return [\"avg\", build_random_function(min_depth-1, max_depth-1) , build_random_function(min_depth-1, max_depth-1)]\n if var == 4:\n return [\"squ\", build_random_function(min_depth-1, max_depth-1)]\n if var == 5:\n return [\"cir\", build_random_function(min_depth-1, max_depth-1) , build_random_function(min_depth-1, max_depth-1) ]\n if var == 6:\n return [\"sms\", build_random_function(min_depth-1, max_depth-1) , build_random_function(min_depth-1, max_depth-1) ]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def build_random_function(min_depth, max_depth):\n depth = random.randint(min_depth, max_depth)\n return build_random_function_helper(depth)","def build_random_function(min_depth, max_depth):\n\n # your code goes here","def build_rand_func(min_depth, max_depth):\n\n\toptions = [['prod'],['sin_pi'],['cos_pi'],['A'],['B']]\n\n\t# base case\n\tif max_depth == 1:\n\t\treturn ['A']\n\n\t# if min_depth reached, also choose base case\n\telif min_depth <= 1:\n\n\t\tfunc_choice = options[randint(0,4)] # choose random func\n\n\t\t# allows products to take two imputs\n\t\tif func_choice == ['prod']:\n\t\t\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1), build_rand_func(min_depth, max_depth)]\n\n\t\t# if base case reached, end recursion\n\t\telif func_choice == ['A'] or func_choice == ['B']:\n\t\t\treturn func_choice\n\n\t\t# otherwise, recurse as usual (single input)\n\t\telse:\n\t\t\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1)]\n\n\t# if min_depth or max_depth not reached, loop again with min/max counters decremented\n\telse:\n\t\tfunc_choice = options[randint(0, 2)]\n\n\t\t# allows products to take two inputs\n\t\tif func_choice != ['prod']:\n\t\t\treturn func_choice + [(build_rand_func(min_depth-1, max_depth-1))]\n\n\t\t# otherwise, recurse as usual\n\t\telse:\n\t\t\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1), build_rand_func(min_depth-1, max_depth-1)]\n\n\t# print rand_func\n\t# return rand_func","def build_random_function(min_depth, max_depth):\n if max_depth == 1:\n rand = random.random()\n if rand < 1.0/(2+timeflag):\n return [\"x\"]\n elif rand < 2.0/(2+timeflag):\n return [\"y\"]\n else:\n return [\"t\"]\n elif min_depth <= 1:\n if random.random() > (max_depth - 1.0)/max_depth:\n rand = random.random()\n if rand < 1.0/(2+timeflag):\n return [\"x\"]\n elif rand < 2.0/(2+timeflag):\n return [\"y\"]\n else:\n return [\"t\"]\n\n rand = random.random()\n if rand < 1.0/NUM_FF:\n return [\"prod\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\n elif rand < 2.0/NUM_FF:\n return [\"avg\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\n elif rand < 3.0/NUM_FF:\n return [\"cos_pi\",build_random_function(min_depth-1,max_depth-1)]\n elif rand < 4.0/NUM_FF:\n return [\"sin_pi\",build_random_function(min_depth-1,max_depth-1)]\n elif rand < 5.0/NUM_FF:\n return [\"hypot\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\n #elif rand < 6.0/NUM_FF:\n # return [\"pow\",build_random_function(min_depth-1,max_depth-1)]\n #elif rand < 6.0/NUM_FF:\n # return [\"add\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\n elif rand < 6.0/NUM_FF:\n return [\"cube\",build_random_function(min_depth-1,max_depth-1)]","def build_random_function(min_depth, max_depth):\n first_order = ['x', 'y']\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\n\n # Base Case. can say == instead of <= because min depth is only ever\n # decreased by 1\n if min_depth == 0:\n ls = []\n ls.append(first_order[random.randint(0, 1)])\n return ls\n else:\n rand = random.randint(0, len(elementary_func)-1)\n begin = elementary_func[rand]\n arguments = [begin]\n arguments.append(build_random_function(min_depth-1, max_depth-1))\n\n # Establishes a second argument for the functions which need two\n if rand < 2:\n arguments.append(build_random_function(min_depth-1, max_depth-1))\n return arguments","def build_random_function(min_depth, max_depth):\n # print 'buildrandomfunc'\n depth = random.randint(min_depth, max_depth)\n if depth==1: #if this is the bottom call, return x or y\n return [blocks[random.randint(0,3)]]\n myFunc=blocks[random.randint(0,7)]\n params=args[myFunc]\n finalList=[]\n finalList+=[myFunc]\n for i in range(0,params):\n finalList+=[build_random_function(depth-1,depth-1)]\n return finalList","def build_random_function_3(min_depth, max_depth):\n first_order = ['x', 'y', 't']\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\n if min_depth == 0:\n ls = []\n ls.append(first_order[random.randint(0, 2)])\n return ls\n else:\n rand = random.randint(0, len(elementary_func)-1)\n begin = elementary_func[rand]\n arguments = [begin]\n arguments.append(build_random_function_3(min_depth-1, max_depth-1))\n if rand < 2:\n arguments.append(build_random_function_3(min_depth-1, max_depth-1))\n to_return = [begin]\n to_return.append(arguments)\n return arguments","def build_random_function_helper(depth):\n random_index = random.randint(0, len(funcs)-1)\n if depth == 0:\n return [funcs[random_index][0]], funcs[random_index][1]\n elif depth > 0:\n name1, lam1 = build_random_function_helper(depth-1)\n name2, lam2 = build_random_function_helper(depth-1)\n\n name_func = [funcs[random_index][0], name1, name2]\n lam_func = lambda x, y: funcs[random_index][1](lam1(x,y), lam2(x,y))\n return name_func, lam_func","def r_lambda_func(depth):\n first_order = [lambda x, y: x, lambda x, y: y]\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi']\n if depth == 0:\n rand = random.randint(0, 1)\n if rand == 0:\n return lambda x, y: x\n else:\n return lambda x, y: y\n else:\n rand = random.randint(0, len(elementary_func))\n rand = 1\n if rand == 0:\n return lambda x, y: (r_lambda_func(depth-1)(x, y)) * (r_lambda_func(depth-1)(x, y))\n elif rand == 1:\n return lambda x, y: .5 * ((r_lambda_func(depth-1)(x, y) + r_lambda_func(depth-1)(x, y)))(x, y)\n elif rand == 2:\n return lambda x, y: math.cos(lambda x, y: math.pi(x, y) * r_lambda_func(depth-1)(x, y))(x, y)\n elif rand == 3:\n return lambda x, y: math.sin(lambda x, y: math.pi(x, y) * r_lambda_func(depth-1)(x, y))(x, y)","def depth(x):\n return max(int(x * depth_multiplier), 8)","def test_rand_100_depth_remains_less_than_8():\n from bbst import Bst\n from random import shuffle\n max_depth = 0\n for x in range(10):\n rando = [x for x in range(100)]\n shuffle(rando)\n tree = Bst(rando)\n tree_depth = tree.depth()\n if tree_depth > max_depth:\n max_depth = tree_depth\n assert max_depth == 8","def random_tree(self, grow, max_depth, depth=0):\n # Full method\n if depth < MIN_DEPTH or (depth < MAX_DEPTH and not grow):\n self.body = random.choice(operators)\n elif depth >= MAX_DEPTH:\n self.body = random.choice(terminals)\n else: # intermediate depth, grow\n if random.random() > 0.9:\n self.body = random.choice(operators)\n else:\n self.body = random.choice(terminals)\n if self.body in operators:\n self.left = Tree()\n self.left.random_tree(grow, max_depth, depth=depth + 1)\n self.right = Tree()\n self.right.random_tree(grow, max_depth, depth=depth + 1)","def pow(a, n, depth=1):\n if n == 1:\n print(\"depth=\", depth)\n return a\n if n % 2 == 1:\n return pow(a, n-1, depth + 1) * a\n else: # n % 2 = 0\n return pow(a * a, n // 2, depth + 1)","def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\n\n def get_states(start):\n frontier = [start]\n frontier_set = {start}\n explored = set()\n\n states = [False for _ in range(len(depths))]\n while not all(states):\n node = frontier.pop(0)\n frontier_set.remove(node)\n explored.add(node)\n\n children = node.get_children()\n\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\n # produced from the parent by the same action) produced at a certain depth will always be selected,\n # and children produced by other actions will never be selected\n shuffle(children)\n\n for child in children:\n if child not in frontier_set and child not in explored:\n frontier_set.add(child)\n frontier.append(child)\n child.path_cost = node.path_cost+1\n index = depths.index(child.path_cost) if child.path_cost in depths else None\n if index is not None and not states[index]:\n states[index] = {'start': start.sequence, 'end': child.sequence}\n\n return states\n\n depth_sample = [[] for depth in range(len(depths))]\n\n for _ in range(num_samples):\n start = list(range(1,n+2))\n shuffle(start)\n start = PuzzleState(start, path_cost=0)\n\n states = get_states(start)\n print('\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\n list(map(list.append, depth_sample, states))\n\n return depth_sample","def build_random_trees(rows, n_features, max_depth, min_size, n_trees, random_dataset_size):\n trees = []\n for tree_number in range(n_trees):\n print(\"Building tree number:\", tree_number, \"of\", n_trees)\n # Select random dataset from original dataset\n random_dataset = select_random_rows(rows, random_dataset_size)\n\n # Select random features (columns)\n random_features = []\n for random_feature in range (n_features):\n # generate random index number to pick column\n random_column = randrange(len(rows))\n random_features.append(random_column)\n # generate the random tree with randomly picked features (columns) and a random dataset\n random_tree = build_single_random_tree(random_dataset, random_features, max_depth, min_size, 1)\n # add to list of trees\n trees.append(random_tree)\n return trees","def depth_from_match(function):\n def wrap(start, values):\n #print 'Depth %d | %d %s' %(self._depth, start, values)\n #print self._current_node\n self._depth = start\n self._current_node = function(values)\n #print self._current_node\n return ''\n\n return wrap","def bld_func(min_d, max_d):\n\n opers = ['prod','avg','cos_pi','sin_pi','subtract','add']\n oper = random.choice(opers)\n\n depth = random.randint(min_d,max_d)\n\n if depth <= 1:\n return [random.choice(['x','y','t'])]\n elif oper == 'prod':\n return ['prod', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\n elif oper == 'avg':\n return ['avg', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\n elif oper == 'cos_pi':\n return ['cos_pi', bld_func(min_d-1,max_d-1)]\n elif oper == 'sin_pi':\n return ['sin_pi', bld_func(min_d-1,max_d-1)]\n elif oper == 'subtract':\n return ['subtract', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\n elif oper == 'add':\n return ['add', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]","def test_random_forest_max_depth_parameter(params, X_train, X_test, y_train, y_test):","def max_depth(self) -> int:\n return 0","def fn(x):\n nonlocal ans \n if x < ans: \n if min(depth) == n: ans = x # all tiled\n else: \n i = min(depth)\n j = jj = depth.index(i) # (i, j)\n while jj < m and depth[jj] == depth[j]: jj += 1\n k = min(n - i, jj - j)\n for kk in reversed(range(1, k+1)): \n for jj in range(j, j+kk): depth[jj] += kk\n fn(x+1)\n for jj in range(j, j+kk): depth[jj] -= kk","def randomTree(maxLevels, minLeafLevels, maxChildren, weightRange, level=0, usedLabels = set()):\n numChildren = randint(1,maxChildren) if level < minLeafLevels else (randint(0,maxChildren) if level < maxLevels else 0)\n\n if numChildren > 0:\n childNodes = [randomTree(maxLevels, minLeafLevels, maxChildren, weightRange, level+1, usedLabels) for i in range(numChildren)]\n weights = [int(uniform(*weightRange)) if random() < 0.25 else round(uniform(*weightRange), randint(0,4)) for i in range(numChildren)]\n return PhyloTree_sol.PhyloTree(children = list(zip(childNodes, weights)))\n \n while True:\n label = \"\".join([choice(labels) for i in range(3)])\n if not label in usedLabels:\n break\n \n usedLabels.add(label)\n\n return PhyloTree_sol.PhyloTree(label=label)","def build_tree(n, d, name=defaultname):\n return build_tree_helper(1, n, 1, d, name)","def test_function(n, m,level=10):\n # call another function so the stack is bigger\n if level > 0:\n return test_function(n,m,level=level-1)\n else:\n return test_function2(m, n)","def get_max_dmag_from_depth(depth):\n return 2.5 * np.log10(depth)","def score_max_depths(graph, max_depths):\n ###TODO\n pass","def iterative_gaussian_tree(\n basedir: Union[str, PurePath],\n nfiles: int = 2,\n nfolders: int = 1,\n repeat: int = 1,\n maxdepth: Optional[int] = None,\n sigma_folders: int = 1,\n sigma_files: int = 1,\n min_folders: int = 0,\n min_files: int = 0,\n filename: Callable = random_string,\n payload: Optional[Callable[[Path], Generator[Path, None, None]]] = None,\n) -> Tuple[List[Path], List[Path]]:\n\n # noinspection PyUnusedLocal\n @no_type_check\n def nfolders_func(*args):\n return max(min_folders, int(random.gauss(nfolders, sigma_folders)))\n\n # noinspection PyUnusedLocal\n @no_type_check\n def nfiles_func(*args):\n return max(min_files, int(random.gauss(nfiles, sigma_files)))\n\n return iterative_tree(\n basedir=basedir,\n nfiles_func=nfiles_func,\n nfolders_func=nfolders_func,\n repeat=repeat,\n maxdepth=maxdepth,\n filename=filename,\n payload=payload,\n )","def max_recursion_depth(self, max_recursion_depth: ConfigNodePropertyInteger):\n\n self._max_recursion_depth = max_recursion_depth","def get_recursion_depth(self):\n str_depth_input = self.entries[\"ent_recursion_depth\"].get()\n if str_depth_input == '':\n return None # default of fractal class while drawing in None\n # draws the base curve instead\n return int(str_depth_input)","def depth_estimation(x_left, x_right, f=33.4, d=114):\n depth = abs(f * d / ((x_left - x_right) / 72 * 2.54)) / 100 # - 0.418879\n return depth","def __build_tree__(self, features, classes, depth=0):\n\n # TODO: finish this.\n root = None\n if (len(set(classes)) <= 1) and (len(classes) != 0) :\n return DecisionNode(None,None,None,classes[0])\n elif (len(classes) == 0):\n return DecisionNode(None,None,None,2)\n elif depth == self.depth_limit:\n return DecisionNode(None,None,None,max(set(classes), key=list(classes).count))\n else:\n# if depth == 0:\n features = np.array(features)\n classes = np.array(classes).reshape(-1,1)\n feat_shape = features.shape\n sample_list = range(feat_shape[0])\n gains = np.zeros((feat_shape[1]))\n indices = np.zeros((feat_shape[1]))\n for i in range(feat_shape[1]):\n attribute = features[:,i]\n for j in range(20):\n split_indx = int(np.random.choice(sample_list, replace=False))\n idx_above = np.where(attribute > attribute[split_indx])[0]\n idx_below = np.where(attribute < attribute[split_indx])[0]\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\n gain = gini_gain(list(classes.reshape(1,-1)[0]),[list(classes_below),list(classes_above)])\n if gain > gains[i]:\n gains[i] = gain\n indices[i] = split_indx\n indx = np.argmax(gains)\n split_indx = int(indices[indx])\n attribute = features[:,indx]\n idx_above = np.where(attribute > attribute[split_indx])[0]\n idx_below = np.where(attribute < attribute[split_indx])[0] \n features_below = features[idx_below,:]\n features_above = features[idx_above,:]\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\n if (len(classes_below) != 0) and (len(classes_above) != 0):\n root = DecisionNode(None,None,lambda feat:feat[indx] > features[split_indx,indx])\n root.left = self.__build_tree__(features_above, classes_above, depth+1)\n root.right = self.__build_tree__(features_below, classes_below, depth+1)\n return root\n elif (len(classes_below) == 0) and (len(classes_above) != 0):\n return DecisionNode(None,None,None,max(set(classes_above), key=list(classes_above).count))\n elif (len(classes_above) == 0) and (len(classes_below) !=0):\n return DecisionNode(None,None,None,max(set(classes_below), key=list(classes_below).count))\n else:\n return DecisionNode(None,None,None,2)","def nodes_at_depth(depth):\n return list(range(2**depth-1, 2**(depth+1)-1))","def max_recursion_depth(self) -> ConfigNodePropertyInteger:\n return self._max_recursion_depth","def bestAtDepthR(self,depth=0,scoreFunc=None) :\n scoreFunc = scoreFunc if scoreFunc != None else lambda g : g.leafScore()\n min_score = ACG.inf\n min_R = None\n for g in self.R() :\n if depth > 0 :\n g = g.bestAtDepthL(depth=depth-1,scoreFunc=scoreFunc)\n score = scoreFunc(g)\n if score < min_score :\n min_score = score\n min_R = g\n return min_R if min_R != None else self","def get_desired_depth(file_name, tree, desired_depth):\n node_keys = []\n get_nodes_at_depth(tree.root, desired_depth, node_keys)\n generate_file(file_name, node_keys)\n print(\"File '\" + file_name + \"' generated with keys at depth: :\", desired_depth)","def depth_from_nemo_tag(function):\n def wrap(start, values):\n # print 'Depth %d | %d %s' %(self._depth, start, values)\n self._depth = start\n tokens = values[1]\n self._current_node = function(tokens)\n #print self._current_node\n return ''\n\n return wrap","def alphabeta(node, depth, alpha, beta, maximizingPlayer, board):\n if depth == 0:\n return node\n\n if maximizingPlayer: # This is us\n best_node = float(\"-inf\"), []\n\n # Get child nodes and put them in the proper form\n possible_moves = get_possible_moves_white(node, board)\n child_nodes = []\n for set_moves in possible_moves:\n child_nodes.append([get_total_score(set_moves, board), set_moves])\n\n if len(child_nodes) == 0:\n return [float(\"-inf\"), node[1]] # We get put check mate (crash if node[1] == [])\n\n best_nodes_list = []\n i = randrange(len(child_nodes))\n for child in child_nodes[i:] + child_nodes[:i]:\n rec_child = alphabeta(child, depth - 1, alpha, beta, False, board)\n if best_node[0] < rec_child[0]:\n best_nodes_list = [rec_child]\n best_node = rec_child\n alpha = max(alpha, best_node[0])\n if alpha >= beta:\n if alpha == float(\"inf\"):\n return best_node\n return [float(\"inf\"), []] # Pruning\n elif best_node[0] == rec_child[0]:\n best_nodes_list.append(rec_child)\n return random.choice(best_nodes_list)\n else: # minimizingPlayer\n worst_node = float(\"inf\"), []\n\n # Get child nodes and put them in the proper form\n possible_moves = get_possible_moves_black(node, board)\n child_nodes = []\n for set_moves in possible_moves:\n child_nodes.append([get_total_score(set_moves, board), set_moves])\n\n if len(child_nodes) == 0:\n if is_checkmate(node[1], board):\n return [float(\"inf\"), node[1]] # Check-mate\n else:\n return [float(\"-inf\"), node[1]] # Draw\n\n worst_nodes_list = []\n for child in child_nodes:\n rec_child = alphabeta(child, depth - 1, alpha, beta, True, board)\n if worst_node[0] > rec_child[0]:\n worst_nodes_list = [rec_child]\n worst_node = rec_child\n beta = min(beta, worst_node[0])\n if alpha >= beta:\n return [float(\"-inf\"), []] # Pruning\n elif worst_node[0] == rec_child[0]:\n worst_nodes_list.append(rec_child)\n return random.choice(worst_nodes_list)","def RandomDiTree(N): \n graph = nx.random_tree(N)\n root = int(np.random.choice(graph.nodes,1)[0])\n return _DirectedTree(root,graph)","def findApproxDepth(train, valid, mD=0, mS=0):\n print(\n \"Building a random set of small trees to geuss the max depth and min set size values\"\n )\n res = []\n tree = DecisionTree(train.randSubSet(120, True))\n r = 10\n s = 3\n if mD != 0:\n s = mD - 1\n r = 1\n for i in range(\n s,\n r + s,\n ):\n depth = i + 1 # depth = randint(2,(len(train[0])-1)*3)\n a = 2\n b = 15\n if mS != 0:\n a = mS\n b = mS + 1\n for min_size in range(a, b, 2):\n # min_size = randint(2,(len(train[0])-1)*2)\n tree.buildTree(depth, min_size, True)\n acc = testTreeF(tree, valid)\n res.append([depth, min_size, acc])\n print(\"%.2f\" % (100 * (i - s + 1) / r), \"percent done\")\n best = max(res, key=lambda r: r[-1])\n # res.sort(key=lambda r: r[-1])\n # for r in res:\n # print(r)\n print(\"found a depth of\", best[0], \"and min size of\", best[1])\n return best","def generate(cls, rng, get_nodes, tree_type, depth, force_types=[],\n parent=None):\n\n # Determine allowed types\n force_types_ = [] # For children\n if force_types: # If there's forced type for this depth,\n types = force_types[0] # use it, and don't pass it on.\n force_types_ = force_types[1:]\n elif parent is not None: # Otherwise, inherit from parent.\n # Doesn't work with mutate, because\n this_i = len(parent.children)\n types = parent.child_type[this_i]\n else:\n raise ValueError('Types must be specified for each node, either '\n 'by the \"force_types\" kwarg (required for root, '\n 'optional for depths), or inherited from the '\n '\"child_type\" attribute of the parent Node.')\n\n # Decide whether terminal or function\n if depth == 0: # Always return a terminal at depth 0\n is_terminal = True\n elif (tree_type == 'g' and # For grow trees,\n 'terminal' in types and # if it's allowed,\n rng.choice([False, True])): # flip a coin.\n is_terminal = True\n else: # Otherwise, return a function\n is_terminal = False\n types = [t for t in types if t != 'terminal']\n\n # Generate a random node\n if is_terminal:\n node_data = rng.choice(get_nodes(['terminal', 'constant']))\n node = cls(node_data, tree_type, parent=parent)\n else:\n node_data = rng.choice(get_nodes(types, depth))\n node = cls(node_data, tree_type, parent=parent)\n # Generate children\n node.children = []\n for i in range(node.arity):\n node.children.append(cls.generate(\n rng, get_nodes, tree_type, depth-1, force_types_, node))\n return node","def get_max_depth(self):\n return self.MAX_DEPTH","def get_depth(self, current, n):\n if current is not None:\n return max(self.get_depth(current.left, n + 1), self.get_depth(current.right, n + 1))\n else:\n return n","def generate_jungle(variable_names, dist_func, num_levels=2, **kwargs):\n shuffle(variable_names)\n num_vars = len(variable_names)\n\n edges = []\n for i in range(num_vars):\n level = int(np.log2(i+1))\n idx = i + 1 - 2 ** level\n for l in range(1, num_levels+1):\n gl = (2**l) * idx + 2 ** (level + l) - 1\n edges += [[i, gl + j] for j in range(2**l)]\n edges = [e for e in edges if max(e) < num_vars]\n\n return graph_from_edges(variable_names, dist_func, edges)","def build_tree_helper(x, n, d, max_d, name=defaultname):\n ret = {}\n ret['name'] = name(x)\n if d == max_d:\n return ret\n children = collatz.children(x, n)\n if x == 1:\n children = children[1:]\n if children:\n ret['children'] = [build_tree_helper(x, n, d + 1, max_d, name) for x in children]\n return ret","def max_depth(self) -> int:\n return pulumi.get(self, \"max_depth\")","def init_population(pop_size):\n population = []\n for md in range(2, MAX_DEPTH - 1):\n for _ in range(int(pop_size / 2)):\n t = Tree()\n t.random_tree(grow=True, max_depth=md) # Grow method \n population.append(t)\n for _ in range(int(pop_size / 2)):\n t = Tree()\n t.random_tree(grow=False, max_depth=md) # Full method\n population.append(t)\n return population","def func_randomint(exp_parameter=3, root_parameter=1):\n sup = Word.objects.all().order_by(\"-id\")[0].id - 1\n randfloat = random.uniform(0,sup)\n randint = math.floor(exp_parameter*(sup**(sup/randfloat)+1) + root_parameter(-1*math.sqrt(sup*randfloat)+sup)/2)\n return randint","def depth_limited_search(initial_state, goal_state, limit):\n\n return recursive_dls(createRootNode(initial_state), goal_state, limit)","def DEFAULT_MAX_DEPTH(self): # real signature unknown; restored from __doc__\n pass","def fill_depth(depth):\n ht, wd = depth.shape\n x, y = np.meshgrid(np.arange(wd), np.arange(ht))\n xx = x[depth > 0].astype(np.float32)\n yy = y[depth > 0].astype(np.float32)\n zz = depth[depth > 0].ravel()\n return interpolate.griddata((xx, yy), zz, (x, y), method='nearest')","def generate_tree(self, max_depth = None):\n\n if max_depth is None:\n max_depth = self.tree.max_depth\n else:\n max_depth -= 1\n if max_depth == 0:\n return\n self.generate_children()\n if self.tree.remove:\n os.unlink(self.source_filename)\n for child in self.children:\n if child.count > self.tree.max_count:\n child.generate_tree(max_depth)","def uniform_cost(initial_state, dimension=3):\n\n\tdef add_cost(node):\n\t\tnode.cost = node.depth\n\n\treturn search(initial_state, Frontier(PriorityQueue), dimension, cost_fn=add_cost)","def bestAtDepthL(self,depth=0,scoreFunc=None) :\n scoreFunc = scoreFunc if scoreFunc != None else lambda g : g.leafScore()\n max_score = ACG.minf\n max_L = None\n for g in self.L() :\n if depth > 0 :\n g = g.bestAtDepthR(depth=depth-1,scoreFunc=scoreFunc)\n score = scoreFunc(g)\n if score > max_score :\n max_score = score\n max_L = g\n return max_L if max_L != None else self","def buildTree(rows, maxDepth = None, scoref=entropy, depth = 0):\n #A base condition for the recursion. Check if this branch of a split has no data\n if len(rows)==0:\n return decisionNode( )\n newDepth = depth + 1 #Calculate the depth of the next split.\n #Check if the depth at the next split is greater than a maximum specified depth\n if (maxDepth == 0 or maxDepth) and (newDepth > maxDepth): \n return decisionNode(results=__uniqueCounts(rows)) #If so, stop splitting.\n current_score=scoref(rows) #Calculate the current value of the score function.\n # Set up some variables to track the best criteria\n best_gain=0.0 #Initialize a value for the best gain from all possible splits\n best_criteria=None #Initialize a variable for the best column to split on\n best_sets=None #Initialize a variable for the best split's true and false data.\n\n #Count the number of columns in the row, minus the results column \n column_count=len(rows[0])-1\n for col in range(0,column_count): #Iterate over all the columns of the data\n #Generate the list of different values in this column\n column_values={} #Initialize a dictionary to store the column values\n for row in rows: \n #Iterate over each row, adding a key in the dict for each observed value\n column_values[row[col]]=1\n # Divide the dataset on each value in this column.\n for value in column_values.keys( ):\n (set1,set2)=__divideset(rows,col,value)\n #Calculate the fraction of data in the true branch\n p=float(len(set1))/len(rows) \n #Calculate the gain on the chosen score function using this split.\n gain=current_score-p*scoref(set1)-(1-p)*scoref(set2) \n #Check if this split provides a better gain than the best previous split\n if gain>best_gain and len(set1)>0 and len(set2)>0:\n best_gain=gain\n best_criteria=(col,value)\n best_sets=(set1,set2)\n # Recursively create the subbranches\n if best_gain>0:\n trueBranch=buildTree(best_sets[0], maxDepth = maxDepth, depth = newDepth)\n falseBranch=buildTree(best_sets[1], maxDepth = maxDepth, depth = newDepth)\n return decisionNode(col=best_criteria[0],value=best_criteria[1],\n tb=trueBranch,fb=falseBranch)\n else:\n return decisionNode(results=__uniqueCounts(rows))","def apply_depth_multiplier(d: Union[int, Sequence[Any]],\n depth_multiplier: float):\n if isinstance(d, int):\n return int(d * depth_multiplier)\n else:\n return [apply_depth_multiplier(x, depth_multiplier) for x in d]","def recursive_mapWithDepth(x, function, apply_depth):\n if count_nest(x) == apply_depth:\n return function(x)\n else:\n if isinstance(x, (list, tuple, set)):\n t = type(x)\n return t(map(lambda e: recursive_mapWithDepth(e, function, apply_depth), x))","def progressive_deepening(state, heuristic_fn=always_zero, depth_limit=INF,\n maximize=True) :\n anytime_value = AnytimeValue() # TA Note: Use this to store values.\n depth = 0\n while depth<=depth_limit-1:\n depth+=1\n best_option=minimax_search_alphabeta(state,-INF,INF, heuristic_fn=heuristic_fn,depth_limit=depth, maximize=True)\n anytime_value.set_value(best_option)\n return anytime_value","def depth_from_indentation(function):\n def wrap(start, values):\n #print 'Depth %d | %d %s' %(self._depth, start, values)\n #self._depth = start\n self._current_node = function(values)\n #print self._current_node\n return ''\n\n return wrap","def get_depths(self, variables):\n\n return [0.]","def build_tree(self, prefix, depth):\n for count, function in [[self.n_files, self.make_file],\n [self.n_children, self.make_child_recurse],\n [self.n_symlinks, self.make_symlink]]:\n for i in range(count):\n if not self.can_continue():\n return\n name = os.path.join(prefix, self.name_gen.next())\n function(name, depth)","def run(self, fitness_function):\r\n return run_helper(depth, fitness_function, 0, 0, 0) # fixme\r","def generate_recursive_rules(limit):\n\n return [\n # 8: 42 | 42 8 - recursion creates the pattern: 42 | 42 42 | 42 42 42 etc...\n f\"8: {' | '.join([('42 ' * x).strip() for x in range(1, limit + 1)])}\",\n # 11: 42 31 | 42 11 31 - recursion creates the pattern: 42 31 | 42 42 31 31 | 42 42 42 31 31 31 etc...\n f\"11: {' | '.join([('42 ' * x).strip() + ' ' + ('31 ' * x).strip() for x in range(1, limit + 1)])}\"\n ]","def make_anonymous_factorial():\n\t# u need to use a helper function if your lambda statement does\n\t# not have a name\n\t# fact = lambda n: 1 if n == 1 else mul(n, fact(sub(n, 1)))\n\tdef recursive2(f, n):\n\t\treturn f(f, n)\n\n\tdef recursive(n):\n\n\t\treturn recursive2((lambda rec, n: 1 if n == 1 else mul(n, rec(sub(n, 1)))), n)\n\n\treturn recursive","def _random_walk(shape, nonlinearity, dtype=dtypes.float32, seed=None,\n name=\"random_walk\"):\n assert len(shape) == 2, \"Random Walk initialization only supports 2D tensors.\"\n num_inputs = shape[0]\n if nonlinearity == math_ops.tanh:\n # No real formula for this case yet, but this works well for many\n # layer widths.\n rwg = 1.13\n elif nonlinearity == array_ops.identity:\n rwg = math.exp(1.0 / (2.0 * num_inputs))\n elif nonlinearity == nn_ops.relu:\n rwg = math.sqrt(2.0) * math.exp(1.2 / (max(num_inputs, 6) - 2.4))\n else:\n assert False, \"Unsupported nonlinearity for Random Walk initialization.\"\n\n mean = 0.0\n stddev = rwg / math.sqrt(float(num_inputs))\n\n return random_ops.random_normal(shape, mean=mean, stddev=stddev, dtype=dtype,\n seed=seed, name=name)","def factorial(n): \n def base(): \n return 1 \n def recursive(): \n return n * factorial(n-1)\n return ____________________________________________________________________","def DEFAULT_MIN_DEPTH(self): # real signature unknown; restored from __doc__\n pass","def _max_depth(self):\n max_depth = 0\n for node, data in self.traverse():\n max_depth = max(max_depth, data['level'])\n return max_depth","def build_tree(self, df=None, tree=None, depth=0):\n if df is None:\n df = self.df\n target = self.target\n\n node = self.get_lowest_entropy_feature(df)\n if not node:\n print(\"Pure solution not possible in current branch...\")\n return tree\n variables = df[node].unique()\n\n if tree is None: \n tree = {}\n tree[node] = {}\n\n for value in variables:\n subtable = df[df[node] == value].reset_index(drop=True)\n inner_variables, counts = np.unique(subtable[target], return_counts=True) \n \n if len(counts) == 1:\n tree[node][value] = inner_variables[0] \n elif depth >= self.max_depth:\n return tree \n else:\n depth += 1 \n tree[node][value] = self.build_tree(df=subtable, depth=depth)\n \n return tree","def generate_full(variable_names, dist_func, **kwargs):\n return generate_random_graph(variable_names, dist_func, edge_prob=1.0)","def __init__(self, d=1):\r\n self.depth = d","def max_depth_forest(self):\n return max(x.tree_.max_depth for x in self.result.estimators_)","def leafEvaluation(self, state):\n\n \"\"\"\n Use random generated values for now\n \"\"\"\n z = np.random.randint(2)\n v = random.uniform(0, 1) \n return (1-LAMBDA) * v + LAMBDA * z","def min_depth(t):\n if is_leaf(t):\n return 0\n h = float('inf')\n for b in branches(t):\n # Still works fine!\n h = min(h, 1 + min_depth(b))\n return h","def miniMax(self,state,depth=0):\n \n #print(\"NextState (depth \"+str(depth)+\"):\")\n #print(\"Action: \"+state.get_action())\n \n if state in self.__explored:\n return self.__explored[state.get_hashable_state()]\n \n if state.is_end_state() or depth >= (self.__max_depth - 1):\n self.__explored[state.get_hashable_state()] = state.get_utility_value()\n return state.get_utility_value() #Return terminal state's utility value\n \n is_max_turn = state.get_max_turn()\n childList = state.get_successors()\n \n if is_max_turn:\n utility = float(\"-inf\")\n for c in childList:\n utility = max(utility,self.miniMax(c, depth+1))\n self.__explored[state.get_hashable_state()] = utility\n return utility\n else:\n utility = float(\"inf\")\n for c in childList:\n utility = min(utility,self.miniMax(c, depth+1))\n self.__explored[state.get_hashable_state()] = utility\n return utility","def fn(i, n):\n if len(stack) > 0 and stack[-1] <= n: ans.append(stack + [n])\n for ii in range(i, len(factors)):\n if n % factors[ii] == 0: \n stack.append(factors[ii])\n fn(ii, n//factors[ii])\n stack.pop()","def reset_max_depth(self) -> None:\n # The max depth is now calculated on the fly, so this is a no-op.\n pass","def get_graph_func(name):\n if name == \"chain\":\n f = generate_chain\n elif name == \"bidiag\":\n f = generate_bidiag\n elif name == \"collider\":\n f = generate_collider\n elif name == \"jungle\":\n f = generate_jungle\n elif name == \"full\":\n f = generate_full\n elif name == \"regular\":\n f = generate_regular_graph\n elif name == \"random\":\n f = generate_random_graph\n elif name.startswith(\"random_max_\"): # Random graph with maximum number of parents\n max_parents = int(name.split(\"_\")[-1])\n f = lambda *args, **kwargs: generate_random_graph(*args, max_parents=max_parents, **kwargs)\n else:\n f = generate_random_graph\n return f","def test_MaxDepth_SimpleTree(self):\n\n root = TreeNode(0)\n root.addLeft(1)\n root.addRight(5)\n root.left.addLeft(2)\n root.left.addRight(3)\n root.left.right.addRight(4)\n root.right.addRight(6)\n\n self.assertEqual(findMaxDepthDFS(root),3)","def max_depth(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_depth\")","def generate_level(level):\n seed = level * 69420 # multiply by 69420 to not have the seeds too close to each other\n random.seed(seed)\n dimensions = get_map_size(level)\n level_map = np.full(dimensions, -1)\n while -1 in level_map:\n choice = random.choice(np.argwhere(level_map == -1))\n next_index = (choice[0], choice[1])\n # get indices of the tiles next to the current index\n left_index, up_index, right_index, down_index = get_direction_indices(next_index)\n left = tile_needs_connection(left_index, level_map, has_connection_right)\n up = tile_needs_connection(up_index, level_map, has_connection_down)\n right = tile_needs_connection(right_index, level_map, has_connection_left)\n down = tile_needs_connection(down_index, level_map, has_connection_up)\n level_map[next_index] = get_tile(left, up, right, down)\n return un_solve(level_map)","def __init__(self, recursion_depth: int, noise_depth: int, scale: float,\n snow_height: float = None, tree_height: float = None,\n color_offset_heightmap: \"Terrain\" = None):\n self._depth = recursion_depth\n self._noise_depth = noise_depth\n self._scale = scale\n self._snow_height = snow_height\n self._tree_height = tree_height\n self._color_offset_heightmap = color_offset_heightmap\n self._height_cache = {}\n \n self._only_heightmap = snow_height is None or tree_height is None\n if self._only_heightmap:\n self._heightmap = {}\n else:\n self._triangles = []\n \n # generate the terrain recursively\n self._fractal_triangle((-1,0,math.sqrt(3)), (1,0,math.sqrt(3)), (0,0,0), depth=self._depth)","def fn(n):\n if n == 1: return 1\n return max(max(i, fn(i))*max(n-i, fn(n-i)) for i in range(1, n//2+1))","def disp_to_depth(disp, min_depth, max_depth):\n min_disp = 1 / max_depth\n max_disp = 1 / min_depth\n scaled_disp = min_disp + (max_disp - min_disp) * disp\n depth = 1 / scaled_disp\n return scaled_disp, depth","def lvl_algo(next_level):\n total_xp_needed = (next_level * next_level)\n return total_xp_needed","def resolve_depth(self: models.FeatureDetails, info, **kwargs):\n min = self.data.get(\"berth_min_depth\")\n max = self.data.get(\"berth_max_depth\")\n\n if min is None:\n return None\n\n return {\n \"min\": min,\n \"max\": max,\n }","def reproduce(self):\n\n def compute_seeds(fitness):\n \"\"\" Computes the number of seeds given a fitness value. \"\"\"\n\n seeds = (fitness-min_fitness) / (max_fitness-min_fitness) * \\\n (self.max_seeds-self.min_seeds) + self.min_seeds\n\n return round(seeds)\n\n # evaluates max and min fitness for current year\n max_fitness = max(tree[0] for tree in self.population)\n min_fitness = min(tree[0] for tree in self.population)\n\n # computes the number of seeds produced per tree\n for tree in self.population:\n tree[1].seeds = int(compute_seeds(tree[0]))","def BiasedTree(N,alpha=0.): \n free = sample(range(N),N)\n nodes = [free.pop()]\n links = []\n K = np.zeros((N,))\n K[nodes[0]]=1.\n while free:\n newn = free.pop()\n K[newn]=1.\n p = K[np.array(nodes)]**alpha\n p = p/np.sum(p)\n mother = np.random.choice(nodes,p=p)\n K[mother] += 1.\n nodes.append(newn)\n links.append((mother,newn))\n return nx.DiGraph(links)","def hash_with_depth_int(func: HashFuncT) -> HashFuncT:\n\n @wraps(func)\n def hashing_func(key, depth=1):\n \"\"\"wrapper function\"\"\"\n res = []\n tmp = func(key, 0)\n res.append(tmp)\n for idx in range(1, depth):\n tmp = func(f\"{tmp:x}\", idx)\n res.append(tmp)\n return res\n\n return hashing_func","def depth(self):\n if self.size == 0:\n return 0\n return int(math.log(self.size, 2)) + 1","def factor(n):\n from random import randrange\n while True:\n i = 1\n x = randrange(0, n)\n y = x\n while True:\n i += 1\n x = ((x ** 2) - 1) % n\n d = gcd(y - x, n)\n if d != 1 and d != n:\n return d\n if i > 10000:\n break","def DEFAULT_MAX_DEPTH_DIFF(self): # real signature unknown; restored from __doc__\n pass","def create_binary_tree(depth=3):\n # The only node is root\n max_nodes, nodes = 2 ** depth - 1, 1\n queue = Queue()\n val = IntGenerator()\n root = Node(val=next(val))\n\n queue.enqueue(root)\n while nodes + 2 <= max_nodes:\n current = queue.dequeue()\n\n # Create child nodes until total num is le max_nodes\n # for specified length in binary tree\n if nodes + 2 <= max_nodes: # tree will have +2 nodes after creating children\n current.left = Node(val=next(val))\n current.right = Node(val=next(val))\n queue.enqueue(current.left)\n queue.enqueue(current.right)\n nodes += 2\n\n return root","def get_min_depth(l_k):\n return max(l_k.values())","def bit_depth(self, value):\n self._bit_depth = value\n self._max_DN = (2 ** self.bit_depth) - 1","def bit_depth(self, value):\n self._bit_depth = value\n self._max_DN = (2 ** self.bit_depth) - 1","def fn(n):\n if n == 1: return [TreeNode()]\n ans = []\n for nn in range(1, n, 2): \n for left in fn(nn):\n for right in fn(n-1-nn): \n ans.append(TreeNode(left=left, right=right))\n return ans","def make_tree(self, X_subset, y_subset, depth):\n \n # YOUR CODE HERE\n #self.depth += 1\n if depth < self.max_depth and X_subset.shape[0] >= self.min_samples_split:\n \n best_feature, best_threshold = self.choose_best_split(X_subset, y_subset)\n print('depth = {}, size parent node = {}'.format(depth, len(X_subset)))\n print('best_feature = {}, best_threshold = {}'.format(best_feature, best_threshold))\n new_node = Node(best_feature, best_threshold)\n \n left_child, right_child = self.make_split(best_feature, best_threshold, X_subset, y_subset)\n new_node.left_child = self.make_tree(*left_child, depth+1)\n new_node.right_child = self.make_tree(*right_child, depth+1)\n \n else: # we have a leaf\n new_node = Node(-1, -1) # We flag leaf nodes by setting feature_index and threshold to -1\n new_node.value = self.predicted_values(y_subset)\n \n if self.classification:\n new_node.proba = np.mean(y_subset, axis=0)\n \n # We reduce the depth to compensate for the two calls to self.depth += 1 we make on\n # the same level for left_child and right_child.\n #self.depth -= 1\n \n return new_node","def run(self, max_depth):\n while len(self.stack) > 0:\n state = self.get_next_state()\n\n if state.is_solution():\n self.solutions.append(state.moves)\n\n if len(state.moves) < max_depth:\n self.create_children(state)\n\n self.archive[state.get_tuple()] = len(state.moves)\n\n # sort solutions best to worst\n self.solutions.sort(key=len)\n\n if self.solutions:\n return self.solutions[0]\n\n print(\"This depth is not sufficient.\")\n return []","def depth(self):\n return self._max_depth","def depth_breadth_eval_function(individual, test_data, truth_data, name=None):\r\n # Compute the string representation of the individual\r\n string_rep = str(individual)\r\n # Generate array for appearances of ARG0\r\n data_appearances = [match.start() for match in re.finditer('ARG0', string_rep)]\r\n # Computed by counting occurrences of GTMOEPDataPair per primitive\r\n # Let's make this dynamic in the future by querying all functions\r\n max_breadth = 3.0\r\n # Tradeoff formula\r\n return individual.height - len(data_appearances)/(max_breadth**individual.height + 1.0)","def constructTree(n, board, player, action, possible_position=None):\r\n max_branch_num = 7\r\n # 限制分支因子，不考虑过多局面\r\n node = Node(player=player, action=action)\r\n successors = []\r\n if possible_position == None:\r\n # 没有给定可选位置，我们自己现场计算\r\n logDebug(\"Point 1.\")\r\n possible_position = possible_pos(board)\r\n logDebug(\"Point 2.\")\r\n if possible_position == None:\r\n # 真的没有可选位置，😅\r\n return None\r\n\r\n is_critical = critical(board)\r\n new_board = copy.deepcopy(board)\r\n if is_critical == '4_1':\r\n # 我方四子连珠\r\n for pos in possible_position:\r\n new_board[pos[0]][pos[1]] = player\r\n new_special_pattern = is_special_pattern(board = new_board, player = player)\r\n old_special_pattern = is_special_pattern(board = board, player = player)\r\n if new_special_pattern[\"H4\"] != old_special_pattern[\"H4\"] or new_special_pattern[\"C4\"] != old_special_pattern[\"C4\"]:\r\n node = Node(player=player, action=action)\r\n successors = []\r\n successors.append(Node(player = 3-player, isLeaf = True, value = 1000000000, action = pos))\r\n # action 是到达这个节点，我们落子的位置\r\n node.successor = successors\r\n return node\r\n \r\n top_position = []\r\n\r\n if n == 1:\r\n # 树的深度只有一层\r\n if len(possible_position) < max_branch_num:\r\n for pos in possible_position:\r\n # :pos: 坐标 (x, y)\r\n # :prob_position: 可选位置，坐标的列表\r\n copy_board = copy.deepcopy(board)\r\n # 棋盘当前状态的拷贝（或许可以直接用深拷贝拷贝列表，不用一个一个位置去循环）\r\n copy_board[pos[0]][pos[1]] = player\r\n # 在当前位置放置当前棋手的棋子\r\n # player == 1 or 2\r\n temp_value = board_score(copy_board)\r\n # :util::board_evaluation:返回当前整个棋局的评分\r\n # 大评分对我们好，小评分对对方好\r\n # print temp_value\r\n # successors.append(Node(player=3-player, isLeaf=True, value=board_evaluation(board_copy), action=pos))\r\n successors.append(Node(player=3 - player, isLeaf=True, value=temp_value, action=pos))\r\n # 一层搜索树，下一个节点就是叶节点\r\n # player = 3 - player 完成棋手轮换\r\n # TODO: need to delete\r\n else:\r\n # 如果分支因子过大，只考虑落子后局面最好的前k个\r\n for pos in possible_position:\r\n board_copy = copy.deepcopy(board)\r\n board_copy[pos[0]][pos[1]] = player\r\n temp_value = board_score(board_copy)\r\n # :util::board_evaluation: 返回当前整个棋局的评分\r\n top_position.append(temp_value)\r\n temp = copy.deepcopy(top_position[:])\r\n # deepcopy\r\n temp.sort(reverse=True)\r\n # 从大到小排列\r\n for v in temp[0:max_branch_num]:\r\n pos = possible_position[top_position.index(v)]\r\n successors.append(Node(player=3 - player, isLeaf=True, value=v, action=pos))\r\n # 一层，后继节点是叶节点\r\n\r\n else:\r\n # 多层搜索树🌲\r\n if len(possible_position) < max_branch_num:\r\n # i = 0\r\n for pos in possible_position:\r\n # i += 1\r\n # print pos, 'else called', i\r\n copy_board = copy.deepcopy(board)\r\n copy_board[pos[0]][pos[1]] = player\r\n # print board_copy\r\n successors.append(constructTree(n-1, copy_board, 3-player, pos, update_possible_pos(pos, possible_position)))\r\n # 递归的调用\r\n else:\r\n for pos in possible_position:\r\n board_copy = copy.deepcopy(board)\r\n board_copy[pos[0]][pos[1]] = player\r\n top_position.append(board_score(board_copy))\r\n temp = copy.deepcopy(top_position[:])\r\n temp.sort(reverse=True)\r\n for v in temp[0:max_branch_num]:\r\n pos = possible_position[top_position.index(v)]\r\n copy_board = copy.deepcopy(board)\r\n copy_board[pos[0]][pos[1]] = player\r\n successors.append(constructTree(n - 1, copy_board, 3 - player, pos, update_possible_pos(pos, possible_position)))\r\n node.successor = successors\r\n return node"],"string":"[\n \"def build_random_function(min_depth, max_depth):\\n depth = random.randint(min_depth, max_depth)\\n return build_random_function_helper(depth)\",\n \"def build_random_function(min_depth, max_depth):\\n\\n # your code goes here\",\n \"def build_rand_func(min_depth, max_depth):\\n\\n\\toptions = [['prod'],['sin_pi'],['cos_pi'],['A'],['B']]\\n\\n\\t# base case\\n\\tif max_depth == 1:\\n\\t\\treturn ['A']\\n\\n\\t# if min_depth reached, also choose base case\\n\\telif min_depth <= 1:\\n\\n\\t\\tfunc_choice = options[randint(0,4)] # choose random func\\n\\n\\t\\t# allows products to take two imputs\\n\\t\\tif func_choice == ['prod']:\\n\\t\\t\\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1), build_rand_func(min_depth, max_depth)]\\n\\n\\t\\t# if base case reached, end recursion\\n\\t\\telif func_choice == ['A'] or func_choice == ['B']:\\n\\t\\t\\treturn func_choice\\n\\n\\t\\t# otherwise, recurse as usual (single input)\\n\\t\\telse:\\n\\t\\t\\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1)]\\n\\n\\t# if min_depth or max_depth not reached, loop again with min/max counters decremented\\n\\telse:\\n\\t\\tfunc_choice = options[randint(0, 2)]\\n\\n\\t\\t# allows products to take two inputs\\n\\t\\tif func_choice != ['prod']:\\n\\t\\t\\treturn func_choice + [(build_rand_func(min_depth-1, max_depth-1))]\\n\\n\\t\\t# otherwise, recurse as usual\\n\\t\\telse:\\n\\t\\t\\treturn func_choice + [build_rand_func(min_depth-1, max_depth-1), build_rand_func(min_depth-1, max_depth-1)]\\n\\n\\t# print rand_func\\n\\t# return rand_func\",\n \"def build_random_function(min_depth, max_depth):\\n if max_depth == 1:\\n rand = random.random()\\n if rand < 1.0/(2+timeflag):\\n return [\\\"x\\\"]\\n elif rand < 2.0/(2+timeflag):\\n return [\\\"y\\\"]\\n else:\\n return [\\\"t\\\"]\\n elif min_depth <= 1:\\n if random.random() > (max_depth - 1.0)/max_depth:\\n rand = random.random()\\n if rand < 1.0/(2+timeflag):\\n return [\\\"x\\\"]\\n elif rand < 2.0/(2+timeflag):\\n return [\\\"y\\\"]\\n else:\\n return [\\\"t\\\"]\\n\\n rand = random.random()\\n if rand < 1.0/NUM_FF:\\n return [\\\"prod\\\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\\n elif rand < 2.0/NUM_FF:\\n return [\\\"avg\\\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\\n elif rand < 3.0/NUM_FF:\\n return [\\\"cos_pi\\\",build_random_function(min_depth-1,max_depth-1)]\\n elif rand < 4.0/NUM_FF:\\n return [\\\"sin_pi\\\",build_random_function(min_depth-1,max_depth-1)]\\n elif rand < 5.0/NUM_FF:\\n return [\\\"hypot\\\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\\n #elif rand < 6.0/NUM_FF:\\n # return [\\\"pow\\\",build_random_function(min_depth-1,max_depth-1)]\\n #elif rand < 6.0/NUM_FF:\\n # return [\\\"add\\\",build_random_function(min_depth-1,max_depth-1),build_random_function(min_depth-1,max_depth-1)]\\n elif rand < 6.0/NUM_FF:\\n return [\\\"cube\\\",build_random_function(min_depth-1,max_depth-1)]\",\n \"def build_random_function(min_depth, max_depth):\\n first_order = ['x', 'y']\\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\\n\\n # Base Case. can say == instead of <= because min depth is only ever\\n # decreased by 1\\n if min_depth == 0:\\n ls = []\\n ls.append(first_order[random.randint(0, 1)])\\n return ls\\n else:\\n rand = random.randint(0, len(elementary_func)-1)\\n begin = elementary_func[rand]\\n arguments = [begin]\\n arguments.append(build_random_function(min_depth-1, max_depth-1))\\n\\n # Establishes a second argument for the functions which need two\\n if rand < 2:\\n arguments.append(build_random_function(min_depth-1, max_depth-1))\\n return arguments\",\n \"def build_random_function(min_depth, max_depth):\\n # print 'buildrandomfunc'\\n depth = random.randint(min_depth, max_depth)\\n if depth==1: #if this is the bottom call, return x or y\\n return [blocks[random.randint(0,3)]]\\n myFunc=blocks[random.randint(0,7)]\\n params=args[myFunc]\\n finalList=[]\\n finalList+=[myFunc]\\n for i in range(0,params):\\n finalList+=[build_random_function(depth-1,depth-1)]\\n return finalList\",\n \"def build_random_function_3(min_depth, max_depth):\\n first_order = ['x', 'y', 't']\\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\\n if min_depth == 0:\\n ls = []\\n ls.append(first_order[random.randint(0, 2)])\\n return ls\\n else:\\n rand = random.randint(0, len(elementary_func)-1)\\n begin = elementary_func[rand]\\n arguments = [begin]\\n arguments.append(build_random_function_3(min_depth-1, max_depth-1))\\n if rand < 2:\\n arguments.append(build_random_function_3(min_depth-1, max_depth-1))\\n to_return = [begin]\\n to_return.append(arguments)\\n return arguments\",\n \"def build_random_function_helper(depth):\\n random_index = random.randint(0, len(funcs)-1)\\n if depth == 0:\\n return [funcs[random_index][0]], funcs[random_index][1]\\n elif depth > 0:\\n name1, lam1 = build_random_function_helper(depth-1)\\n name2, lam2 = build_random_function_helper(depth-1)\\n\\n name_func = [funcs[random_index][0], name1, name2]\\n lam_func = lambda x, y: funcs[random_index][1](lam1(x,y), lam2(x,y))\\n return name_func, lam_func\",\n \"def r_lambda_func(depth):\\n first_order = [lambda x, y: x, lambda x, y: y]\\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi']\\n if depth == 0:\\n rand = random.randint(0, 1)\\n if rand == 0:\\n return lambda x, y: x\\n else:\\n return lambda x, y: y\\n else:\\n rand = random.randint(0, len(elementary_func))\\n rand = 1\\n if rand == 0:\\n return lambda x, y: (r_lambda_func(depth-1)(x, y)) * (r_lambda_func(depth-1)(x, y))\\n elif rand == 1:\\n return lambda x, y: .5 * ((r_lambda_func(depth-1)(x, y) + r_lambda_func(depth-1)(x, y)))(x, y)\\n elif rand == 2:\\n return lambda x, y: math.cos(lambda x, y: math.pi(x, y) * r_lambda_func(depth-1)(x, y))(x, y)\\n elif rand == 3:\\n return lambda x, y: math.sin(lambda x, y: math.pi(x, y) * r_lambda_func(depth-1)(x, y))(x, y)\",\n \"def depth(x):\\n return max(int(x * depth_multiplier), 8)\",\n \"def test_rand_100_depth_remains_less_than_8():\\n from bbst import Bst\\n from random import shuffle\\n max_depth = 0\\n for x in range(10):\\n rando = [x for x in range(100)]\\n shuffle(rando)\\n tree = Bst(rando)\\n tree_depth = tree.depth()\\n if tree_depth > max_depth:\\n max_depth = tree_depth\\n assert max_depth == 8\",\n \"def random_tree(self, grow, max_depth, depth=0):\\n # Full method\\n if depth < MIN_DEPTH or (depth < MAX_DEPTH and not grow):\\n self.body = random.choice(operators)\\n elif depth >= MAX_DEPTH:\\n self.body = random.choice(terminals)\\n else: # intermediate depth, grow\\n if random.random() > 0.9:\\n self.body = random.choice(operators)\\n else:\\n self.body = random.choice(terminals)\\n if self.body in operators:\\n self.left = Tree()\\n self.left.random_tree(grow, max_depth, depth=depth + 1)\\n self.right = Tree()\\n self.right.random_tree(grow, max_depth, depth=depth + 1)\",\n \"def pow(a, n, depth=1):\\n if n == 1:\\n print(\\\"depth=\\\", depth)\\n return a\\n if n % 2 == 1:\\n return pow(a, n-1, depth + 1) * a\\n else: # n % 2 = 0\\n return pow(a * a, n // 2, depth + 1)\",\n \"def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\\n\\n def get_states(start):\\n frontier = [start]\\n frontier_set = {start}\\n explored = set()\\n\\n states = [False for _ in range(len(depths))]\\n while not all(states):\\n node = frontier.pop(0)\\n frontier_set.remove(node)\\n explored.add(node)\\n\\n children = node.get_children()\\n\\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\\n # produced from the parent by the same action) produced at a certain depth will always be selected,\\n # and children produced by other actions will never be selected\\n shuffle(children)\\n\\n for child in children:\\n if child not in frontier_set and child not in explored:\\n frontier_set.add(child)\\n frontier.append(child)\\n child.path_cost = node.path_cost+1\\n index = depths.index(child.path_cost) if child.path_cost in depths else None\\n if index is not None and not states[index]:\\n states[index] = {'start': start.sequence, 'end': child.sequence}\\n\\n return states\\n\\n depth_sample = [[] for depth in range(len(depths))]\\n\\n for _ in range(num_samples):\\n start = list(range(1,n+2))\\n shuffle(start)\\n start = PuzzleState(start, path_cost=0)\\n\\n states = get_states(start)\\n print('\\\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\\n list(map(list.append, depth_sample, states))\\n\\n return depth_sample\",\n \"def build_random_trees(rows, n_features, max_depth, min_size, n_trees, random_dataset_size):\\n trees = []\\n for tree_number in range(n_trees):\\n print(\\\"Building tree number:\\\", tree_number, \\\"of\\\", n_trees)\\n # Select random dataset from original dataset\\n random_dataset = select_random_rows(rows, random_dataset_size)\\n\\n # Select random features (columns)\\n random_features = []\\n for random_feature in range (n_features):\\n # generate random index number to pick column\\n random_column = randrange(len(rows))\\n random_features.append(random_column)\\n # generate the random tree with randomly picked features (columns) and a random dataset\\n random_tree = build_single_random_tree(random_dataset, random_features, max_depth, min_size, 1)\\n # add to list of trees\\n trees.append(random_tree)\\n return trees\",\n \"def depth_from_match(function):\\n def wrap(start, values):\\n #print 'Depth %d | %d %s' %(self._depth, start, values)\\n #print self._current_node\\n self._depth = start\\n self._current_node = function(values)\\n #print self._current_node\\n return ''\\n\\n return wrap\",\n \"def bld_func(min_d, max_d):\\n\\n opers = ['prod','avg','cos_pi','sin_pi','subtract','add']\\n oper = random.choice(opers)\\n\\n depth = random.randint(min_d,max_d)\\n\\n if depth <= 1:\\n return [random.choice(['x','y','t'])]\\n elif oper == 'prod':\\n return ['prod', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\\n elif oper == 'avg':\\n return ['avg', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\\n elif oper == 'cos_pi':\\n return ['cos_pi', bld_func(min_d-1,max_d-1)]\\n elif oper == 'sin_pi':\\n return ['sin_pi', bld_func(min_d-1,max_d-1)]\\n elif oper == 'subtract':\\n return ['subtract', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\\n elif oper == 'add':\\n return ['add', bld_func(min_d-1,max_d-1), bld_func(min_d-1,max_d-1)]\",\n \"def test_random_forest_max_depth_parameter(params, X_train, X_test, y_train, y_test):\",\n \"def max_depth(self) -> int:\\n return 0\",\n \"def fn(x):\\n nonlocal ans \\n if x < ans: \\n if min(depth) == n: ans = x # all tiled\\n else: \\n i = min(depth)\\n j = jj = depth.index(i) # (i, j)\\n while jj < m and depth[jj] == depth[j]: jj += 1\\n k = min(n - i, jj - j)\\n for kk in reversed(range(1, k+1)): \\n for jj in range(j, j+kk): depth[jj] += kk\\n fn(x+1)\\n for jj in range(j, j+kk): depth[jj] -= kk\",\n \"def randomTree(maxLevels, minLeafLevels, maxChildren, weightRange, level=0, usedLabels = set()):\\n numChildren = randint(1,maxChildren) if level < minLeafLevels else (randint(0,maxChildren) if level < maxLevels else 0)\\n\\n if numChildren > 0:\\n childNodes = [randomTree(maxLevels, minLeafLevels, maxChildren, weightRange, level+1, usedLabels) for i in range(numChildren)]\\n weights = [int(uniform(*weightRange)) if random() < 0.25 else round(uniform(*weightRange), randint(0,4)) for i in range(numChildren)]\\n return PhyloTree_sol.PhyloTree(children = list(zip(childNodes, weights)))\\n \\n while True:\\n label = \\\"\\\".join([choice(labels) for i in range(3)])\\n if not label in usedLabels:\\n break\\n \\n usedLabels.add(label)\\n\\n return PhyloTree_sol.PhyloTree(label=label)\",\n \"def build_tree(n, d, name=defaultname):\\n return build_tree_helper(1, n, 1, d, name)\",\n \"def test_function(n, m,level=10):\\n # call another function so the stack is bigger\\n if level > 0:\\n return test_function(n,m,level=level-1)\\n else:\\n return test_function2(m, n)\",\n \"def get_max_dmag_from_depth(depth):\\n return 2.5 * np.log10(depth)\",\n \"def score_max_depths(graph, max_depths):\\n ###TODO\\n pass\",\n \"def iterative_gaussian_tree(\\n basedir: Union[str, PurePath],\\n nfiles: int = 2,\\n nfolders: int = 1,\\n repeat: int = 1,\\n maxdepth: Optional[int] = None,\\n sigma_folders: int = 1,\\n sigma_files: int = 1,\\n min_folders: int = 0,\\n min_files: int = 0,\\n filename: Callable = random_string,\\n payload: Optional[Callable[[Path], Generator[Path, None, None]]] = None,\\n) -> Tuple[List[Path], List[Path]]:\\n\\n # noinspection PyUnusedLocal\\n @no_type_check\\n def nfolders_func(*args):\\n return max(min_folders, int(random.gauss(nfolders, sigma_folders)))\\n\\n # noinspection PyUnusedLocal\\n @no_type_check\\n def nfiles_func(*args):\\n return max(min_files, int(random.gauss(nfiles, sigma_files)))\\n\\n return iterative_tree(\\n basedir=basedir,\\n nfiles_func=nfiles_func,\\n nfolders_func=nfolders_func,\\n repeat=repeat,\\n maxdepth=maxdepth,\\n filename=filename,\\n payload=payload,\\n )\",\n \"def max_recursion_depth(self, max_recursion_depth: ConfigNodePropertyInteger):\\n\\n self._max_recursion_depth = max_recursion_depth\",\n \"def get_recursion_depth(self):\\n str_depth_input = self.entries[\\\"ent_recursion_depth\\\"].get()\\n if str_depth_input == '':\\n return None # default of fractal class while drawing in None\\n # draws the base curve instead\\n return int(str_depth_input)\",\n \"def depth_estimation(x_left, x_right, f=33.4, d=114):\\n depth = abs(f * d / ((x_left - x_right) / 72 * 2.54)) / 100 # - 0.418879\\n return depth\",\n \"def __build_tree__(self, features, classes, depth=0):\\n\\n # TODO: finish this.\\n root = None\\n if (len(set(classes)) <= 1) and (len(classes) != 0) :\\n return DecisionNode(None,None,None,classes[0])\\n elif (len(classes) == 0):\\n return DecisionNode(None,None,None,2)\\n elif depth == self.depth_limit:\\n return DecisionNode(None,None,None,max(set(classes), key=list(classes).count))\\n else:\\n# if depth == 0:\\n features = np.array(features)\\n classes = np.array(classes).reshape(-1,1)\\n feat_shape = features.shape\\n sample_list = range(feat_shape[0])\\n gains = np.zeros((feat_shape[1]))\\n indices = np.zeros((feat_shape[1]))\\n for i in range(feat_shape[1]):\\n attribute = features[:,i]\\n for j in range(20):\\n split_indx = int(np.random.choice(sample_list, replace=False))\\n idx_above = np.where(attribute > attribute[split_indx])[0]\\n idx_below = np.where(attribute < attribute[split_indx])[0]\\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\\n gain = gini_gain(list(classes.reshape(1,-1)[0]),[list(classes_below),list(classes_above)])\\n if gain > gains[i]:\\n gains[i] = gain\\n indices[i] = split_indx\\n indx = np.argmax(gains)\\n split_indx = int(indices[indx])\\n attribute = features[:,indx]\\n idx_above = np.where(attribute > attribute[split_indx])[0]\\n idx_below = np.where(attribute < attribute[split_indx])[0] \\n features_below = features[idx_below,:]\\n features_above = features[idx_above,:]\\n classes_below = classes[idx_below,:].reshape(1,-1)[0]\\n classes_above = classes[idx_above,:].reshape(1,-1)[0]\\n if (len(classes_below) != 0) and (len(classes_above) != 0):\\n root = DecisionNode(None,None,lambda feat:feat[indx] > features[split_indx,indx])\\n root.left = self.__build_tree__(features_above, classes_above, depth+1)\\n root.right = self.__build_tree__(features_below, classes_below, depth+1)\\n return root\\n elif (len(classes_below) == 0) and (len(classes_above) != 0):\\n return DecisionNode(None,None,None,max(set(classes_above), key=list(classes_above).count))\\n elif (len(classes_above) == 0) and (len(classes_below) !=0):\\n return DecisionNode(None,None,None,max(set(classes_below), key=list(classes_below).count))\\n else:\\n return DecisionNode(None,None,None,2)\",\n \"def nodes_at_depth(depth):\\n return list(range(2**depth-1, 2**(depth+1)-1))\",\n \"def max_recursion_depth(self) -> ConfigNodePropertyInteger:\\n return self._max_recursion_depth\",\n \"def bestAtDepthR(self,depth=0,scoreFunc=None) :\\n scoreFunc = scoreFunc if scoreFunc != None else lambda g : g.leafScore()\\n min_score = ACG.inf\\n min_R = None\\n for g in self.R() :\\n if depth > 0 :\\n g = g.bestAtDepthL(depth=depth-1,scoreFunc=scoreFunc)\\n score = scoreFunc(g)\\n if score < min_score :\\n min_score = score\\n min_R = g\\n return min_R if min_R != None else self\",\n \"def get_desired_depth(file_name, tree, desired_depth):\\n node_keys = []\\n get_nodes_at_depth(tree.root, desired_depth, node_keys)\\n generate_file(file_name, node_keys)\\n print(\\\"File '\\\" + file_name + \\\"' generated with keys at depth: :\\\", desired_depth)\",\n \"def depth_from_nemo_tag(function):\\n def wrap(start, values):\\n # print 'Depth %d | %d %s' %(self._depth, start, values)\\n self._depth = start\\n tokens = values[1]\\n self._current_node = function(tokens)\\n #print self._current_node\\n return ''\\n\\n return wrap\",\n \"def alphabeta(node, depth, alpha, beta, maximizingPlayer, board):\\n if depth == 0:\\n return node\\n\\n if maximizingPlayer: # This is us\\n best_node = float(\\\"-inf\\\"), []\\n\\n # Get child nodes and put them in the proper form\\n possible_moves = get_possible_moves_white(node, board)\\n child_nodes = []\\n for set_moves in possible_moves:\\n child_nodes.append([get_total_score(set_moves, board), set_moves])\\n\\n if len(child_nodes) == 0:\\n return [float(\\\"-inf\\\"), node[1]] # We get put check mate (crash if node[1] == [])\\n\\n best_nodes_list = []\\n i = randrange(len(child_nodes))\\n for child in child_nodes[i:] + child_nodes[:i]:\\n rec_child = alphabeta(child, depth - 1, alpha, beta, False, board)\\n if best_node[0] < rec_child[0]:\\n best_nodes_list = [rec_child]\\n best_node = rec_child\\n alpha = max(alpha, best_node[0])\\n if alpha >= beta:\\n if alpha == float(\\\"inf\\\"):\\n return best_node\\n return [float(\\\"inf\\\"), []] # Pruning\\n elif best_node[0] == rec_child[0]:\\n best_nodes_list.append(rec_child)\\n return random.choice(best_nodes_list)\\n else: # minimizingPlayer\\n worst_node = float(\\\"inf\\\"), []\\n\\n # Get child nodes and put them in the proper form\\n possible_moves = get_possible_moves_black(node, board)\\n child_nodes = []\\n for set_moves in possible_moves:\\n child_nodes.append([get_total_score(set_moves, board), set_moves])\\n\\n if len(child_nodes) == 0:\\n if is_checkmate(node[1], board):\\n return [float(\\\"inf\\\"), node[1]] # Check-mate\\n else:\\n return [float(\\\"-inf\\\"), node[1]] # Draw\\n\\n worst_nodes_list = []\\n for child in child_nodes:\\n rec_child = alphabeta(child, depth - 1, alpha, beta, True, board)\\n if worst_node[0] > rec_child[0]:\\n worst_nodes_list = [rec_child]\\n worst_node = rec_child\\n beta = min(beta, worst_node[0])\\n if alpha >= beta:\\n return [float(\\\"-inf\\\"), []] # Pruning\\n elif worst_node[0] == rec_child[0]:\\n worst_nodes_list.append(rec_child)\\n return random.choice(worst_nodes_list)\",\n \"def RandomDiTree(N): \\n graph = nx.random_tree(N)\\n root = int(np.random.choice(graph.nodes,1)[0])\\n return _DirectedTree(root,graph)\",\n \"def findApproxDepth(train, valid, mD=0, mS=0):\\n print(\\n \\\"Building a random set of small trees to geuss the max depth and min set size values\\\"\\n )\\n res = []\\n tree = DecisionTree(train.randSubSet(120, True))\\n r = 10\\n s = 3\\n if mD != 0:\\n s = mD - 1\\n r = 1\\n for i in range(\\n s,\\n r + s,\\n ):\\n depth = i + 1 # depth = randint(2,(len(train[0])-1)*3)\\n a = 2\\n b = 15\\n if mS != 0:\\n a = mS\\n b = mS + 1\\n for min_size in range(a, b, 2):\\n # min_size = randint(2,(len(train[0])-1)*2)\\n tree.buildTree(depth, min_size, True)\\n acc = testTreeF(tree, valid)\\n res.append([depth, min_size, acc])\\n print(\\\"%.2f\\\" % (100 * (i - s + 1) / r), \\\"percent done\\\")\\n best = max(res, key=lambda r: r[-1])\\n # res.sort(key=lambda r: r[-1])\\n # for r in res:\\n # print(r)\\n print(\\\"found a depth of\\\", best[0], \\\"and min size of\\\", best[1])\\n return best\",\n \"def generate(cls, rng, get_nodes, tree_type, depth, force_types=[],\\n parent=None):\\n\\n # Determine allowed types\\n force_types_ = [] # For children\\n if force_types: # If there's forced type for this depth,\\n types = force_types[0] # use it, and don't pass it on.\\n force_types_ = force_types[1:]\\n elif parent is not None: # Otherwise, inherit from parent.\\n # Doesn't work with mutate, because\\n this_i = len(parent.children)\\n types = parent.child_type[this_i]\\n else:\\n raise ValueError('Types must be specified for each node, either '\\n 'by the \\\"force_types\\\" kwarg (required for root, '\\n 'optional for depths), or inherited from the '\\n '\\\"child_type\\\" attribute of the parent Node.')\\n\\n # Decide whether terminal or function\\n if depth == 0: # Always return a terminal at depth 0\\n is_terminal = True\\n elif (tree_type == 'g' and # For grow trees,\\n 'terminal' in types and # if it's allowed,\\n rng.choice([False, True])): # flip a coin.\\n is_terminal = True\\n else: # Otherwise, return a function\\n is_terminal = False\\n types = [t for t in types if t != 'terminal']\\n\\n # Generate a random node\\n if is_terminal:\\n node_data = rng.choice(get_nodes(['terminal', 'constant']))\\n node = cls(node_data, tree_type, parent=parent)\\n else:\\n node_data = rng.choice(get_nodes(types, depth))\\n node = cls(node_data, tree_type, parent=parent)\\n # Generate children\\n node.children = []\\n for i in range(node.arity):\\n node.children.append(cls.generate(\\n rng, get_nodes, tree_type, depth-1, force_types_, node))\\n return node\",\n \"def get_max_depth(self):\\n return self.MAX_DEPTH\",\n \"def get_depth(self, current, n):\\n if current is not None:\\n return max(self.get_depth(current.left, n + 1), self.get_depth(current.right, n + 1))\\n else:\\n return n\",\n \"def generate_jungle(variable_names, dist_func, num_levels=2, **kwargs):\\n shuffle(variable_names)\\n num_vars = len(variable_names)\\n\\n edges = []\\n for i in range(num_vars):\\n level = int(np.log2(i+1))\\n idx = i + 1 - 2 ** level\\n for l in range(1, num_levels+1):\\n gl = (2**l) * idx + 2 ** (level + l) - 1\\n edges += [[i, gl + j] for j in range(2**l)]\\n edges = [e for e in edges if max(e) < num_vars]\\n\\n return graph_from_edges(variable_names, dist_func, edges)\",\n \"def build_tree_helper(x, n, d, max_d, name=defaultname):\\n ret = {}\\n ret['name'] = name(x)\\n if d == max_d:\\n return ret\\n children = collatz.children(x, n)\\n if x == 1:\\n children = children[1:]\\n if children:\\n ret['children'] = [build_tree_helper(x, n, d + 1, max_d, name) for x in children]\\n return ret\",\n \"def max_depth(self) -> int:\\n return pulumi.get(self, \\\"max_depth\\\")\",\n \"def init_population(pop_size):\\n population = []\\n for md in range(2, MAX_DEPTH - 1):\\n for _ in range(int(pop_size / 2)):\\n t = Tree()\\n t.random_tree(grow=True, max_depth=md) # Grow method \\n population.append(t)\\n for _ in range(int(pop_size / 2)):\\n t = Tree()\\n t.random_tree(grow=False, max_depth=md) # Full method\\n population.append(t)\\n return population\",\n \"def func_randomint(exp_parameter=3, root_parameter=1):\\n sup = Word.objects.all().order_by(\\\"-id\\\")[0].id - 1\\n randfloat = random.uniform(0,sup)\\n randint = math.floor(exp_parameter*(sup**(sup/randfloat)+1) + root_parameter(-1*math.sqrt(sup*randfloat)+sup)/2)\\n return randint\",\n \"def depth_limited_search(initial_state, goal_state, limit):\\n\\n return recursive_dls(createRootNode(initial_state), goal_state, limit)\",\n \"def DEFAULT_MAX_DEPTH(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def fill_depth(depth):\\n ht, wd = depth.shape\\n x, y = np.meshgrid(np.arange(wd), np.arange(ht))\\n xx = x[depth > 0].astype(np.float32)\\n yy = y[depth > 0].astype(np.float32)\\n zz = depth[depth > 0].ravel()\\n return interpolate.griddata((xx, yy), zz, (x, y), method='nearest')\",\n \"def generate_tree(self, max_depth = None):\\n\\n if max_depth is None:\\n max_depth = self.tree.max_depth\\n else:\\n max_depth -= 1\\n if max_depth == 0:\\n return\\n self.generate_children()\\n if self.tree.remove:\\n os.unlink(self.source_filename)\\n for child in self.children:\\n if child.count > self.tree.max_count:\\n child.generate_tree(max_depth)\",\n \"def uniform_cost(initial_state, dimension=3):\\n\\n\\tdef add_cost(node):\\n\\t\\tnode.cost = node.depth\\n\\n\\treturn search(initial_state, Frontier(PriorityQueue), dimension, cost_fn=add_cost)\",\n \"def bestAtDepthL(self,depth=0,scoreFunc=None) :\\n scoreFunc = scoreFunc if scoreFunc != None else lambda g : g.leafScore()\\n max_score = ACG.minf\\n max_L = None\\n for g in self.L() :\\n if depth > 0 :\\n g = g.bestAtDepthR(depth=depth-1,scoreFunc=scoreFunc)\\n score = scoreFunc(g)\\n if score > max_score :\\n max_score = score\\n max_L = g\\n return max_L if max_L != None else self\",\n \"def buildTree(rows, maxDepth = None, scoref=entropy, depth = 0):\\n #A base condition for the recursion. Check if this branch of a split has no data\\n if len(rows)==0:\\n return decisionNode( )\\n newDepth = depth + 1 #Calculate the depth of the next split.\\n #Check if the depth at the next split is greater than a maximum specified depth\\n if (maxDepth == 0 or maxDepth) and (newDepth > maxDepth): \\n return decisionNode(results=__uniqueCounts(rows)) #If so, stop splitting.\\n current_score=scoref(rows) #Calculate the current value of the score function.\\n # Set up some variables to track the best criteria\\n best_gain=0.0 #Initialize a value for the best gain from all possible splits\\n best_criteria=None #Initialize a variable for the best column to split on\\n best_sets=None #Initialize a variable for the best split's true and false data.\\n\\n #Count the number of columns in the row, minus the results column \\n column_count=len(rows[0])-1\\n for col in range(0,column_count): #Iterate over all the columns of the data\\n #Generate the list of different values in this column\\n column_values={} #Initialize a dictionary to store the column values\\n for row in rows: \\n #Iterate over each row, adding a key in the dict for each observed value\\n column_values[row[col]]=1\\n # Divide the dataset on each value in this column.\\n for value in column_values.keys( ):\\n (set1,set2)=__divideset(rows,col,value)\\n #Calculate the fraction of data in the true branch\\n p=float(len(set1))/len(rows) \\n #Calculate the gain on the chosen score function using this split.\\n gain=current_score-p*scoref(set1)-(1-p)*scoref(set2) \\n #Check if this split provides a better gain than the best previous split\\n if gain>best_gain and len(set1)>0 and len(set2)>0:\\n best_gain=gain\\n best_criteria=(col,value)\\n best_sets=(set1,set2)\\n # Recursively create the subbranches\\n if best_gain>0:\\n trueBranch=buildTree(best_sets[0], maxDepth = maxDepth, depth = newDepth)\\n falseBranch=buildTree(best_sets[1], maxDepth = maxDepth, depth = newDepth)\\n return decisionNode(col=best_criteria[0],value=best_criteria[1],\\n tb=trueBranch,fb=falseBranch)\\n else:\\n return decisionNode(results=__uniqueCounts(rows))\",\n \"def apply_depth_multiplier(d: Union[int, Sequence[Any]],\\n depth_multiplier: float):\\n if isinstance(d, int):\\n return int(d * depth_multiplier)\\n else:\\n return [apply_depth_multiplier(x, depth_multiplier) for x in d]\",\n \"def recursive_mapWithDepth(x, function, apply_depth):\\n if count_nest(x) == apply_depth:\\n return function(x)\\n else:\\n if isinstance(x, (list, tuple, set)):\\n t = type(x)\\n return t(map(lambda e: recursive_mapWithDepth(e, function, apply_depth), x))\",\n \"def progressive_deepening(state, heuristic_fn=always_zero, depth_limit=INF,\\n maximize=True) :\\n anytime_value = AnytimeValue() # TA Note: Use this to store values.\\n depth = 0\\n while depth<=depth_limit-1:\\n depth+=1\\n best_option=minimax_search_alphabeta(state,-INF,INF, heuristic_fn=heuristic_fn,depth_limit=depth, maximize=True)\\n anytime_value.set_value(best_option)\\n return anytime_value\",\n \"def depth_from_indentation(function):\\n def wrap(start, values):\\n #print 'Depth %d | %d %s' %(self._depth, start, values)\\n #self._depth = start\\n self._current_node = function(values)\\n #print self._current_node\\n return ''\\n\\n return wrap\",\n \"def get_depths(self, variables):\\n\\n return [0.]\",\n \"def build_tree(self, prefix, depth):\\n for count, function in [[self.n_files, self.make_file],\\n [self.n_children, self.make_child_recurse],\\n [self.n_symlinks, self.make_symlink]]:\\n for i in range(count):\\n if not self.can_continue():\\n return\\n name = os.path.join(prefix, self.name_gen.next())\\n function(name, depth)\",\n \"def run(self, fitness_function):\\r\\n return run_helper(depth, fitness_function, 0, 0, 0) # fixme\\r\",\n \"def generate_recursive_rules(limit):\\n\\n return [\\n # 8: 42 | 42 8 - recursion creates the pattern: 42 | 42 42 | 42 42 42 etc...\\n f\\\"8: {' | '.join([('42 ' * x).strip() for x in range(1, limit + 1)])}\\\",\\n # 11: 42 31 | 42 11 31 - recursion creates the pattern: 42 31 | 42 42 31 31 | 42 42 42 31 31 31 etc...\\n f\\\"11: {' | '.join([('42 ' * x).strip() + ' ' + ('31 ' * x).strip() for x in range(1, limit + 1)])}\\\"\\n ]\",\n \"def make_anonymous_factorial():\\n\\t# u need to use a helper function if your lambda statement does\\n\\t# not have a name\\n\\t# fact = lambda n: 1 if n == 1 else mul(n, fact(sub(n, 1)))\\n\\tdef recursive2(f, n):\\n\\t\\treturn f(f, n)\\n\\n\\tdef recursive(n):\\n\\n\\t\\treturn recursive2((lambda rec, n: 1 if n == 1 else mul(n, rec(sub(n, 1)))), n)\\n\\n\\treturn recursive\",\n \"def _random_walk(shape, nonlinearity, dtype=dtypes.float32, seed=None,\\n name=\\\"random_walk\\\"):\\n assert len(shape) == 2, \\\"Random Walk initialization only supports 2D tensors.\\\"\\n num_inputs = shape[0]\\n if nonlinearity == math_ops.tanh:\\n # No real formula for this case yet, but this works well for many\\n # layer widths.\\n rwg = 1.13\\n elif nonlinearity == array_ops.identity:\\n rwg = math.exp(1.0 / (2.0 * num_inputs))\\n elif nonlinearity == nn_ops.relu:\\n rwg = math.sqrt(2.0) * math.exp(1.2 / (max(num_inputs, 6) - 2.4))\\n else:\\n assert False, \\\"Unsupported nonlinearity for Random Walk initialization.\\\"\\n\\n mean = 0.0\\n stddev = rwg / math.sqrt(float(num_inputs))\\n\\n return random_ops.random_normal(shape, mean=mean, stddev=stddev, dtype=dtype,\\n seed=seed, name=name)\",\n \"def factorial(n): \\n def base(): \\n return 1 \\n def recursive(): \\n return n * factorial(n-1)\\n return ____________________________________________________________________\",\n \"def DEFAULT_MIN_DEPTH(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def _max_depth(self):\\n max_depth = 0\\n for node, data in self.traverse():\\n max_depth = max(max_depth, data['level'])\\n return max_depth\",\n \"def build_tree(self, df=None, tree=None, depth=0):\\n if df is None:\\n df = self.df\\n target = self.target\\n\\n node = self.get_lowest_entropy_feature(df)\\n if not node:\\n print(\\\"Pure solution not possible in current branch...\\\")\\n return tree\\n variables = df[node].unique()\\n\\n if tree is None: \\n tree = {}\\n tree[node] = {}\\n\\n for value in variables:\\n subtable = df[df[node] == value].reset_index(drop=True)\\n inner_variables, counts = np.unique(subtable[target], return_counts=True) \\n \\n if len(counts) == 1:\\n tree[node][value] = inner_variables[0] \\n elif depth >= self.max_depth:\\n return tree \\n else:\\n depth += 1 \\n tree[node][value] = self.build_tree(df=subtable, depth=depth)\\n \\n return tree\",\n \"def generate_full(variable_names, dist_func, **kwargs):\\n return generate_random_graph(variable_names, dist_func, edge_prob=1.0)\",\n \"def __init__(self, d=1):\\r\\n self.depth = d\",\n \"def max_depth_forest(self):\\n return max(x.tree_.max_depth for x in self.result.estimators_)\",\n \"def leafEvaluation(self, state):\\n\\n \\\"\\\"\\\"\\n Use random generated values for now\\n \\\"\\\"\\\"\\n z = np.random.randint(2)\\n v = random.uniform(0, 1) \\n return (1-LAMBDA) * v + LAMBDA * z\",\n \"def min_depth(t):\\n if is_leaf(t):\\n return 0\\n h = float('inf')\\n for b in branches(t):\\n # Still works fine!\\n h = min(h, 1 + min_depth(b))\\n return h\",\n \"def miniMax(self,state,depth=0):\\n \\n #print(\\\"NextState (depth \\\"+str(depth)+\\\"):\\\")\\n #print(\\\"Action: \\\"+state.get_action())\\n \\n if state in self.__explored:\\n return self.__explored[state.get_hashable_state()]\\n \\n if state.is_end_state() or depth >= (self.__max_depth - 1):\\n self.__explored[state.get_hashable_state()] = state.get_utility_value()\\n return state.get_utility_value() #Return terminal state's utility value\\n \\n is_max_turn = state.get_max_turn()\\n childList = state.get_successors()\\n \\n if is_max_turn:\\n utility = float(\\\"-inf\\\")\\n for c in childList:\\n utility = max(utility,self.miniMax(c, depth+1))\\n self.__explored[state.get_hashable_state()] = utility\\n return utility\\n else:\\n utility = float(\\\"inf\\\")\\n for c in childList:\\n utility = min(utility,self.miniMax(c, depth+1))\\n self.__explored[state.get_hashable_state()] = utility\\n return utility\",\n \"def fn(i, n):\\n if len(stack) > 0 and stack[-1] <= n: ans.append(stack + [n])\\n for ii in range(i, len(factors)):\\n if n % factors[ii] == 0: \\n stack.append(factors[ii])\\n fn(ii, n//factors[ii])\\n stack.pop()\",\n \"def reset_max_depth(self) -> None:\\n # The max depth is now calculated on the fly, so this is a no-op.\\n pass\",\n \"def get_graph_func(name):\\n if name == \\\"chain\\\":\\n f = generate_chain\\n elif name == \\\"bidiag\\\":\\n f = generate_bidiag\\n elif name == \\\"collider\\\":\\n f = generate_collider\\n elif name == \\\"jungle\\\":\\n f = generate_jungle\\n elif name == \\\"full\\\":\\n f = generate_full\\n elif name == \\\"regular\\\":\\n f = generate_regular_graph\\n elif name == \\\"random\\\":\\n f = generate_random_graph\\n elif name.startswith(\\\"random_max_\\\"): # Random graph with maximum number of parents\\n max_parents = int(name.split(\\\"_\\\")[-1])\\n f = lambda *args, **kwargs: generate_random_graph(*args, max_parents=max_parents, **kwargs)\\n else:\\n f = generate_random_graph\\n return f\",\n \"def test_MaxDepth_SimpleTree(self):\\n\\n root = TreeNode(0)\\n root.addLeft(1)\\n root.addRight(5)\\n root.left.addLeft(2)\\n root.left.addRight(3)\\n root.left.right.addRight(4)\\n root.right.addRight(6)\\n\\n self.assertEqual(findMaxDepthDFS(root),3)\",\n \"def max_depth(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_depth\\\")\",\n \"def generate_level(level):\\n seed = level * 69420 # multiply by 69420 to not have the seeds too close to each other\\n random.seed(seed)\\n dimensions = get_map_size(level)\\n level_map = np.full(dimensions, -1)\\n while -1 in level_map:\\n choice = random.choice(np.argwhere(level_map == -1))\\n next_index = (choice[0], choice[1])\\n # get indices of the tiles next to the current index\\n left_index, up_index, right_index, down_index = get_direction_indices(next_index)\\n left = tile_needs_connection(left_index, level_map, has_connection_right)\\n up = tile_needs_connection(up_index, level_map, has_connection_down)\\n right = tile_needs_connection(right_index, level_map, has_connection_left)\\n down = tile_needs_connection(down_index, level_map, has_connection_up)\\n level_map[next_index] = get_tile(left, up, right, down)\\n return un_solve(level_map)\",\n \"def __init__(self, recursion_depth: int, noise_depth: int, scale: float,\\n snow_height: float = None, tree_height: float = None,\\n color_offset_heightmap: \\\"Terrain\\\" = None):\\n self._depth = recursion_depth\\n self._noise_depth = noise_depth\\n self._scale = scale\\n self._snow_height = snow_height\\n self._tree_height = tree_height\\n self._color_offset_heightmap = color_offset_heightmap\\n self._height_cache = {}\\n \\n self._only_heightmap = snow_height is None or tree_height is None\\n if self._only_heightmap:\\n self._heightmap = {}\\n else:\\n self._triangles = []\\n \\n # generate the terrain recursively\\n self._fractal_triangle((-1,0,math.sqrt(3)), (1,0,math.sqrt(3)), (0,0,0), depth=self._depth)\",\n \"def fn(n):\\n if n == 1: return 1\\n return max(max(i, fn(i))*max(n-i, fn(n-i)) for i in range(1, n//2+1))\",\n \"def disp_to_depth(disp, min_depth, max_depth):\\n min_disp = 1 / max_depth\\n max_disp = 1 / min_depth\\n scaled_disp = min_disp + (max_disp - min_disp) * disp\\n depth = 1 / scaled_disp\\n return scaled_disp, depth\",\n \"def lvl_algo(next_level):\\n total_xp_needed = (next_level * next_level)\\n return total_xp_needed\",\n \"def resolve_depth(self: models.FeatureDetails, info, **kwargs):\\n min = self.data.get(\\\"berth_min_depth\\\")\\n max = self.data.get(\\\"berth_max_depth\\\")\\n\\n if min is None:\\n return None\\n\\n return {\\n \\\"min\\\": min,\\n \\\"max\\\": max,\\n }\",\n \"def reproduce(self):\\n\\n def compute_seeds(fitness):\\n \\\"\\\"\\\" Computes the number of seeds given a fitness value. \\\"\\\"\\\"\\n\\n seeds = (fitness-min_fitness) / (max_fitness-min_fitness) * \\\\\\n (self.max_seeds-self.min_seeds) + self.min_seeds\\n\\n return round(seeds)\\n\\n # evaluates max and min fitness for current year\\n max_fitness = max(tree[0] for tree in self.population)\\n min_fitness = min(tree[0] for tree in self.population)\\n\\n # computes the number of seeds produced per tree\\n for tree in self.population:\\n tree[1].seeds = int(compute_seeds(tree[0]))\",\n \"def BiasedTree(N,alpha=0.): \\n free = sample(range(N),N)\\n nodes = [free.pop()]\\n links = []\\n K = np.zeros((N,))\\n K[nodes[0]]=1.\\n while free:\\n newn = free.pop()\\n K[newn]=1.\\n p = K[np.array(nodes)]**alpha\\n p = p/np.sum(p)\\n mother = np.random.choice(nodes,p=p)\\n K[mother] += 1.\\n nodes.append(newn)\\n links.append((mother,newn))\\n return nx.DiGraph(links)\",\n \"def hash_with_depth_int(func: HashFuncT) -> HashFuncT:\\n\\n @wraps(func)\\n def hashing_func(key, depth=1):\\n \\\"\\\"\\\"wrapper function\\\"\\\"\\\"\\n res = []\\n tmp = func(key, 0)\\n res.append(tmp)\\n for idx in range(1, depth):\\n tmp = func(f\\\"{tmp:x}\\\", idx)\\n res.append(tmp)\\n return res\\n\\n return hashing_func\",\n \"def depth(self):\\n if self.size == 0:\\n return 0\\n return int(math.log(self.size, 2)) + 1\",\n \"def factor(n):\\n from random import randrange\\n while True:\\n i = 1\\n x = randrange(0, n)\\n y = x\\n while True:\\n i += 1\\n x = ((x ** 2) - 1) % n\\n d = gcd(y - x, n)\\n if d != 1 and d != n:\\n return d\\n if i > 10000:\\n break\",\n \"def DEFAULT_MAX_DEPTH_DIFF(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def create_binary_tree(depth=3):\\n # The only node is root\\n max_nodes, nodes = 2 ** depth - 1, 1\\n queue = Queue()\\n val = IntGenerator()\\n root = Node(val=next(val))\\n\\n queue.enqueue(root)\\n while nodes + 2 <= max_nodes:\\n current = queue.dequeue()\\n\\n # Create child nodes until total num is le max_nodes\\n # for specified length in binary tree\\n if nodes + 2 <= max_nodes: # tree will have +2 nodes after creating children\\n current.left = Node(val=next(val))\\n current.right = Node(val=next(val))\\n queue.enqueue(current.left)\\n queue.enqueue(current.right)\\n nodes += 2\\n\\n return root\",\n \"def get_min_depth(l_k):\\n return max(l_k.values())\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def fn(n):\\n if n == 1: return [TreeNode()]\\n ans = []\\n for nn in range(1, n, 2): \\n for left in fn(nn):\\n for right in fn(n-1-nn): \\n ans.append(TreeNode(left=left, right=right))\\n return ans\",\n \"def make_tree(self, X_subset, y_subset, depth):\\n \\n # YOUR CODE HERE\\n #self.depth += 1\\n if depth < self.max_depth and X_subset.shape[0] >= self.min_samples_split:\\n \\n best_feature, best_threshold = self.choose_best_split(X_subset, y_subset)\\n print('depth = {}, size parent node = {}'.format(depth, len(X_subset)))\\n print('best_feature = {}, best_threshold = {}'.format(best_feature, best_threshold))\\n new_node = Node(best_feature, best_threshold)\\n \\n left_child, right_child = self.make_split(best_feature, best_threshold, X_subset, y_subset)\\n new_node.left_child = self.make_tree(*left_child, depth+1)\\n new_node.right_child = self.make_tree(*right_child, depth+1)\\n \\n else: # we have a leaf\\n new_node = Node(-1, -1) # We flag leaf nodes by setting feature_index and threshold to -1\\n new_node.value = self.predicted_values(y_subset)\\n \\n if self.classification:\\n new_node.proba = np.mean(y_subset, axis=0)\\n \\n # We reduce the depth to compensate for the two calls to self.depth += 1 we make on\\n # the same level for left_child and right_child.\\n #self.depth -= 1\\n \\n return new_node\",\n \"def run(self, max_depth):\\n while len(self.stack) > 0:\\n state = self.get_next_state()\\n\\n if state.is_solution():\\n self.solutions.append(state.moves)\\n\\n if len(state.moves) < max_depth:\\n self.create_children(state)\\n\\n self.archive[state.get_tuple()] = len(state.moves)\\n\\n # sort solutions best to worst\\n self.solutions.sort(key=len)\\n\\n if self.solutions:\\n return self.solutions[0]\\n\\n print(\\\"This depth is not sufficient.\\\")\\n return []\",\n \"def depth(self):\\n return self._max_depth\",\n \"def depth_breadth_eval_function(individual, test_data, truth_data, name=None):\\r\\n # Compute the string representation of the individual\\r\\n string_rep = str(individual)\\r\\n # Generate array for appearances of ARG0\\r\\n data_appearances = [match.start() for match in re.finditer('ARG0', string_rep)]\\r\\n # Computed by counting occurrences of GTMOEPDataPair per primitive\\r\\n # Let's make this dynamic in the future by querying all functions\\r\\n max_breadth = 3.0\\r\\n # Tradeoff formula\\r\\n return individual.height - len(data_appearances)/(max_breadth**individual.height + 1.0)\",\n \"def constructTree(n, board, player, action, possible_position=None):\\r\\n max_branch_num = 7\\r\\n # 限制分支因子，不考虑过多局面\\r\\n node = Node(player=player, action=action)\\r\\n successors = []\\r\\n if possible_position == None:\\r\\n # 没有给定可选位置，我们自己现场计算\\r\\n logDebug(\\\"Point 1.\\\")\\r\\n possible_position = possible_pos(board)\\r\\n logDebug(\\\"Point 2.\\\")\\r\\n if possible_position == None:\\r\\n # 真的没有可选位置，😅\\r\\n return None\\r\\n\\r\\n is_critical = critical(board)\\r\\n new_board = copy.deepcopy(board)\\r\\n if is_critical == '4_1':\\r\\n # 我方四子连珠\\r\\n for pos in possible_position:\\r\\n new_board[pos[0]][pos[1]] = player\\r\\n new_special_pattern = is_special_pattern(board = new_board, player = player)\\r\\n old_special_pattern = is_special_pattern(board = board, player = player)\\r\\n if new_special_pattern[\\\"H4\\\"] != old_special_pattern[\\\"H4\\\"] or new_special_pattern[\\\"C4\\\"] != old_special_pattern[\\\"C4\\\"]:\\r\\n node = Node(player=player, action=action)\\r\\n successors = []\\r\\n successors.append(Node(player = 3-player, isLeaf = True, value = 1000000000, action = pos))\\r\\n # action 是到达这个节点，我们落子的位置\\r\\n node.successor = successors\\r\\n return node\\r\\n \\r\\n top_position = []\\r\\n\\r\\n if n == 1:\\r\\n # 树的深度只有一层\\r\\n if len(possible_position) < max_branch_num:\\r\\n for pos in possible_position:\\r\\n # :pos: 坐标 (x, y)\\r\\n # :prob_position: 可选位置，坐标的列表\\r\\n copy_board = copy.deepcopy(board)\\r\\n # 棋盘当前状态的拷贝（或许可以直接用深拷贝拷贝列表，不用一个一个位置去循环）\\r\\n copy_board[pos[0]][pos[1]] = player\\r\\n # 在当前位置放置当前棋手的棋子\\r\\n # player == 1 or 2\\r\\n temp_value = board_score(copy_board)\\r\\n # :util::board_evaluation:返回当前整个棋局的评分\\r\\n # 大评分对我们好，小评分对对方好\\r\\n # print temp_value\\r\\n # successors.append(Node(player=3-player, isLeaf=True, value=board_evaluation(board_copy), action=pos))\\r\\n successors.append(Node(player=3 - player, isLeaf=True, value=temp_value, action=pos))\\r\\n # 一层搜索树，下一个节点就是叶节点\\r\\n # player = 3 - player 完成棋手轮换\\r\\n # TODO: need to delete\\r\\n else:\\r\\n # 如果分支因子过大，只考虑落子后局面最好的前k个\\r\\n for pos in possible_position:\\r\\n board_copy = copy.deepcopy(board)\\r\\n board_copy[pos[0]][pos[1]] = player\\r\\n temp_value = board_score(board_copy)\\r\\n # :util::board_evaluation: 返回当前整个棋局的评分\\r\\n top_position.append(temp_value)\\r\\n temp = copy.deepcopy(top_position[:])\\r\\n # deepcopy\\r\\n temp.sort(reverse=True)\\r\\n # 从大到小排列\\r\\n for v in temp[0:max_branch_num]:\\r\\n pos = possible_position[top_position.index(v)]\\r\\n successors.append(Node(player=3 - player, isLeaf=True, value=v, action=pos))\\r\\n # 一层，后继节点是叶节点\\r\\n\\r\\n else:\\r\\n # 多层搜索树🌲\\r\\n if len(possible_position) < max_branch_num:\\r\\n # i = 0\\r\\n for pos in possible_position:\\r\\n # i += 1\\r\\n # print pos, 'else called', i\\r\\n copy_board = copy.deepcopy(board)\\r\\n copy_board[pos[0]][pos[1]] = player\\r\\n # print board_copy\\r\\n successors.append(constructTree(n-1, copy_board, 3-player, pos, update_possible_pos(pos, possible_position)))\\r\\n # 递归的调用\\r\\n else:\\r\\n for pos in possible_position:\\r\\n board_copy = copy.deepcopy(board)\\r\\n board_copy[pos[0]][pos[1]] = player\\r\\n top_position.append(board_score(board_copy))\\r\\n temp = copy.deepcopy(top_position[:])\\r\\n temp.sort(reverse=True)\\r\\n for v in temp[0:max_branch_num]:\\r\\n pos = possible_position[top_position.index(v)]\\r\\n copy_board = copy.deepcopy(board)\\r\\n copy_board[pos[0]][pos[1]] = player\\r\\n successors.append(constructTree(n - 1, copy_board, 3 - player, pos, update_possible_pos(pos, possible_position)))\\r\\n node.successor = successors\\r\\n return node\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.89440006","0.87607706","0.8079794","0.801927","0.79594904","0.78108656","0.7484326","0.64881915","0.6170833","0.6011024","0.5912187","0.5898084","0.5888185","0.57918245","0.5591146","0.55420274","0.550629","0.54398507","0.541542","0.532502","0.53238696","0.52883667","0.5249913","0.5228356","0.5183749","0.51636136","0.5153706","0.5150617","0.51355135","0.5119607","0.5109263","0.5109122","0.5077665","0.5064582","0.50597054","0.5047417","0.50358886","0.5028293","0.50140184","0.49982217","0.49921247","0.4982184","0.49819088","0.49818036","0.49654913","0.49517533","0.49456277","0.4928413","0.4920878","0.4917907","0.49108148","0.4907825","0.49017265","0.49013618","0.4893095","0.4876184","0.48698708","0.48674977","0.4859411","0.48543668","0.48492172","0.48438716","0.4833745","0.4829238","0.48272064","0.48156098","0.4813459","0.48035824","0.48023623","0.4788605","0.4788456","0.47869802","0.47829178","0.47825477","0.4781968","0.47743264","0.4762174","0.47559255","0.4752019","0.47383314","0.47348145","0.47331563","0.47324964","0.47164452","0.4714662","0.46983856","0.46981734","0.46918046","0.46901956","0.46900243","0.46870938","0.4685402","0.4681371","0.4681371","0.46776873","0.46773934","0.46761328","0.4667748","0.46668848","0.46565714"],"string":"[\n \"0.89440006\",\n \"0.87607706\",\n \"0.8079794\",\n \"0.801927\",\n \"0.79594904\",\n \"0.78108656\",\n \"0.7484326\",\n \"0.64881915\",\n \"0.6170833\",\n \"0.6011024\",\n \"0.5912187\",\n \"0.5898084\",\n \"0.5888185\",\n \"0.57918245\",\n \"0.5591146\",\n \"0.55420274\",\n \"0.550629\",\n \"0.54398507\",\n \"0.541542\",\n \"0.532502\",\n \"0.53238696\",\n \"0.52883667\",\n \"0.5249913\",\n \"0.5228356\",\n \"0.5183749\",\n \"0.51636136\",\n \"0.5153706\",\n \"0.5150617\",\n \"0.51355135\",\n \"0.5119607\",\n \"0.5109263\",\n \"0.5109122\",\n \"0.5077665\",\n \"0.5064582\",\n \"0.50597054\",\n \"0.5047417\",\n \"0.50358886\",\n \"0.5028293\",\n \"0.50140184\",\n \"0.49982217\",\n \"0.49921247\",\n \"0.4982184\",\n \"0.49819088\",\n \"0.49818036\",\n \"0.49654913\",\n \"0.49517533\",\n \"0.49456277\",\n \"0.4928413\",\n \"0.4920878\",\n \"0.4917907\",\n \"0.49108148\",\n \"0.4907825\",\n \"0.49017265\",\n \"0.49013618\",\n \"0.4893095\",\n \"0.4876184\",\n \"0.48698708\",\n \"0.48674977\",\n \"0.4859411\",\n \"0.48543668\",\n \"0.48492172\",\n \"0.48438716\",\n \"0.4833745\",\n \"0.4829238\",\n \"0.48272064\",\n \"0.48156098\",\n \"0.4813459\",\n \"0.48035824\",\n \"0.48023623\",\n \"0.4788605\",\n \"0.4788456\",\n \"0.47869802\",\n \"0.47829178\",\n \"0.47825477\",\n \"0.4781968\",\n \"0.47743264\",\n \"0.4762174\",\n \"0.47559255\",\n \"0.4752019\",\n \"0.47383314\",\n \"0.47348145\",\n \"0.47331563\",\n \"0.47324964\",\n \"0.47164452\",\n \"0.4714662\",\n \"0.46983856\",\n \"0.46981734\",\n \"0.46918046\",\n \"0.46901956\",\n \"0.46900243\",\n \"0.46870938\",\n \"0.4685402\",\n \"0.4681371\",\n \"0.4681371\",\n \"0.46776873\",\n \"0.46773934\",\n \"0.46761328\",\n \"0.4667748\",\n \"0.46668848\",\n \"0.46565714\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7593185"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":93695,"cells":{"query":{"kind":"string","value":"Evaluate the random function f with inputs x,y Representation of the function f is defined in the assignment writeup"},"document":{"kind":"string","value":"def evaluate_random_function(f, x, y):\n # this section actually evaluates the functions \n\n if f[0] == \"x\":\n return x \n elif f[0] == \"y\":\n return y\n elif f[0] == \"sin_pi\":\n return math.sin(math.pi*evaluate_random_function(f[1], x, y ))\n elif f[0] == \"cos_pi\":\n return math.cos(math.pi*evaluate_random_function(f[1], x, y ))\n elif f[0] == \"prod\":\n return evaluate_random_function(f[1] , x , y ) * evaluate_random_function(f[2] , x , y )\n elif f[0] == \"avg\":\n return (evaluate_random_function(f[1] , x , y ) + evaluate_random_function(f[2] , x , y)) / 2.0\n elif f[0] == \"squ\":\n return evaluate_random_function(f[1] , x , y ) * evaluate_random_function(f[1] , x , y ) \n elif f[0] == \"cir\":\n return ((evaluate_random_function(f[1] , x , y )**2 + evaluate_random_function(f[2] , x , y)) **2 )**0.5\n elif f[0] == \"sms\":\n return (evaluate_random_function(f[1] , x , y )**2 - evaluate_random_function(f[2] , x , y)) **2 \n\n #elif f == [\"sinpi\"]:\n # return math.sin(math.pi*)"},"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 evaluate_random_function(f, x, y):\n\n # your code goes here","def evaluate_random_function(f, x, y):\n\n if f[0] == \"prod\":\n return evaluate_random_function(f[1],x,y) * evaluate_random_function(f[2],x,y)\n elif f[0] == \"sin_pi\":\n return sin(evaluate_random_function(f[1],x,y) * pi)\n elif f[0] == \"cos_pi\":\n return cos(evaluate_random_function(f[1],x,y) * pi)\n elif f[0] == \"x\":\n return x\n else:\n return y","def evaluate_random_function(f, x, y):\n if (f[0]=='x'):\n return X(x,y)\n elif (f[0]=='y'):\n return Y(x,y)\n elif (f[0]=='sin_pi'):\n return sin_pi(evaluate_random_function(f[1],x,y))\n elif (f[0]=='cos_pi'):\n return cos_pi(evaluate_random_function(f[1],x,y))\n elif (f[0]=='times'):\n return times(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\n elif (f[0]=='root'):\n return root(evaluate_random_function(f[1],x,y))\n elif (f[0]=='square'):\n return square(evaluate_random_function(f[1],x,y))","def evaluate_random_function(f, x, y):\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\n if f[0] == \"x\":\n return x\n elif f[0] == \"y\":\n return y\n\n # Kindof effort instensive way to do this, but it allows for a\n # changeable list of functions with less effort\n else:\n if f[0] == elementary_func[0]:\n first_argument = evaluate_random_function(f[1], x, y)\n second_argument = evaluate_random_function(f[2], x, y)\n return first_argument * second_argument\n elif f[0] == elementary_func[1]:\n first_argument = evaluate_random_function(f[1], x, y)\n second_argument = evaluate_random_function(f[2], x, y)\n return .5*(first_argument + second_argument)\n elif f[0] == elementary_func[2]:\n argument = evaluate_random_function(f[1], x, y)\n ans = math.cos(math.pi * argument)\n return ans\n elif f[0] == elementary_func[3]:\n argument = evaluate_random_function(f[1], x, y)\n ans = math.sin(math.pi * argument)\n return ans\n elif f[0] == elementary_func[4]:\n argument = evaluate_random_function(f[1], x, y)\n return argument**2\n elif f[0] == elementary_func[5]:\n argument = evaluate_random_function(f[1], x, y)\n return math.sqrt(math.fabs(argument))","def evaluate_random_function(f, x, y):\n if len(f)==1: #check base case\n # print f[0],\"BASE\"\n if f[0]==\"x0\":\n return x0(x,y)\n if f[0]==\"y0\":\n return y0(x,y)\n if f[0]==\"prod\":\n return prod(x,y)\n if f[0]==\"avg\":\n return avg(x,y)\n if f[0]==\"square\":\n return square(x,y)\n if f[0]==\"squarert\":\n return squarert(x,y)\n return 'error1'\n #done checking base case. Only need to provide for possible base cases\n # print f[0], \"NORMAL\"\n if f[0]==\"x0\":\n return x0(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\n if f[0]==\"y0\":\n return y0(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\n if f[0]==\"prod\":\n return prod(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\n if f[0]==\"avg\":\n return avg(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\n if f[0]==\"cos_pi\":\n return cos_pi(evaluate_random_function(f[1],x,y))\n if f[0]==\"sin_pi\":\n return sin_pi(evaluate_random_function(f[1],x,y))\n if f[0]==\"square\":\n return square(evaluate_random_function(f[1],x,y))\n if f[0]==\"squarert\":\n return squarert(evaluate_random_function(f[1],x,y))\n \n return 'error'","def evaluate_random_function(f, x, y, t=0):\n if f[0] == \"x\":\n return x\n elif f[0] == \"y\":\n return y\n elif f[0] == \"t\":\n return t\n elif f[0] == \"prod\": \n return evaluate_random_function(f[1], x, y, t)*evaluate_random_function(f[2], x, y, t)\n elif f[0] == \"avg\":\n return 0.5*(evaluate_random_function(f[1], x, y, t)+evaluate_random_function(f[2], x, y, t))\n elif f[0] == \"cos_pi\":\n return cos(pi*evaluate_random_function(f[1], x, y, t))\n elif f[0] == \"sin_pi\":\n return sin(pi*evaluate_random_function(f[1], x, y, t))\n elif f[0] == \"hypot\":\n first = evaluate_random_function(f[1], x, y, t)\n second = evaluate_random_function(f[1], x, y, t)\n tester = first*abs(first) + second*abs(second)\n if tester >= 0:\n return sqrt(first**2 + second**2)/sqrt(2)\n else:\n return -sqrt(first**2 + second**2)/sqrt(2)\n elif f[0] == \"pow\":\n val = evaluate_random_function(f[1], x, y, t)\n if val >= 0:\n return 1-val**val\n else:\n return -(1-abs(val)**abs(val))\n elif f[0] == \"add\":\n first = evaluate_random_function(f[1], x, y, t)\n second = evaluate_random_function(f[1], x, y, t)\n if first + second > 1:\n return (1 - (first+second) + 1)\n elif first + second < -1:\n return (-2 - (first+second))\n else:\n return (first + second)\n elif f[0] == \"cube\":\n return evaluate_random_function(f[1], x, y, t)**3","def eval_rand_func(f, a, b):\n\n\tif f[0] == 'prod':\n\t\treturn eval_rand_func(f[1], a, b) * eval_rand_func(f[2], a, b)\n\n\telif f[0] == 'cos_pi':\n\t\treturn math.cos(math.pi * eval_rand_func(f[1], a, b))\n\n\telif f[0] == 'sin_pi':\n\t\treturn math.sin(math.pi * eval_rand_func(f[1], a, b))\n\n\telif f[0] == 'A':\n\t\treturn a\n\t\t\n\telse:\n\t\treturn b","def evaluate_random_function(f, x, y, lambdas):\n if lambdas:\n return f(x, y)\n\n if len(f) == 3:\n x2 = evaluate_random_function(f[1], x, y, lambdas)\n y2 = evaluate_random_function(f[2], x, y, lambdas)\n\n for i in range(len(funcs)):\n if f[0] == funcs[i][0]:\n return funcs[i][1](x2, y2)\n else:\n for i in range(len(funcs)):\n if f[0] == funcs[i][0]:\n return funcs[i][1](x, y)","def eval_func(f, x, y, t):\n if f[0] == 'x':\n return x\n if f[0] == 'y':\n return y\n if f[0] == 't':\n return y-t\n if f[0] == 'prod':\n return eval_func(f[1],x,y,t)*eval_func(f[2],x,y,t)\n if f[0] == 'avg':\n return (eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t))/2.0\n if f[0] == 'cos_pi':\n return math.cos(math.pi*eval_func(f[1],x,y,t))\n if f[0] == 'sin_pi':\n return math.sin(math.pi*eval_func(f[1],x,y,t))\n if f[0] == 'subtract':\n return eval_func(f[1],x,y,t)-eval_func(f[2],x,y,t)\n if f[0] == 'add':\n return eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t)","def eval_r_func_3(f, x, y, t):\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi']\n if f[0] == \"x\":\n return x\n elif f[0] == \"y\":\n return y\n elif f[0] == \"t\":\n return t\n else:\n if f[0] == elementary_func[0]:\n first_argument = eval_r_func_3(f[1], x, y, t)\n second_argument = eval_r_func_3(f[2], x, y, t)\n return first_argument * second_argument\n elif f[0] == elementary_func[1]:\n first_argument = eval_r_func_3(f[1], x, y, t)\n second_argument = eval_r_func_3(f[2], x, y, t)\n return .5*(first_argument + second_argument)\n elif f[0] == elementary_func[2]:\n argument = eval_r_func_3(f[1], x, y, t)\n ans = math.cos(math.pi * argument)\n return ans\n elif f[0] == elementary_func[3]:\n argument = eval_r_func_3(f[1], x, y, t)\n ans = math.sin(math.pi * argument)\n return ans","def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\n ...","def evaluate(self, prediction_fn):\n pass","def _evaluate(self, x, y):\n if _isscalar(x):\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n else:\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n alpha = (x - self.x_list[x_pos - 1]) / (\n self.x_list[x_pos] - self.x_list[x_pos - 1]\n )\n beta = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n f = (\n (1 - alpha) * (1 - beta) * self.f_values[x_pos - 1, y_pos - 1]\n + (1 - alpha) * beta * self.f_values[x_pos - 1, y_pos]\n + alpha * (1 - beta) * self.f_values[x_pos, y_pos - 1]\n + alpha * beta * self.f_values[x_pos, y_pos]\n )\n return f","def evaluate(x,a,b,c,k1,k2,f1,f2):\n return a * np.sin(k1 * x - f1) + b * np.cos(k2 * x - f2) + c","def _evaluate(self, x, y):\n x_pos, y_pos = self.find_sector(x, y)\n alpha, beta = self.find_coords(x, y, x_pos, y_pos)\n\n # Calculate the function at each point using bilinear interpolation\n f = (\n (1 - alpha) * (1 - beta) * self.f_values[x_pos, y_pos]\n + (1 - alpha) * beta * self.f_values[x_pos, y_pos + 1]\n + alpha * (1 - beta) * self.f_values[x_pos + 1, y_pos]\n + alpha * beta * self.f_values[x_pos + 1, y_pos + 1]\n )\n return f","def f(n):\n n[0].evaluate(n[1])\n return (n.code,n.fitness,)","def func(x, f, fp):\n\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))","def sampleFunction(x: int, y: float) -> float:\n return x * y","def TargetFunction(p,x,y):\n \n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y","def evaluate(self, state, player, random_state):\n raise NotImplementedError","def evaluate_functional(x, functional, solution, functionals={}, params={}):\n\n functional = eval_expr(functional, functionals, params)\n\n undefined = functional.free_symbols - set(x)\n if undefined:\n raise ValueError(\n f\"Functional contains symbols with undefined values: {undefined}\"\n )\n\n code = _generate_code(x, functional)\n # print(code)\n ldict = {}\n exec(code, globals(), ldict)\n evaluate = ldict[\"evaluate\"]\n del code, ldict\n\n K = len(solution)\n values = numpy.empty(K, dtype=float)\n evaluate(values, solution)\n return values","def test_simple_funcs(self):\r\n variables = {'x': 4.712}\r\n functions = {'id': lambda x: x}\r\n self.assertEqual(calc.evaluator({}, functions, 'id(2.81)'), 2.81)\r\n self.assertEqual(calc.evaluator({}, functions, 'id(2.81)'), 2.81)\r\n self.assertEqual(calc.evaluator(variables, functions, 'id(x)'), 4.712)\r\n\r\n functions.update({'f': numpy.sin})\r\n self.assertAlmostEqual(\r\n calc.evaluator(variables, functions, 'f(x)'),\r\n -1, delta=1e-3\r\n )","def evaluate(self,\n x=None,\n y=None,\n input_fn=None,\n feed_fn=None,\n batch_size=None,\n steps=None,\n metrics=None,\n name=None,\n checkpoint_path=None,\n hooks=None):\n raise NotImplementedError","def evaluate(self, x):\n return self.function(x)","def evaluationFunction(problem, gFunc, hFunc, node):\n #g = getattr(searchAgents, gFunc)\n #h = getattr(searchAgents, hFunc)\n h = hFunc\n #return g(node) + h(node)\n return gFunc + h(node, problem)","def draw(function):\n def f(**kwargs):\n rand = random.random()\n x = function(**kwargs)\n return int(rand < x)\n return f","def f(t,y):\n return (lam*y)","def eval_func(individual):\n \n tiled = np.tile(individual, (tile_factor, tile_factor))\n return calculate_force_on_sample(tiled, lam_frac_=lambda_factor)","def _random_function(self, random_state):\n return random_state.rand","def f(x, y=1):\r\n return x ** 2 + y","def f(x):\n\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)","def evaluate(self, *args, **kwargs):\n params = self.process_args(args, kwargs)\n a = params['a']\n b = params['b']\n return a * self.x + b","def _pairing_func(x, a, b, c, d, e, f):\n y = a * np.exp(-((b * x) ** c)) + d * np.exp(-((e * x) ** f))\n\n return y","def _evaluate(self, x, y):\n raise NotImplementedError()","def user_function(x, y):\r\n return x ** 2 + 2 * y ** 2","def _evaluate(self, x, y, z):\n if _isscalar(x):\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n alpha = (x - self.x_list[x_pos - 1]) / (\n self.x_list[x_pos] - self.x_list[x_pos - 1]\n )\n beta = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n gamma = (z - self.z_list[z_pos - 1]) / (\n self.z_list[z_pos] - self.z_list[z_pos - 1]\n )\n f = (\n (1 - alpha)\n * (1 - beta)\n * (1 - gamma)\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\n + (1 - alpha)\n * (1 - beta)\n * gamma\n * self.f_values[x_pos - 1, y_pos - 1, z_pos]\n + (1 - alpha)\n * beta\n * (1 - gamma)\n * self.f_values[x_pos - 1, y_pos, z_pos - 1]\n + (1 - alpha) * beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\n + alpha\n * (1 - beta)\n * (1 - gamma)\n * self.f_values[x_pos, y_pos - 1, z_pos - 1]\n + alpha * (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\n + alpha * beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\n + alpha * beta * gamma * self.f_values[x_pos, y_pos, z_pos]\n )\n return f","def _pairing_func(x, a, b, c, d, e, f):\n y = a * np.exp(-(b * x)**c) + d * np.exp(-(e * x)**f)\n\n return y","def F(x):\n return math.exp(-0.5 * (x ** 2))","def _evaluate(self, x, y):\n if _isscalar(x):\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\n alpha = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n f = (1 - alpha) * self.xInterpolators[y_pos - 1](\n x\n ) + alpha * self.xInterpolators[y_pos](x)\n else:\n m = len(x)\n y_pos = np.searchsorted(self.y_list, y)\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n y_pos[y_pos < 1] = 1\n f = np.zeros(m) + np.nan\n if y.size > 0:\n for i in range(1, self.y_n):\n c = y_pos == i\n if np.any(c):\n alpha = (y[c] - self.y_list[i - 1]) / (\n self.y_list[i] - self.y_list[i - 1]\n )\n f[c] = (1 - alpha) * self.xInterpolators[i - 1](\n x[c]\n ) + alpha * self.xInterpolators[i](x[c])\n return f","def interpolate(self, f: callable, a: float, b: float, n: int) -> callable:\n\n # replace this line with your solution to pass the second test\n result = lambda x:x;\n\n return result","def RandomFunction(self):\r\n return self._random_fn","def evaluateFunction(self):\n self.functionValue = np.round(self.function.evaluate(self.position[0], self.position[1]), 2)","def sfunc(self,x,y):\n return np.exp(-(x-self.x_0)**2.0-(y-self.y_0)**2.0)","def evaluate_model(points, function):\n function_values = np.zeros((len(points), 1))\n for i in range(0, len(points)):\n function_values[i,0] = function(points[i,:])\n return function_values","def random() -> float:\n ...","def _evaluate(self, x, y):\n if _isscalar(x):\n f = self.compare([f(x, y) for f in self.functions])\n else:\n m = len(x)\n temp = np.zeros((m, self.funcCount))\n for j in range(self.funcCount):\n temp[:, j] = self.functions[j](x, y)\n f = self.compare(temp, axis=1)\n return f","def get_fy(self):\n\n def fy(p):\n p0, p1 = p\n e = anp.exp(-(p0 + p1) * self.ts)\n x = (\n 1\n / (-p0 - p1)\n * anp.array(\n [\n [-p1 - p0 * e, -p1 + p1 * e],\n [-p0 + p0 * e, -p0 - p1 * e],\n ]\n )\n )\n y = anp.einsum(\"mnr,n->mr\", x, self.x0)\n return y\n\n return fy","def f(x, y=1):\n return x ** 2 + y","def eval(self, x):\n\n if self.eval_f is None:\n self.eval_f = theano.function(\n inputs=[self.input],\n outputs=[self.y],\n givens=[(self.m, self.bm), (self.v, self.bv)]\n )\n\n return self.eval_f(x.astype(dtype))","def generate_evaluate_new_parameter_values(\n self,\n # pyre-fixme[24]: Generic type `Callable` expects 2 type parameters.\n evaluation_function: Callable,\n arm_count: int = 1,\n ) -> None:\n\n model_run = self._random_strategy_model.gen(n=arm_count)\n self.generator_run_for_search_method(\n evaluation_function=evaluation_function, generator_run=model_run\n )","def test_args(self):\r\n rf2 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector)\r\n rf4 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector,\r\n inplace=True)\r\n rng_R = random_state_type()\r\n\r\n # use make_node to override some of the self.args\r\n post_r2, out2 = rf2(rng_R, (4,), -2, 2) # NOT INPLACE\r\n post_r4, out4 = rf4(rng_R, (4,), -4, 4) # INPLACE\r\n post_r2_4, out2_4 = rf2(rng_R, (4, ), -4.0, 2) # NOT INPLACE\r\n post_r2_4_4, out2_4_4 = rf2(rng_R, (4, ), -4.0, 4.0) # NOT INPLACE\r\n\r\n # configure out4 to be computed inplace\r\n # The update expression means that the random state rng_R will\r\n # be maintained by post_r4\r\n f = compile.function(\r\n [compile.In(rng_R,\r\n value=numpy.random.RandomState(utt.fetch_seed()),\r\n update=post_r4,\r\n mutable=True)],\r\n [out2, out4, out2_4, out2_4_4],\r\n accept_inplace=True)\r\n\r\n f2, f4, f2_4, f2_4_4 = f()\r\n f2b, f4b, f2_4b, f2_4_4b = f()\r\n\r\n #print f2\r\n #print f4\r\n #print f2_4\r\n #print f2_4_4\r\n\r\n #print f2b\r\n #print f4b\r\n #print f2_4b\r\n #print f2_4_4b\r\n\r\n # setting bounds is same as multiplying by 2\r\n assert numpy.allclose(f2 * 2, f4), (f2, f4)\r\n\r\n # retrieving from non-inplace generator\r\n # is same as inplace one for first call\r\n assert numpy.allclose(f2_4_4, f4), (f2_4_4, f4)\r\n\r\n # f4 changes from call to call, that the update has worked\r\n assert not numpy.allclose(f4, f4b), (f4, f4b)","def f(self, x):\n r = 0.\n for _ in range(self.batchSize):\n if isinstance(x, Module):\n x.reset()\n self.reset()\n while not self.isFinished():\n self.performAction(x.activate(self.getObservation()))\n elif isinstance(x, Agent):\n EpisodicExperiment(self, x).doEpisodes()\n else:\n raise ValueError(self.__class__.__name__+' cannot evaluate the fitness of '+str(type(x)))\n r += self.getTotalReward()\n return r / float(self.batchSize)","def f(x, a, d1, d2):\n A = 10*a\n D1 = 10*d1\n D2 = 10*d2\n y = e * (frequency) * (1e9) * ( np.exp(-np.exp(-A*x+D1)) + np.exp(-np.exp(-A*x+D2)) + N)\n return y","def evaluate(bounds , func):\n if len(bounds) != 2:\n raise ValueError(\"Bounds should contain 2 elements, found %d.\" % len(bounds))\n\n a = bounds[0]\n b = bounds[1]\n ya = func(a)\n yb = func((a+b)/2.)\n yc = func(b)\n I = (b-a) * (ya + 4. * yb + yc) / 6.\n return I","def run(self):\n\t\tcurX = self.x0\n\t\tcurY = self.func.evalAt(curX)\n\t\tcurT = self.T0\n\t\tfor i in range(1, self.iters + 1):\n\t\t\tif curT == 0:\n\t\t\t\tbreak\n\t\t\tnX = self.newStateFunc(curX)\n\t\t\tnY = self.func.evalAt(nX)\n\t\t\tif nY <= curY or self.acceptanceFunc(nY - curY, curT) > random.random(): # accept if lower energy or probability check passes\n\t\t\t\tcurX = nX\n\t\t\t\tcurY = nY \n\t\t\tcurT = self.coolingFunc(self.T0, i)\t\n\t\treturn (curX, curY)","def _evaluate(self, x, y, z):\n raise NotImplementedError()","def apx_ratio_eval():\n print 'starting random eval'\n\n n_pl = randint(2, MAX_PL)\n n_target = randint(n_pl + 1, MAX_TARGETS)\n\n target_values = []\n for t in range(0,n_target):\n target_values.append(random())\n target_values = np.array(target_values)\n\n attacker_strategy = get_random_attacker_strategy(n_target)\n\n #I = get_random_covering_routes(n_pl, n_target)\n I = get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values)\n\n start_opt = time()\n br_opt = ilp.generate_row(I, attacker_strategy, target_values)\n opt_time = time() - start_opt\n\n start_apx = time()\n br_apx = greedy.generate_row(I, attacker_strategy, target_values)\n apx_time = time() - start_apx\n\n print 'opt time: ', opt_time, 'apx time: ', apx_time\n\n apx_val = get_value(br_apx, I, target_values, attacker_strategy)\n opt_val = get_value(br_opt, I, target_values, attacker_strategy)\n\n logging.info('ratio = %f - target = %d - pl = %f - max_r = %d - max_cov_t = %d',apx_val/opt_val, n_target, n_pl, MAX_ROUTES, MAX_ROUTE_LEN)\n\n return apx_val/opt_val, opt_time, apx_time","def get_eval_fn(\n testset: torchvision.datasets.CIFAR10,\n) -> Callable[[fl.common.Weights], Optional[Tuple[float, float]]]:\n\n def evaluate(weights: fl.common.Weights) -> Optional[Tuple[float, float]]:\n \"\"\"Use the entire CIFAR-10 test set for evaluation.\"\"\"\n model = models.load_model(glb.MODEL)\n model.set_weights(weights)\n model.to(DEVICE)\n testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)\n # using pytorch for central evaluation, can be tensorflow as well\n return modules.pt_test(model, testloader, device=DEVICE) \n\n return evaluate","def f(x):\r\n return x * np.sin(x)","def evaluate():\n\t\t\t\tif not hasattr(evaluate, 'value'):\n\t\t\t\t\tevaluate.value = func()\n\t\t\t\treturn evaluate.value","def evaluate(self, batch_x, batch_y):\n raise NotImplementedError()","def f(x, y):\n return Ripple.g(np.sqrt(x ** 2 + y ** 2))","def test_exercise_1():\n a, b = 5, 0\n fvals = []\n grid = np.linspace(-3, 4)\n for value in grid:\n fvals.append(get_test_function(value, a, b))\n plt.plot(grid, fvals)","def constant_equation(funct):\n return funct + \"x\"","def my_fn(x):\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)","def evaluate(self, state):\n _n = len(state)\n _t = np.ceil(self.t_pct*_n)\n\n # Calculate head and tail values\n tail_0 = self.tail(0, state)\n head_1 = self.head(1, state)\n\n # Calculate R(X, T)\n if (tail_0 > _t and head_1 > _t):\n _r = _n\n else:\n _r = 0\n\n # Evaluate function\n fitness = max(tail_0, head_1) + _r\n self.num_evals += 1\n return fitness","def evaluate(self, x, y):\n x = np.asanyarray(x, dtype=float)\n y = np.asanyarray(y, dtype=float)\n parvals = self.parvals(x)\n return self._evaluate_y(y, parvals)","def test_uniform(self):\r\n # Check over two calls to see if the random state is correctly updated.\r\n rng_R = random_state_type()\r\n # Use non-default parameters\r\n post_r, out = uniform(rng_R, (4,), -2.0, 2.0)\r\n\r\n f = compile.function(\r\n [compile.In(rng_R,\r\n value=numpy.random.RandomState(utt.fetch_seed()),\r\n update=post_r, mutable=True)],\r\n [out], accept_inplace=True)\r\n\r\n numpy_rng = numpy.random.RandomState(utt.fetch_seed())\r\n val0 = f()\r\n val1 = f()\r\n numpy_val0 = numpy_rng.uniform(-2.0, 2.0, size=(4,))\r\n numpy_val1 = numpy_rng.uniform(-2.0, 2.0, size=(4,))\r\n print val0\r\n print numpy_val0\r\n print val1\r\n print numpy_val1\r\n self.assertTrue(numpy.allclose(val0, numpy_val0))\r\n self.assertTrue(numpy.allclose(val1, numpy_val1))","def eval(self, x):\n self.__check_input__(x)\n x1 = x[0]\n x2 = x[1]\n\n t = 1 / (8 * np.pi)\n s = 10\n r = 6\n c = 5 / np.pi\n b = 5.1 / (4 * np.pi ** 2)\n a = 1\n\n term1 = a * (x2 - b * x1 ** 2 + c * x1 - r) ** 2\n term2 = s * (1 - t) * np.cos(x1)\n\n return term1 + term2 + s","def main():\r\n\r\n coef = [1,0,0,-1,-10]\r\n x = 2\r\n\r\n # The algorithm initializes result as coefficient of x^n, where n is the degree of polynomial and then\r\n # Repeatedly multiply result with x and add next coefficient to result\r\n result = coef[0]\r\n for i in range(1, len(coef)):\r\n result = (result * x) + coef[i]\r\n\r\n print(f'The function evaluate to : {result} for given x value: {x}')","def f(self, x: np.array) -> np.array:\n return self.a * x**2 + self.b * x + self.c","def test_func(x, a, b, c, d):\n return a + b * x + c * x**2 + d * x**3","def f(x):\n return x**2","def f1(x):\n return x**3 - 2*x + 2","def evaluate(X_test, y_test):\n # batch size is 16 for evaluation\n batch_size = 16\n\n # Load Model\n model = load_model('model/model.h5')\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)","def f(self, x, theta):\n raise NotImplementedError(\n \"f has not been implemented for this Experiment\")","def _fit_function(self,x,a,b):\n return b + a*x","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def eval_f(self, u, t):\n f = self.f_init\n f[:] = self.A.dot(u.flatten()).reshape(self.nvars)\n return f","def fn(a, y):\n return 0.5*np.linalg.norm(a-y)**2","def eval_test(self, rng_key, svi_state):\n def body_fn(i, loss_sum):\n rng_key_i = random.fold_in(rng_key, i) \n rng_key_i, rng_key_ls, rng_key_var, rng_key_sigma = random.split(rng_key_i, 4)\n \n length_i = numpyro.sample(\"length\", dist.InverseGamma(1,.1), rng_key=rng_key_ls)\n var_i = numpyro.sample(\"var\", dist.LogNormal(0,0.1), rng_key=rng_key_var)\n sigma_i = numpyro.sample(\"noise\", dist.HalfNormal(0.1), rng_key=rng_key_sigma)\n \n batch = self.gp_predictive(rng_key_i, self.x\n , ls=length_i, var=var_i, sigma=sigma_i\n )\n\n loss = self.svi.evaluate(svi_state, batch['y']) / self.batch_size\n loss_sum += loss\n return loss_sum\n\n loss = lax.fori_loop(0, self.num_test, body_fn, 0.0)\n loss = loss / self.num_test\n\n return loss","def evaluate(self,x,y):\n\n #below function comes from MATLAB Peaks function\n # return np.multiply(3*np.power((1-x), 2), np.exp(-np.power(x,2) - np.power((y+1), 2))) - np.multiply(10 * (x/5.0 - np.power(x,3) - np.power(y,5)), np.exp(-np.power(x,2)-np.power(y,2)))#- np.exp(-np.power(x+1,2)-np.power(y,2))/3.0\n # return -np.power((x-50),2) - np.power(y, 2)-3\n return 5- (np.multiply(np.multiply(np.sin(x), np.sin(y)), np.power(x,2)) + np.power(y,2))","def f(m, x, b):\n return m*x + b","def f(x):\n return math.exp(-x**2)/(1+x**2)+(2*math.cos(x)**2)/(1+(x-4)**2)","def zzx_eval(f, x):\n result = INT_ZERO\n\n if not x:\n return poly_TC(f)\n\n for a in f:\n result *= x\n result += a\n\n return result","def scalar_function(x, y):\n #Your code here\n if x<=y:\n fs = x*y\n else:\n fs = x/y\n return fs\n raise NotImplementedError","def f(x, y):\n raise NotImplementedError","def sample2d(f, x_args):\n try:\n f = sympify(f)\n except SympifyError:\n raise ValueError(\"f could not be interpreted as a SymPy function\")\n try:\n x, x_min, x_max, x_n = x_args\n except (TypeError, IndexError):\n raise ValueError(\"x_args must be a tuple of the form (var, min, max, n)\")\n\n x_l = float(x_max - x_min)\n x_d = x_l/float(x_n)\n X = np.arange(float(x_min), float(x_max) + x_d, x_d)\n\n Y = np.empty(len(X))\n for i in range(len(X)):\n try:\n Y[i] = float(f.subs(x, X[i]))\n except TypeError:\n Y[i] = None\n return X, Y","def f1(x, a, b):\n #return x**43 - b*x**42 + x**7 - x**6 * a + 84*x - 42 * b - 42 * a\n return (x**42 + 42)/(x-a) + (x**6 + 42)/(x-b)","def f(x):\r\n\treturn np.sin(x)","def f(x):\n return (2.0*math.sin(10.0*x+1.0)+1.0)","def test_figure34(self):\n star = 0.1\n current = 1.37\n func = lambda x: x**6 + 3 * x - 4\n\n logging.info(\"\\nCONFIRMING FIGURE 3.4\")\n rf_results = undertest.regula_falsi(func, star, current, 100)","def test_generate_lambda_alchemical_function(self):\n from openmmtools.utils import math_eval\n\n def evaluate(expr, l):\n variables = {'lambda': l}\n return math_eval(expr, variables)\n\n # Each test case are [(lambda0, lambda1), (f(lambda0), f([lambda0+lambda1]/2), f(lambda1))]\n # where the second tuple in the list are the expected values of the function.\n test_cases = [(0, 1), (1, 0), (2, 3), (3, 2), (4, 8), (10, 5)]\n\n for lambda0, lambda1 in test_cases:\n expr = ExperimentBuilder._generate_lambda_alchemical_function(lambda0, lambda1)\n print(lambda0, lambda1, ':', expr)\n assert evaluate(expr, lambda0) == 0.0\n assert evaluate(expr, (lambda0 + lambda1)/2) == 0.5\n assert evaluate(expr, lambda1) == 1.0\n\n # The funciton must be constant after the end states.\n if lambda0 < lambda1:\n assert evaluate(expr, lambda0-1) == 0.0\n assert evaluate(expr, lambda1+1) == 1.0\n else:\n assert evaluate(expr, lambda0+1) == 0.0\n assert evaluate(expr, lambda1-1) == 1.0","def _evaluate(self, x, y, z):\n if _isscalar(x):\n f = self.compare([f(x, y, z) for f in self.functions])\n else:\n m = len(x)\n temp = np.zeros((m, self.funcCount))\n for j in range(self.funcCount):\n temp[:, j] = self.functions[j](x, y, z)\n f = self.compare(temp, axis=1)\n return f","def _evaluate(self, x, y, z):\n if _isscalar(x):\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(np.searchsorted(self.z_list, z), self.z_n - 1), 1)\n alpha = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n beta = (z - self.z_list[z_pos - 1]) / (\n self.z_list[z_pos] - self.z_list[z_pos - 1]\n )\n f = (\n (1 - alpha) * (1 - beta) * self.xInterpolators[y_pos - 1][z_pos - 1](x)\n + (1 - alpha) * beta * self.xInterpolators[y_pos - 1][z_pos](x)\n + alpha * (1 - beta) * self.xInterpolators[y_pos][z_pos - 1](x)\n + alpha * beta * self.xInterpolators[y_pos][z_pos](x)\n )\n else:\n m = len(x)\n y_pos = np.searchsorted(self.y_list, y)\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n y_pos[y_pos < 1] = 1\n z_pos = np.searchsorted(self.z_list, z)\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n z_pos[z_pos < 1] = 1\n f = np.zeros(m) + np.nan\n for i in range(1, self.y_n):\n for j in range(1, self.z_n):\n c = np.logical_and(i == y_pos, j == z_pos)\n if np.any(c):\n alpha = (y[c] - self.y_list[i - 1]) / (\n self.y_list[i] - self.y_list[i - 1]\n )\n beta = (z[c] - self.z_list[j - 1]) / (\n self.z_list[j] - self.z_list[j - 1]\n )\n f[c] = (\n (1 - alpha)\n * (1 - beta)\n * self.xInterpolators[i - 1][j - 1](x[c])\n + (1 - alpha) * beta * self.xInterpolators[i - 1][j](x[c])\n + alpha * (1 - beta) * self.xInterpolators[i][j - 1](x[c])\n + alpha * beta * self.xInterpolators[i][j](x[c])\n )\n return f","def funcv(x):\n f0 = x[0] ** 3.0 + x[1] + 3.0\n f1 = x[1] - 4.0 * x[0]\n return f0, f1","def get_func_eval(self, x_vals: X):\n return np.dot(self.get_feature_vals(x_vals), self.params[0])"],"string":"[\n \"def evaluate_random_function(f, x, y):\\n\\n # your code goes here\",\n \"def evaluate_random_function(f, x, y):\\n\\n if f[0] == \\\"prod\\\":\\n return evaluate_random_function(f[1],x,y) * evaluate_random_function(f[2],x,y)\\n elif f[0] == \\\"sin_pi\\\":\\n return sin(evaluate_random_function(f[1],x,y) * pi)\\n elif f[0] == \\\"cos_pi\\\":\\n return cos(evaluate_random_function(f[1],x,y) * pi)\\n elif f[0] == \\\"x\\\":\\n return x\\n else:\\n return y\",\n \"def evaluate_random_function(f, x, y):\\n if (f[0]=='x'):\\n return X(x,y)\\n elif (f[0]=='y'):\\n return Y(x,y)\\n elif (f[0]=='sin_pi'):\\n return sin_pi(evaluate_random_function(f[1],x,y))\\n elif (f[0]=='cos_pi'):\\n return cos_pi(evaluate_random_function(f[1],x,y))\\n elif (f[0]=='times'):\\n return times(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\\n elif (f[0]=='root'):\\n return root(evaluate_random_function(f[1],x,y))\\n elif (f[0]=='square'):\\n return square(evaluate_random_function(f[1],x,y))\",\n \"def evaluate_random_function(f, x, y):\\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi', 'square', 'root']\\n if f[0] == \\\"x\\\":\\n return x\\n elif f[0] == \\\"y\\\":\\n return y\\n\\n # Kindof effort instensive way to do this, but it allows for a\\n # changeable list of functions with less effort\\n else:\\n if f[0] == elementary_func[0]:\\n first_argument = evaluate_random_function(f[1], x, y)\\n second_argument = evaluate_random_function(f[2], x, y)\\n return first_argument * second_argument\\n elif f[0] == elementary_func[1]:\\n first_argument = evaluate_random_function(f[1], x, y)\\n second_argument = evaluate_random_function(f[2], x, y)\\n return .5*(first_argument + second_argument)\\n elif f[0] == elementary_func[2]:\\n argument = evaluate_random_function(f[1], x, y)\\n ans = math.cos(math.pi * argument)\\n return ans\\n elif f[0] == elementary_func[3]:\\n argument = evaluate_random_function(f[1], x, y)\\n ans = math.sin(math.pi * argument)\\n return ans\\n elif f[0] == elementary_func[4]:\\n argument = evaluate_random_function(f[1], x, y)\\n return argument**2\\n elif f[0] == elementary_func[5]:\\n argument = evaluate_random_function(f[1], x, y)\\n return math.sqrt(math.fabs(argument))\",\n \"def evaluate_random_function(f, x, y):\\n if len(f)==1: #check base case\\n # print f[0],\\\"BASE\\\"\\n if f[0]==\\\"x0\\\":\\n return x0(x,y)\\n if f[0]==\\\"y0\\\":\\n return y0(x,y)\\n if f[0]==\\\"prod\\\":\\n return prod(x,y)\\n if f[0]==\\\"avg\\\":\\n return avg(x,y)\\n if f[0]==\\\"square\\\":\\n return square(x,y)\\n if f[0]==\\\"squarert\\\":\\n return squarert(x,y)\\n return 'error1'\\n #done checking base case. Only need to provide for possible base cases\\n # print f[0], \\\"NORMAL\\\"\\n if f[0]==\\\"x0\\\":\\n return x0(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\\n if f[0]==\\\"y0\\\":\\n return y0(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\\n if f[0]==\\\"prod\\\":\\n return prod(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\\n if f[0]==\\\"avg\\\":\\n return avg(evaluate_random_function(f[1],x,y),evaluate_random_function(f[2],x,y))\\n if f[0]==\\\"cos_pi\\\":\\n return cos_pi(evaluate_random_function(f[1],x,y))\\n if f[0]==\\\"sin_pi\\\":\\n return sin_pi(evaluate_random_function(f[1],x,y))\\n if f[0]==\\\"square\\\":\\n return square(evaluate_random_function(f[1],x,y))\\n if f[0]==\\\"squarert\\\":\\n return squarert(evaluate_random_function(f[1],x,y))\\n \\n return 'error'\",\n \"def evaluate_random_function(f, x, y, t=0):\\n if f[0] == \\\"x\\\":\\n return x\\n elif f[0] == \\\"y\\\":\\n return y\\n elif f[0] == \\\"t\\\":\\n return t\\n elif f[0] == \\\"prod\\\": \\n return evaluate_random_function(f[1], x, y, t)*evaluate_random_function(f[2], x, y, t)\\n elif f[0] == \\\"avg\\\":\\n return 0.5*(evaluate_random_function(f[1], x, y, t)+evaluate_random_function(f[2], x, y, t))\\n elif f[0] == \\\"cos_pi\\\":\\n return cos(pi*evaluate_random_function(f[1], x, y, t))\\n elif f[0] == \\\"sin_pi\\\":\\n return sin(pi*evaluate_random_function(f[1], x, y, t))\\n elif f[0] == \\\"hypot\\\":\\n first = evaluate_random_function(f[1], x, y, t)\\n second = evaluate_random_function(f[1], x, y, t)\\n tester = first*abs(first) + second*abs(second)\\n if tester >= 0:\\n return sqrt(first**2 + second**2)/sqrt(2)\\n else:\\n return -sqrt(first**2 + second**2)/sqrt(2)\\n elif f[0] == \\\"pow\\\":\\n val = evaluate_random_function(f[1], x, y, t)\\n if val >= 0:\\n return 1-val**val\\n else:\\n return -(1-abs(val)**abs(val))\\n elif f[0] == \\\"add\\\":\\n first = evaluate_random_function(f[1], x, y, t)\\n second = evaluate_random_function(f[1], x, y, t)\\n if first + second > 1:\\n return (1 - (first+second) + 1)\\n elif first + second < -1:\\n return (-2 - (first+second))\\n else:\\n return (first + second)\\n elif f[0] == \\\"cube\\\":\\n return evaluate_random_function(f[1], x, y, t)**3\",\n \"def eval_rand_func(f, a, b):\\n\\n\\tif f[0] == 'prod':\\n\\t\\treturn eval_rand_func(f[1], a, b) * eval_rand_func(f[2], a, b)\\n\\n\\telif f[0] == 'cos_pi':\\n\\t\\treturn math.cos(math.pi * eval_rand_func(f[1], a, b))\\n\\n\\telif f[0] == 'sin_pi':\\n\\t\\treturn math.sin(math.pi * eval_rand_func(f[1], a, b))\\n\\n\\telif f[0] == 'A':\\n\\t\\treturn a\\n\\t\\t\\n\\telse:\\n\\t\\treturn b\",\n \"def evaluate_random_function(f, x, y, lambdas):\\n if lambdas:\\n return f(x, y)\\n\\n if len(f) == 3:\\n x2 = evaluate_random_function(f[1], x, y, lambdas)\\n y2 = evaluate_random_function(f[2], x, y, lambdas)\\n\\n for i in range(len(funcs)):\\n if f[0] == funcs[i][0]:\\n return funcs[i][1](x2, y2)\\n else:\\n for i in range(len(funcs)):\\n if f[0] == funcs[i][0]:\\n return funcs[i][1](x, y)\",\n \"def eval_func(f, x, y, t):\\n if f[0] == 'x':\\n return x\\n if f[0] == 'y':\\n return y\\n if f[0] == 't':\\n return y-t\\n if f[0] == 'prod':\\n return eval_func(f[1],x,y,t)*eval_func(f[2],x,y,t)\\n if f[0] == 'avg':\\n return (eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t))/2.0\\n if f[0] == 'cos_pi':\\n return math.cos(math.pi*eval_func(f[1],x,y,t))\\n if f[0] == 'sin_pi':\\n return math.sin(math.pi*eval_func(f[1],x,y,t))\\n if f[0] == 'subtract':\\n return eval_func(f[1],x,y,t)-eval_func(f[2],x,y,t)\\n if f[0] == 'add':\\n return eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t)\",\n \"def eval_r_func_3(f, x, y, t):\\n elementary_func = ['prod', 'avg', 'cos_pi', 'sin_pi']\\n if f[0] == \\\"x\\\":\\n return x\\n elif f[0] == \\\"y\\\":\\n return y\\n elif f[0] == \\\"t\\\":\\n return t\\n else:\\n if f[0] == elementary_func[0]:\\n first_argument = eval_r_func_3(f[1], x, y, t)\\n second_argument = eval_r_func_3(f[2], x, y, t)\\n return first_argument * second_argument\\n elif f[0] == elementary_func[1]:\\n first_argument = eval_r_func_3(f[1], x, y, t)\\n second_argument = eval_r_func_3(f[2], x, y, t)\\n return .5*(first_argument + second_argument)\\n elif f[0] == elementary_func[2]:\\n argument = eval_r_func_3(f[1], x, y, t)\\n ans = math.cos(math.pi * argument)\\n return ans\\n elif f[0] == elementary_func[3]:\\n argument = eval_r_func_3(f[1], x, y, t)\\n ans = math.sin(math.pi * argument)\\n return ans\",\n \"def EvaluateFunction(self, p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def evaluate(self, prediction_fn):\\n pass\",\n \"def _evaluate(self, x, y):\\n if _isscalar(x):\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n else:\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n alpha = (x - self.x_list[x_pos - 1]) / (\\n self.x_list[x_pos] - self.x_list[x_pos - 1]\\n )\\n beta = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n f = (\\n (1 - alpha) * (1 - beta) * self.f_values[x_pos - 1, y_pos - 1]\\n + (1 - alpha) * beta * self.f_values[x_pos - 1, y_pos]\\n + alpha * (1 - beta) * self.f_values[x_pos, y_pos - 1]\\n + alpha * beta * self.f_values[x_pos, y_pos]\\n )\\n return f\",\n \"def evaluate(x,a,b,c,k1,k2,f1,f2):\\n return a * np.sin(k1 * x - f1) + b * np.cos(k2 * x - f2) + c\",\n \"def _evaluate(self, x, y):\\n x_pos, y_pos = self.find_sector(x, y)\\n alpha, beta = self.find_coords(x, y, x_pos, y_pos)\\n\\n # Calculate the function at each point using bilinear interpolation\\n f = (\\n (1 - alpha) * (1 - beta) * self.f_values[x_pos, y_pos]\\n + (1 - alpha) * beta * self.f_values[x_pos, y_pos + 1]\\n + alpha * (1 - beta) * self.f_values[x_pos + 1, y_pos]\\n + alpha * beta * self.f_values[x_pos + 1, y_pos + 1]\\n )\\n return f\",\n \"def f(n):\\n n[0].evaluate(n[1])\\n return (n.code,n.fitness,)\",\n \"def func(x, f, fp):\\n\\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))\",\n \"def sampleFunction(x: int, y: float) -> float:\\n return x * y\",\n \"def TargetFunction(p,x,y):\\n \\n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y\",\n \"def evaluate(self, state, player, random_state):\\n raise NotImplementedError\",\n \"def evaluate_functional(x, functional, solution, functionals={}, params={}):\\n\\n functional = eval_expr(functional, functionals, params)\\n\\n undefined = functional.free_symbols - set(x)\\n if undefined:\\n raise ValueError(\\n f\\\"Functional contains symbols with undefined values: {undefined}\\\"\\n )\\n\\n code = _generate_code(x, functional)\\n # print(code)\\n ldict = {}\\n exec(code, globals(), ldict)\\n evaluate = ldict[\\\"evaluate\\\"]\\n del code, ldict\\n\\n K = len(solution)\\n values = numpy.empty(K, dtype=float)\\n evaluate(values, solution)\\n return values\",\n \"def test_simple_funcs(self):\\r\\n variables = {'x': 4.712}\\r\\n functions = {'id': lambda x: x}\\r\\n self.assertEqual(calc.evaluator({}, functions, 'id(2.81)'), 2.81)\\r\\n self.assertEqual(calc.evaluator({}, functions, 'id(2.81)'), 2.81)\\r\\n self.assertEqual(calc.evaluator(variables, functions, 'id(x)'), 4.712)\\r\\n\\r\\n functions.update({'f': numpy.sin})\\r\\n self.assertAlmostEqual(\\r\\n calc.evaluator(variables, functions, 'f(x)'),\\r\\n -1, delta=1e-3\\r\\n )\",\n \"def evaluate(self,\\n x=None,\\n y=None,\\n input_fn=None,\\n feed_fn=None,\\n batch_size=None,\\n steps=None,\\n metrics=None,\\n name=None,\\n checkpoint_path=None,\\n hooks=None):\\n raise NotImplementedError\",\n \"def evaluate(self, x):\\n return self.function(x)\",\n \"def evaluationFunction(problem, gFunc, hFunc, node):\\n #g = getattr(searchAgents, gFunc)\\n #h = getattr(searchAgents, hFunc)\\n h = hFunc\\n #return g(node) + h(node)\\n return gFunc + h(node, problem)\",\n \"def draw(function):\\n def f(**kwargs):\\n rand = random.random()\\n x = function(**kwargs)\\n return int(rand < x)\\n return f\",\n \"def f(t,y):\\n return (lam*y)\",\n \"def eval_func(individual):\\n \\n tiled = np.tile(individual, (tile_factor, tile_factor))\\n return calculate_force_on_sample(tiled, lam_frac_=lambda_factor)\",\n \"def _random_function(self, random_state):\\n return random_state.rand\",\n \"def f(x, y=1):\\r\\n return x ** 2 + y\",\n \"def f(x):\\n\\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)\",\n \"def evaluate(self, *args, **kwargs):\\n params = self.process_args(args, kwargs)\\n a = params['a']\\n b = params['b']\\n return a * self.x + b\",\n \"def _pairing_func(x, a, b, c, d, e, f):\\n y = a * np.exp(-((b * x) ** c)) + d * np.exp(-((e * x) ** f))\\n\\n return y\",\n \"def _evaluate(self, x, y):\\n raise NotImplementedError()\",\n \"def user_function(x, y):\\r\\n return x ** 2 + 2 * y ** 2\",\n \"def _evaluate(self, x, y, z):\\n if _isscalar(x):\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n alpha = (x - self.x_list[x_pos - 1]) / (\\n self.x_list[x_pos] - self.x_list[x_pos - 1]\\n )\\n beta = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n gamma = (z - self.z_list[z_pos - 1]) / (\\n self.z_list[z_pos] - self.z_list[z_pos - 1]\\n )\\n f = (\\n (1 - alpha)\\n * (1 - beta)\\n * (1 - gamma)\\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\\n + (1 - alpha)\\n * (1 - beta)\\n * gamma\\n * self.f_values[x_pos - 1, y_pos - 1, z_pos]\\n + (1 - alpha)\\n * beta\\n * (1 - gamma)\\n * self.f_values[x_pos - 1, y_pos, z_pos - 1]\\n + (1 - alpha) * beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\\n + alpha\\n * (1 - beta)\\n * (1 - gamma)\\n * self.f_values[x_pos, y_pos - 1, z_pos - 1]\\n + alpha * (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\\n + alpha * beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\\n + alpha * beta * gamma * self.f_values[x_pos, y_pos, z_pos]\\n )\\n return f\",\n \"def _pairing_func(x, a, b, c, d, e, f):\\n y = a * np.exp(-(b * x)**c) + d * np.exp(-(e * x)**f)\\n\\n return y\",\n \"def F(x):\\n return math.exp(-0.5 * (x ** 2))\",\n \"def _evaluate(self, x, y):\\n if _isscalar(x):\\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\\n alpha = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n f = (1 - alpha) * self.xInterpolators[y_pos - 1](\\n x\\n ) + alpha * self.xInterpolators[y_pos](x)\\n else:\\n m = len(x)\\n y_pos = np.searchsorted(self.y_list, y)\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n y_pos[y_pos < 1] = 1\\n f = np.zeros(m) + np.nan\\n if y.size > 0:\\n for i in range(1, self.y_n):\\n c = y_pos == i\\n if np.any(c):\\n alpha = (y[c] - self.y_list[i - 1]) / (\\n self.y_list[i] - self.y_list[i - 1]\\n )\\n f[c] = (1 - alpha) * self.xInterpolators[i - 1](\\n x[c]\\n ) + alpha * self.xInterpolators[i](x[c])\\n return f\",\n \"def interpolate(self, f: callable, a: float, b: float, n: int) -> callable:\\n\\n # replace this line with your solution to pass the second test\\n result = lambda x:x;\\n\\n return result\",\n \"def RandomFunction(self):\\r\\n return self._random_fn\",\n \"def evaluateFunction(self):\\n self.functionValue = np.round(self.function.evaluate(self.position[0], self.position[1]), 2)\",\n \"def sfunc(self,x,y):\\n return np.exp(-(x-self.x_0)**2.0-(y-self.y_0)**2.0)\",\n \"def evaluate_model(points, function):\\n function_values = np.zeros((len(points), 1))\\n for i in range(0, len(points)):\\n function_values[i,0] = function(points[i,:])\\n return function_values\",\n \"def random() -> float:\\n ...\",\n \"def _evaluate(self, x, y):\\n if _isscalar(x):\\n f = self.compare([f(x, y) for f in self.functions])\\n else:\\n m = len(x)\\n temp = np.zeros((m, self.funcCount))\\n for j in range(self.funcCount):\\n temp[:, j] = self.functions[j](x, y)\\n f = self.compare(temp, axis=1)\\n return f\",\n \"def get_fy(self):\\n\\n def fy(p):\\n p0, p1 = p\\n e = anp.exp(-(p0 + p1) * self.ts)\\n x = (\\n 1\\n / (-p0 - p1)\\n * anp.array(\\n [\\n [-p1 - p0 * e, -p1 + p1 * e],\\n [-p0 + p0 * e, -p0 - p1 * e],\\n ]\\n )\\n )\\n y = anp.einsum(\\\"mnr,n->mr\\\", x, self.x0)\\n return y\\n\\n return fy\",\n \"def f(x, y=1):\\n return x ** 2 + y\",\n \"def eval(self, x):\\n\\n if self.eval_f is None:\\n self.eval_f = theano.function(\\n inputs=[self.input],\\n outputs=[self.y],\\n givens=[(self.m, self.bm), (self.v, self.bv)]\\n )\\n\\n return self.eval_f(x.astype(dtype))\",\n \"def generate_evaluate_new_parameter_values(\\n self,\\n # pyre-fixme[24]: Generic type `Callable` expects 2 type parameters.\\n evaluation_function: Callable,\\n arm_count: int = 1,\\n ) -> None:\\n\\n model_run = self._random_strategy_model.gen(n=arm_count)\\n self.generator_run_for_search_method(\\n evaluation_function=evaluation_function, generator_run=model_run\\n )\",\n \"def test_args(self):\\r\\n rf2 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector)\\r\\n rf4 = RandomFunction(numpy.random.RandomState.uniform, tensor.dvector,\\r\\n inplace=True)\\r\\n rng_R = random_state_type()\\r\\n\\r\\n # use make_node to override some of the self.args\\r\\n post_r2, out2 = rf2(rng_R, (4,), -2, 2) # NOT INPLACE\\r\\n post_r4, out4 = rf4(rng_R, (4,), -4, 4) # INPLACE\\r\\n post_r2_4, out2_4 = rf2(rng_R, (4, ), -4.0, 2) # NOT INPLACE\\r\\n post_r2_4_4, out2_4_4 = rf2(rng_R, (4, ), -4.0, 4.0) # NOT INPLACE\\r\\n\\r\\n # configure out4 to be computed inplace\\r\\n # The update expression means that the random state rng_R will\\r\\n # be maintained by post_r4\\r\\n f = compile.function(\\r\\n [compile.In(rng_R,\\r\\n value=numpy.random.RandomState(utt.fetch_seed()),\\r\\n update=post_r4,\\r\\n mutable=True)],\\r\\n [out2, out4, out2_4, out2_4_4],\\r\\n accept_inplace=True)\\r\\n\\r\\n f2, f4, f2_4, f2_4_4 = f()\\r\\n f2b, f4b, f2_4b, f2_4_4b = f()\\r\\n\\r\\n #print f2\\r\\n #print f4\\r\\n #print f2_4\\r\\n #print f2_4_4\\r\\n\\r\\n #print f2b\\r\\n #print f4b\\r\\n #print f2_4b\\r\\n #print f2_4_4b\\r\\n\\r\\n # setting bounds is same as multiplying by 2\\r\\n assert numpy.allclose(f2 * 2, f4), (f2, f4)\\r\\n\\r\\n # retrieving from non-inplace generator\\r\\n # is same as inplace one for first call\\r\\n assert numpy.allclose(f2_4_4, f4), (f2_4_4, f4)\\r\\n\\r\\n # f4 changes from call to call, that the update has worked\\r\\n assert not numpy.allclose(f4, f4b), (f4, f4b)\",\n \"def f(self, x):\\n r = 0.\\n for _ in range(self.batchSize):\\n if isinstance(x, Module):\\n x.reset()\\n self.reset()\\n while not self.isFinished():\\n self.performAction(x.activate(self.getObservation()))\\n elif isinstance(x, Agent):\\n EpisodicExperiment(self, x).doEpisodes()\\n else:\\n raise ValueError(self.__class__.__name__+' cannot evaluate the fitness of '+str(type(x)))\\n r += self.getTotalReward()\\n return r / float(self.batchSize)\",\n \"def f(x, a, d1, d2):\\n A = 10*a\\n D1 = 10*d1\\n D2 = 10*d2\\n y = e * (frequency) * (1e9) * ( np.exp(-np.exp(-A*x+D1)) + np.exp(-np.exp(-A*x+D2)) + N)\\n return y\",\n \"def evaluate(bounds , func):\\n if len(bounds) != 2:\\n raise ValueError(\\\"Bounds should contain 2 elements, found %d.\\\" % len(bounds))\\n\\n a = bounds[0]\\n b = bounds[1]\\n ya = func(a)\\n yb = func((a+b)/2.)\\n yc = func(b)\\n I = (b-a) * (ya + 4. * yb + yc) / 6.\\n return I\",\n \"def run(self):\\n\\t\\tcurX = self.x0\\n\\t\\tcurY = self.func.evalAt(curX)\\n\\t\\tcurT = self.T0\\n\\t\\tfor i in range(1, self.iters + 1):\\n\\t\\t\\tif curT == 0:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tnX = self.newStateFunc(curX)\\n\\t\\t\\tnY = self.func.evalAt(nX)\\n\\t\\t\\tif nY <= curY or self.acceptanceFunc(nY - curY, curT) > random.random(): # accept if lower energy or probability check passes\\n\\t\\t\\t\\tcurX = nX\\n\\t\\t\\t\\tcurY = nY \\n\\t\\t\\tcurT = self.coolingFunc(self.T0, i)\\t\\n\\t\\treturn (curX, curY)\",\n \"def _evaluate(self, x, y, z):\\n raise NotImplementedError()\",\n \"def apx_ratio_eval():\\n print 'starting random eval'\\n\\n n_pl = randint(2, MAX_PL)\\n n_target = randint(n_pl + 1, MAX_TARGETS)\\n\\n target_values = []\\n for t in range(0,n_target):\\n target_values.append(random())\\n target_values = np.array(target_values)\\n\\n attacker_strategy = get_random_attacker_strategy(n_target)\\n\\n #I = get_random_covering_routes(n_pl, n_target)\\n I = get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values)\\n\\n start_opt = time()\\n br_opt = ilp.generate_row(I, attacker_strategy, target_values)\\n opt_time = time() - start_opt\\n\\n start_apx = time()\\n br_apx = greedy.generate_row(I, attacker_strategy, target_values)\\n apx_time = time() - start_apx\\n\\n print 'opt time: ', opt_time, 'apx time: ', apx_time\\n\\n apx_val = get_value(br_apx, I, target_values, attacker_strategy)\\n opt_val = get_value(br_opt, I, target_values, attacker_strategy)\\n\\n logging.info('ratio = %f - target = %d - pl = %f - max_r = %d - max_cov_t = %d',apx_val/opt_val, n_target, n_pl, MAX_ROUTES, MAX_ROUTE_LEN)\\n\\n return apx_val/opt_val, opt_time, apx_time\",\n \"def get_eval_fn(\\n testset: torchvision.datasets.CIFAR10,\\n) -> Callable[[fl.common.Weights], Optional[Tuple[float, float]]]:\\n\\n def evaluate(weights: fl.common.Weights) -> Optional[Tuple[float, float]]:\\n \\\"\\\"\\\"Use the entire CIFAR-10 test set for evaluation.\\\"\\\"\\\"\\n model = models.load_model(glb.MODEL)\\n model.set_weights(weights)\\n model.to(DEVICE)\\n testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)\\n # using pytorch for central evaluation, can be tensorflow as well\\n return modules.pt_test(model, testloader, device=DEVICE) \\n\\n return evaluate\",\n \"def f(x):\\r\\n return x * np.sin(x)\",\n \"def evaluate():\\n\\t\\t\\t\\tif not hasattr(evaluate, 'value'):\\n\\t\\t\\t\\t\\tevaluate.value = func()\\n\\t\\t\\t\\treturn evaluate.value\",\n \"def evaluate(self, batch_x, batch_y):\\n raise NotImplementedError()\",\n \"def f(x, y):\\n return Ripple.g(np.sqrt(x ** 2 + y ** 2))\",\n \"def test_exercise_1():\\n a, b = 5, 0\\n fvals = []\\n grid = np.linspace(-3, 4)\\n for value in grid:\\n fvals.append(get_test_function(value, a, b))\\n plt.plot(grid, fvals)\",\n \"def constant_equation(funct):\\n return funct + \\\"x\\\"\",\n \"def my_fn(x):\\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)\",\n \"def evaluate(self, state):\\n _n = len(state)\\n _t = np.ceil(self.t_pct*_n)\\n\\n # Calculate head and tail values\\n tail_0 = self.tail(0, state)\\n head_1 = self.head(1, state)\\n\\n # Calculate R(X, T)\\n if (tail_0 > _t and head_1 > _t):\\n _r = _n\\n else:\\n _r = 0\\n\\n # Evaluate function\\n fitness = max(tail_0, head_1) + _r\\n self.num_evals += 1\\n return fitness\",\n \"def evaluate(self, x, y):\\n x = np.asanyarray(x, dtype=float)\\n y = np.asanyarray(y, dtype=float)\\n parvals = self.parvals(x)\\n return self._evaluate_y(y, parvals)\",\n \"def test_uniform(self):\\r\\n # Check over two calls to see if the random state is correctly updated.\\r\\n rng_R = random_state_type()\\r\\n # Use non-default parameters\\r\\n post_r, out = uniform(rng_R, (4,), -2.0, 2.0)\\r\\n\\r\\n f = compile.function(\\r\\n [compile.In(rng_R,\\r\\n value=numpy.random.RandomState(utt.fetch_seed()),\\r\\n update=post_r, mutable=True)],\\r\\n [out], accept_inplace=True)\\r\\n\\r\\n numpy_rng = numpy.random.RandomState(utt.fetch_seed())\\r\\n val0 = f()\\r\\n val1 = f()\\r\\n numpy_val0 = numpy_rng.uniform(-2.0, 2.0, size=(4,))\\r\\n numpy_val1 = numpy_rng.uniform(-2.0, 2.0, size=(4,))\\r\\n print val0\\r\\n print numpy_val0\\r\\n print val1\\r\\n print numpy_val1\\r\\n self.assertTrue(numpy.allclose(val0, numpy_val0))\\r\\n self.assertTrue(numpy.allclose(val1, numpy_val1))\",\n \"def eval(self, x):\\n self.__check_input__(x)\\n x1 = x[0]\\n x2 = x[1]\\n\\n t = 1 / (8 * np.pi)\\n s = 10\\n r = 6\\n c = 5 / np.pi\\n b = 5.1 / (4 * np.pi ** 2)\\n a = 1\\n\\n term1 = a * (x2 - b * x1 ** 2 + c * x1 - r) ** 2\\n term2 = s * (1 - t) * np.cos(x1)\\n\\n return term1 + term2 + s\",\n \"def main():\\r\\n\\r\\n coef = [1,0,0,-1,-10]\\r\\n x = 2\\r\\n\\r\\n # The algorithm initializes result as coefficient of x^n, where n is the degree of polynomial and then\\r\\n # Repeatedly multiply result with x and add next coefficient to result\\r\\n result = coef[0]\\r\\n for i in range(1, len(coef)):\\r\\n result = (result * x) + coef[i]\\r\\n\\r\\n print(f'The function evaluate to : {result} for given x value: {x}')\",\n \"def f(self, x: np.array) -> np.array:\\n return self.a * x**2 + self.b * x + self.c\",\n \"def test_func(x, a, b, c, d):\\n return a + b * x + c * x**2 + d * x**3\",\n \"def f(x):\\n return x**2\",\n \"def f1(x):\\n return x**3 - 2*x + 2\",\n \"def evaluate(X_test, y_test):\\n # batch size is 16 for evaluation\\n batch_size = 16\\n\\n # Load Model\\n model = load_model('model/model.h5')\\n return model.evaluate(X_test, y_test, batch_size, verbose = 1)\",\n \"def f(self, x, theta):\\n raise NotImplementedError(\\n \\\"f has not been implemented for this Experiment\\\")\",\n \"def _fit_function(self,x,a,b):\\n return b + a*x\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def eval_f(self, u, t):\\n f = self.f_init\\n f[:] = self.A.dot(u.flatten()).reshape(self.nvars)\\n return f\",\n \"def fn(a, y):\\n return 0.5*np.linalg.norm(a-y)**2\",\n \"def eval_test(self, rng_key, svi_state):\\n def body_fn(i, loss_sum):\\n rng_key_i = random.fold_in(rng_key, i) \\n rng_key_i, rng_key_ls, rng_key_var, rng_key_sigma = random.split(rng_key_i, 4)\\n \\n length_i = numpyro.sample(\\\"length\\\", dist.InverseGamma(1,.1), rng_key=rng_key_ls)\\n var_i = numpyro.sample(\\\"var\\\", dist.LogNormal(0,0.1), rng_key=rng_key_var)\\n sigma_i = numpyro.sample(\\\"noise\\\", dist.HalfNormal(0.1), rng_key=rng_key_sigma)\\n \\n batch = self.gp_predictive(rng_key_i, self.x\\n , ls=length_i, var=var_i, sigma=sigma_i\\n )\\n\\n loss = self.svi.evaluate(svi_state, batch['y']) / self.batch_size\\n loss_sum += loss\\n return loss_sum\\n\\n loss = lax.fori_loop(0, self.num_test, body_fn, 0.0)\\n loss = loss / self.num_test\\n\\n return loss\",\n \"def evaluate(self,x,y):\\n\\n #below function comes from MATLAB Peaks function\\n # return np.multiply(3*np.power((1-x), 2), np.exp(-np.power(x,2) - np.power((y+1), 2))) - np.multiply(10 * (x/5.0 - np.power(x,3) - np.power(y,5)), np.exp(-np.power(x,2)-np.power(y,2)))#- np.exp(-np.power(x+1,2)-np.power(y,2))/3.0\\n # return -np.power((x-50),2) - np.power(y, 2)-3\\n return 5- (np.multiply(np.multiply(np.sin(x), np.sin(y)), np.power(x,2)) + np.power(y,2))\",\n \"def f(m, x, b):\\n return m*x + b\",\n \"def f(x):\\n return math.exp(-x**2)/(1+x**2)+(2*math.cos(x)**2)/(1+(x-4)**2)\",\n \"def zzx_eval(f, x):\\n result = INT_ZERO\\n\\n if not x:\\n return poly_TC(f)\\n\\n for a in f:\\n result *= x\\n result += a\\n\\n return result\",\n \"def scalar_function(x, y):\\n #Your code here\\n if x<=y:\\n fs = x*y\\n else:\\n fs = x/y\\n return fs\\n raise NotImplementedError\",\n \"def f(x, y):\\n raise NotImplementedError\",\n \"def sample2d(f, x_args):\\n try:\\n f = sympify(f)\\n except SympifyError:\\n raise ValueError(\\\"f could not be interpreted as a SymPy function\\\")\\n try:\\n x, x_min, x_max, x_n = x_args\\n except (TypeError, IndexError):\\n raise ValueError(\\\"x_args must be a tuple of the form (var, min, max, n)\\\")\\n\\n x_l = float(x_max - x_min)\\n x_d = x_l/float(x_n)\\n X = np.arange(float(x_min), float(x_max) + x_d, x_d)\\n\\n Y = np.empty(len(X))\\n for i in range(len(X)):\\n try:\\n Y[i] = float(f.subs(x, X[i]))\\n except TypeError:\\n Y[i] = None\\n return X, Y\",\n \"def f1(x, a, b):\\n #return x**43 - b*x**42 + x**7 - x**6 * a + 84*x - 42 * b - 42 * a\\n return (x**42 + 42)/(x-a) + (x**6 + 42)/(x-b)\",\n \"def f(x):\\r\\n\\treturn np.sin(x)\",\n \"def f(x):\\n return (2.0*math.sin(10.0*x+1.0)+1.0)\",\n \"def test_figure34(self):\\n star = 0.1\\n current = 1.37\\n func = lambda x: x**6 + 3 * x - 4\\n\\n logging.info(\\\"\\\\nCONFIRMING FIGURE 3.4\\\")\\n rf_results = undertest.regula_falsi(func, star, current, 100)\",\n \"def test_generate_lambda_alchemical_function(self):\\n from openmmtools.utils import math_eval\\n\\n def evaluate(expr, l):\\n variables = {'lambda': l}\\n return math_eval(expr, variables)\\n\\n # Each test case are [(lambda0, lambda1), (f(lambda0), f([lambda0+lambda1]/2), f(lambda1))]\\n # where the second tuple in the list are the expected values of the function.\\n test_cases = [(0, 1), (1, 0), (2, 3), (3, 2), (4, 8), (10, 5)]\\n\\n for lambda0, lambda1 in test_cases:\\n expr = ExperimentBuilder._generate_lambda_alchemical_function(lambda0, lambda1)\\n print(lambda0, lambda1, ':', expr)\\n assert evaluate(expr, lambda0) == 0.0\\n assert evaluate(expr, (lambda0 + lambda1)/2) == 0.5\\n assert evaluate(expr, lambda1) == 1.0\\n\\n # The funciton must be constant after the end states.\\n if lambda0 < lambda1:\\n assert evaluate(expr, lambda0-1) == 0.0\\n assert evaluate(expr, lambda1+1) == 1.0\\n else:\\n assert evaluate(expr, lambda0+1) == 0.0\\n assert evaluate(expr, lambda1-1) == 1.0\",\n \"def _evaluate(self, x, y, z):\\n if _isscalar(x):\\n f = self.compare([f(x, y, z) for f in self.functions])\\n else:\\n m = len(x)\\n temp = np.zeros((m, self.funcCount))\\n for j in range(self.funcCount):\\n temp[:, j] = self.functions[j](x, y, z)\\n f = self.compare(temp, axis=1)\\n return f\",\n \"def _evaluate(self, x, y, z):\\n if _isscalar(x):\\n y_pos = max(min(np.searchsorted(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(np.searchsorted(self.z_list, z), self.z_n - 1), 1)\\n alpha = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n beta = (z - self.z_list[z_pos - 1]) / (\\n self.z_list[z_pos] - self.z_list[z_pos - 1]\\n )\\n f = (\\n (1 - alpha) * (1 - beta) * self.xInterpolators[y_pos - 1][z_pos - 1](x)\\n + (1 - alpha) * beta * self.xInterpolators[y_pos - 1][z_pos](x)\\n + alpha * (1 - beta) * self.xInterpolators[y_pos][z_pos - 1](x)\\n + alpha * beta * self.xInterpolators[y_pos][z_pos](x)\\n )\\n else:\\n m = len(x)\\n y_pos = np.searchsorted(self.y_list, y)\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n y_pos[y_pos < 1] = 1\\n z_pos = np.searchsorted(self.z_list, z)\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n z_pos[z_pos < 1] = 1\\n f = np.zeros(m) + np.nan\\n for i in range(1, self.y_n):\\n for j in range(1, self.z_n):\\n c = np.logical_and(i == y_pos, j == z_pos)\\n if np.any(c):\\n alpha = (y[c] - self.y_list[i - 1]) / (\\n self.y_list[i] - self.y_list[i - 1]\\n )\\n beta = (z[c] - self.z_list[j - 1]) / (\\n self.z_list[j] - self.z_list[j - 1]\\n )\\n f[c] = (\\n (1 - alpha)\\n * (1 - beta)\\n * self.xInterpolators[i - 1][j - 1](x[c])\\n + (1 - alpha) * beta * self.xInterpolators[i - 1][j](x[c])\\n + alpha * (1 - beta) * self.xInterpolators[i][j - 1](x[c])\\n + alpha * beta * self.xInterpolators[i][j](x[c])\\n )\\n return f\",\n \"def funcv(x):\\n f0 = x[0] ** 3.0 + x[1] + 3.0\\n f1 = x[1] - 4.0 * x[0]\\n return f0, f1\",\n \"def get_func_eval(self, x_vals: X):\\n return np.dot(self.get_feature_vals(x_vals), self.params[0])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8462733","0.8068793","0.8034158","0.7850618","0.7745526","0.76073825","0.7115134","0.6986317","0.66636187","0.6654048","0.64210814","0.63877445","0.6360093","0.6220911","0.6102655","0.6082553","0.60335815","0.60012615","0.5903432","0.57977605","0.57917017","0.5787892","0.57862943","0.57797426","0.577615","0.57686275","0.5743363","0.5735257","0.5732621","0.57299864","0.57162756","0.57084805","0.57064605","0.5703499","0.5678577","0.5653015","0.5651281","0.56491894","0.5645624","0.5642649","0.5641317","0.5636284","0.56327814","0.5632676","0.56156284","0.560781","0.5596491","0.5579161","0.55667526","0.5559774","0.5554986","0.5545269","0.55371004","0.5526197","0.55227035","0.55215794","0.5518748","0.55084085","0.55042124","0.5501571","0.55003536","0.5494237","0.5489224","0.5486355","0.54861873","0.54861414","0.54812044","0.5471563","0.54699206","0.5464915","0.54641443","0.5455582","0.5453464","0.54504585","0.5449985","0.54439914","0.54394823","0.54393685","0.54393685","0.54393685","0.54393685","0.5434031","0.5430471","0.5426549","0.542023","0.54182833","0.54155225","0.54118687","0.5399332","0.53951836","0.5395039","0.53904116","0.5389672","0.53882104","0.5386777","0.5383731","0.53795093","0.5376736","0.5376078","0.5372334"],"string":"[\n \"0.8462733\",\n \"0.8068793\",\n \"0.8034158\",\n \"0.7850618\",\n \"0.7745526\",\n \"0.76073825\",\n \"0.7115134\",\n \"0.6986317\",\n \"0.66636187\",\n \"0.6654048\",\n \"0.64210814\",\n \"0.63877445\",\n \"0.6360093\",\n \"0.6220911\",\n \"0.6102655\",\n \"0.6082553\",\n \"0.60335815\",\n \"0.60012615\",\n \"0.5903432\",\n \"0.57977605\",\n \"0.57917017\",\n \"0.5787892\",\n \"0.57862943\",\n \"0.57797426\",\n \"0.577615\",\n \"0.57686275\",\n \"0.5743363\",\n \"0.5735257\",\n \"0.5732621\",\n \"0.57299864\",\n \"0.57162756\",\n \"0.57084805\",\n \"0.57064605\",\n \"0.5703499\",\n \"0.5678577\",\n \"0.5653015\",\n \"0.5651281\",\n \"0.56491894\",\n \"0.5645624\",\n \"0.5642649\",\n \"0.5641317\",\n \"0.5636284\",\n \"0.56327814\",\n \"0.5632676\",\n \"0.56156284\",\n \"0.560781\",\n \"0.5596491\",\n \"0.5579161\",\n \"0.55667526\",\n \"0.5559774\",\n \"0.5554986\",\n \"0.5545269\",\n \"0.55371004\",\n \"0.5526197\",\n \"0.55227035\",\n \"0.55215794\",\n \"0.5518748\",\n \"0.55084085\",\n \"0.55042124\",\n \"0.5501571\",\n \"0.55003536\",\n \"0.5494237\",\n \"0.5489224\",\n \"0.5486355\",\n \"0.54861873\",\n \"0.54861414\",\n \"0.54812044\",\n \"0.5471563\",\n \"0.54699206\",\n \"0.5464915\",\n \"0.54641443\",\n \"0.5455582\",\n \"0.5453464\",\n \"0.54504585\",\n \"0.5449985\",\n \"0.54439914\",\n \"0.54394823\",\n \"0.54393685\",\n \"0.54393685\",\n \"0.54393685\",\n \"0.54393685\",\n \"0.5434031\",\n \"0.5430471\",\n \"0.5426549\",\n \"0.542023\",\n \"0.54182833\",\n \"0.54155225\",\n \"0.54118687\",\n \"0.5399332\",\n \"0.53951836\",\n \"0.5395039\",\n \"0.53904116\",\n \"0.5389672\",\n \"0.53882104\",\n \"0.5386777\",\n \"0.5383731\",\n \"0.53795093\",\n \"0.5376736\",\n \"0.5376078\",\n \"0.5372334\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7887029"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":93696,"cells":{"query":{"kind":"string","value":"Given an input value in the interval [input_interval_start, input_interval_end], return an output value scaled to fall within the output interval [output_interval_start, output_interval_end]."},"document":{"kind":"string","value":"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 length of target interval\n scaledvalue = float(val) - input_interval_start #finds how far through the interval the value is \n value = ( scaledvalue / inputrange ) * outputrange + output_interval_start\n return value"},"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 remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n convert = float (val - input_interval_start) / float ( input_interval_end - input_interval_start)\n output1 = output_interval_start + convert* (output_interval_end - output_interval_start)\n return output1","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n \n return ((float(val-input_interval_start) * (output_interval_end-output_interval_start)) / (input_interval_end-input_interval_start)) + output_interval_start","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n return (val - input_interval_start)/float(input_interval_end - input_interval_start)*(\n output_interval_end - output_interval_start) + output_interval_start","def remap(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n weight_end = float(val-input_interval_start)/(input_interval_end-input_interval_start)\n weight_start = float(input_interval_end-val)/(input_interval_end-input_interval_start)\n\n return (weight_end*output_interval_end)+(weight_start*output_interval_start)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n x=(float(val)-float(input_interval_start))\n y=(float(input_interval_end)-float(input_interval_start))\n z=x/y\n return output_interval_start+(z*(output_interval_end-output_interval_start))","def remap_interval(val, in_start, in_end, out_start, out_end):\n in_range = in_end-in_start\n out_range = out_end-out_start\n return (val-in_start)/in_range*out_range+out_start","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n\n\t# shift the zero\n\tzero = (output_interval_start - input_interval_start)\n\t\n\t# stretch/compress after shifting\n\tchange_factor = float(output_interval_end)/ (input_interval_end + zero)\n\n\t# apply stretching/compression\n\tnew_value = (val+zero)*change_factor\n\n\treturn new_value","def remap_interval(val,\n input_interval_start,\n input_interval_end,\n output_interval_start,\n output_interval_end):\n if val is not None:\n # make sure it stays as a float\n ratio = 1.0*(val - input_interval_start)\n ratio = ratio / (input_interval_end - input_interval_start)\n num = ratio * (output_interval_end - output_interval_start)\n num += output_interval_start\n return num\n else:\n return 0","def translate(value, input_min, input_max, output_min, output_max):\n # Figure out how 'wide' each range is\n input_span = input_max - input_min\n output_span = output_max - output_min\n\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - input_min) / float(input_span)\n\n # Convert the 0-1 range into a value in the right range.\n return output_min + (value_scaled * output_span)","def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n # your code goes here","def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))","def scaled(values, output_min, output_max, input_min=0, input_max=1):\n values = _normalize(values)\n if input_min >= input_max:\n raise ValueError('input_min must be smaller than input_max')\n input_size = input_max - input_min\n output_size = output_max - output_min\n for v in values:\n yield (((v - input_min) / input_size) * output_size) + output_min","def scale_range(x, input_range, target_range):\n\n range = [np.amin(x), np.amax(x)]\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\n return x_scaled, range","def mapVal(inputPos, in_min, in_max, out_min, out_max):\n \n \n scale = ((out_max - out_min) / (in_max - in_min))\n return float(((inputPos - in_min) * scale) + out_min)","def mapped(val, in_min, in_max, out_min, out_max):\n return (val - in_min) * (out_max - out_min) / \\\n (in_max - in_min) + out_min","def map_range(x, in_min, in_max, out_min, out_max):\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\n if out_min <= out_max:\n return max(min(mapped, out_max), out_min)\n return min(max(mapped, out_max), out_min)","def map(value, in_low, in_high, out_low, out_high):\n # example from /animation_nodes/nodes/number/map_range.py\n # if inMin == inMax:\n # newValue = 0\n # # with clamping\n # if inMin < inMax:\n # _value = min(max(value, inMin), inMax)\n # else:\n # _value = min(max(value, inMax), inMin)\n # with interpolation\n # newValue = outMin + interpolation(\n # (_value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # without interpolation\n # newValue = outMin + (\n # (_value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # # without clamping\n # newValue = outMin + (\n # (value - inMin) / (inMax - inMin)\n # ) * (outMax - outMin)\n # # without clamping - reworded\n # result = (\n # (\n # ((value - in_low) / (in_high - in_low)) *\n # (out_high - out_low)\n # ) + out_low\n # )\n\n result = None\n\n # based on http://arduino.cc/en/Reference/Map\n # and http://stackoverflow.com/a/5650012/574981\n result = (\n (\n ((value - in_low) * (out_high - out_low)) /\n (in_high - in_low)\n ) + out_low\n )\n\n return result","def linearscale(input, boundfrom, boundto, extrema=None):\n\n\tminfrom,maxfrom = boundfrom\n\tminto,maxto = boundto\n\n\t### default from bounds are min,max of the input\n\tif minfrom is None:\n\t\tif extrema:\n\t\t\tminfrom = extrema[0]\n\t\telse:\n\t\t\tminfrom = arraystats.min(input)\n\tif maxfrom is None:\n\t\tif extrema:\n\t\t\tmaxfrom = extrema[1]\n\t\telse:\n\t\t\tmaxfrom = arraystats.max(input)\n\n\trangefrom = maxfrom - minfrom\n\tif rangefrom == 0:\n\t\t# if min==max, do simple thresholding\n\t\toutput = numpy.where(input>maxfrom, maxto, minto)\n\telse:\n\t\trangeto = maxto - minto\n\t\tscale = float(rangeto) / rangefrom\n\t\toffset = minfrom * scale\n\t\toutput = input * scale - offset\n\n\treturn output","def scale(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def scale(val, src, dst):\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def map_to_range(val, old_min, old_max, new_min, new_max):\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)","def scale_value(value, ip_range, domain=(0,1)):\n x1, x2 = domain\n y1, y2 = ip_range\n\n assert(y1 <= value <= y2)\n\n m = (x2 - x1)/(y2 - y1)\n b = y1 - m * x1\n return m * value - b","def scale(val, src, dst):\r\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]\n # pass","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]","def scale(x, minimum, maximum):\n return (x - minimum) / (maximum - minimum)","def scale(self, value):\n return (float(value) - float(self.minimum)) / \\\n float(self.maximum - self.minimum) * 2.0 - 1.0","def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0","def translate(value, from_min, from_max, to_min, to_max):\n # Figure out how 'wide' each range is\n left_span = from_max - from_min\n right_span = to_max - to_min\n\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - from_min) / float(left_span)\n\n # Convert the 0-1 range into a value in the right range.\n return to_min + (value_scaled * right_span)","def scale(val, src, dst):\n try:\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\n except ZeroDivisionError:\n return 0.0","def rescale(num, old_min, old_max, new_min, new_max):\n old_range = old_max - old_min\n new_range = new_max - new_min\n new_val = new_min + (((num - old_min) * new_range)/old_range)\n\n return new_val","def normalize_index(x, input_scale, output_scale):\n return np.round(x / input_scale[2] * output_scale[2])","def scale(self, value):\n\t\toldscale = self.oldmax - self.oldmin\n\t\tnewscale = self.newmax - self.newmin\n\t\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin","def scale(inp: np.ndarray, new_min: float = 0., new_max: float = 1.,\n axis: int = -1) -> np.ndarray:\n xmax = inp.max(axis=axis, keepdims=True)\n xmin = inp.min(axis=axis, keepdims=True)\n a = (inp-xmin) / (xmax - xmin)\n y = a * (new_max - new_min) + new_min\n return y","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def map_between(value, start, stop):\n\n return (stop - start) * value + start","def adjust_dynamic_range(data, drange_in=(-1, 1), drange_out=(0, 1)):\r\n if drange_in != drange_out:\r\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\r\n np.float32(drange_in[1]) - np.float32(drange_in[0]))\r\n bias = (np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale)\r\n data = data * scale + bias\r\n return torch.clamp(data, min=0, max=1)","def scale_floor(value, old_max, new_max):\n\tassert value >= 0\n\tassert value <= old_max\n\treturn new_max * value / old_max","def rescale(range1, range2):\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\n def resize(value):\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\n return resize","def map_bound(value, in_low, in_high, out_low, out_high):\n result = None\n\n if value <= in_low:\n result = out_low\n else:\n if value >= in_high:\n result = out_high\n else:\n # http://stackoverflow.com/a/5650012/574981\n result = out_low + (\n (out_high - out_low) * (value - in_low) / (in_high - in_low)\n )\n return result","def adjust_uh_timestep(unit_hydrograph, t_uh, input_interval, output_interval, x_inds, y_inds):\n if output_interval == input_interval:\n log.debug('No need to aggregate (output_interval = input_interval) \\\n Skipping the adjust_uh_timestep step')\n uh_out = unit_hydrograph\n ts_new = np.arange(t_uh)\n elif np.remainder(output_interval, input_interval) == 0:\n log.debug('Aggregating to %i from %i seconds' % (output_interval, input_interval))\n fac = int(output_interval/input_interval)\n t_uh_out = int(t_uh/fac)\n ts_new = np.arange(t_uh_out)\n uh_out = np.zeros((t_uh_out, unit_hydrograph.shape[1], unit_hydrograph.shape[2]))\n for (y, x) in zip(y_inds, x_inds):\n for t in xrange(t_uh_out):\n uh_out[t, y, x] = np.sum(unit_hydrograph[t*fac:t*fac+fac, y, x])\n elif np.remainder(input_interval, output_interval):\n log.debug('Interpolating unit hydrograph from input_interval: %i to output_interval: %i' % (input_interval, output_interval))\n fac = int(input_interval / output_interval)\n t_uh_out = int(t_uh * fac)\n uh_out = np.zeros((t_uh_out, unit_hydrograph.shape[1], unit_hydrograph.shape[2]))\n ts_orig = np.linspace(0, t_uh, t_uh)\n ts_new = np.linspace(0, t_uh, t_uh_out)\n for (y, x) in zip(y_inds, x_inds):\n f = interp1d(ts_orig, unit_hydrograph[:, y, x])\n uh_out[:, y, x] = f(ts_new)\n return uh_out, ts_new","def translate(value, leftMin, leftMax, rightMin, rightMax):\n # Figure out how 'wide' each range is\n leftSpan = leftMax - leftMin\n rightSpan = rightMax - rightMin\n\n # Convert the left range into a 0-1 range (float)\n valueScaled = float(value - leftMin) / float(leftSpan)\n\n # Convert the 0-1 range into a value in the right range.\n return rightMin + (valueScaled * rightSpan)","def adjust_dynamic_range(\n data: np.array,\n drange_in: Tuple[int, int],\n drange_out: Tuple[int, int],\n slack: bool = False,\n) -> np.array:\n\n if drange_in != drange_out:\n if not slack:\n old_min, old_max = np.float32(drange_in[0]), np.float32(drange_in[1])\n new_min, new_max = np.float32(drange_out[0]), np.float32(drange_out[1])\n data = (\n (data - old_min) / (old_max - old_min) * (new_max - new_min)\n ) + new_min\n else:\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\n np.float32(drange_in[1]) - np.float32(drange_in[0])\n )\n bias = np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale\n data = data * scale + bias\n data = np.clip(data, a_min=drange_out[0], a_max=drange_out[1])\n return data","def scale(a, tmin=0.0, tmax=1.0):\n return np.interp(a, (a.min(), a.max()), (tmin, tmax))","def simple_scaling(input_data):\n\n # Insert debugging assertions\n assert type(input_data) is np.ndarray, \"The 'input_data' must be numpy array.\"\n\n # Get the minimum values of the input numpy array along the axis \n Max = np.max(input_data, axis = 0)\n\n # Simple sclaing \n scaled_input_data = input_data / (Max + sys.float_info.min)\n\n # Return scaled input data\n return scaled_input_data","def __normalize(self, value, lower_bound, upper_bound):\n\n min_max_diff = self.max - self.min\n bound_diff = upper_bound - lower_bound\n return (value - self.min) / min_max_diff * bound_diff + lower_bound","def scale_image(image, new_range):\n min_val = np.min(image).astype(np.float32)\n max_val = np.max(image).astype(np.float32)\n min_val_new = np.array(min(new_range), dtype=np.float32)\n max_val_new = np.array(max(new_range), dtype=np.float32)\n scaled_image = (image - min_val) / (max_val - min_val) * (max_val_new - min_val_new) + min_val_new\n return scaled_image.astype(np.uint8)","def scale(x, feature_range=(-1,1)):\r\n x = x * 2 - 1\r\n return x","def normalise_modular_range(value, min, max):\n return numpy.mod(value-min, max-min)+min","def scale_range(data, minTo, maxTo):\n minFrom = np.min(data)\n maxFrom = np.max(data)\n \n scaled_data = []\n \n for point in data:\n new_point = minTo + (maxTo - minTo) * ((point - minFrom)/(maxFrom - minFrom))\n scaled_data.append(new_point)\n \n return scaled_data","def translate(self, value, left_min, left_max, right_min=None, right_max=None):\n if right_min is None:\n right_min = self.values['pulse_min'].data\n if right_max is None:\n right_max = self.values['pulse_max'].data\n # Figure out how 'wide' each range is\n left_span = left_max - left_min\n right_span = right_max - right_min\n # Convert the left range into a 0-1 range (float)\n value_scaled = float(value - left_min) / float(left_span)\n # Convert the 0-1 range into a value in the right range.\n return int(right_min + (value_scaled * right_span))","def scaleValues(values):\n\n values = values - values.min()\n return values/values.max()","def normalize_value_range(image,\n vmin = -1,\n vmax = 1,\n in_min = 0,\n in_max = 255.0,\n clip_values = False):\n if in_min >= in_max or vmin >= vmax:\n raise ValueError('min must be strictly less than max')\n\n in_min_t = tf.constant(in_min, tf.float32)\n in_max_t = tf.constant(in_max, tf.float32)\n image = tf.cast(image, tf.float32)\n image = (image - in_min_t) / (in_max_t - in_min_t)\n image = vmin + image * (vmax - vmin)\n if clip_values:\n image = tf.clip_by_value(image, vmin, vmax)\n return image","def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\n return new_value","def compute_interpolation_weights(out_size, in_size, scale):\n # lower, upper, lerp\n res = [[0, 0, 0] for _ in range(out_size + 1)]\n for i in range(out_size - 1, -1, -1):\n val = i * scale\n res[i][0] = int(val)\n res[i][1] = min(res[i][0] + 1, in_size - 1)\n res[i][2] = val - int(val)\n return res","def _scalar_conversion(self, p_input:float) -> float:\n return (p_input/self.units[self._unit_in]*self.units[self._unit_out])","def scale(input_img, size):\n width, height = size\n old_height, old_width = input_img.shape\n x_scale = float(height) / old_height\n y_scale = float(width) / old_width\n\n output_img = np.zeros((height, width), dtype=np.uint8)\n for xidx in xrange(height):\n old_x = float(xidx) / x_scale\n for yidx in xrange(width):\n old_y = float(yidx) / y_scale\n if old_x.is_integer() or old_y.is_integer():\n output_img[xidx, yidx] = input_img[int(old_x), int(old_y)]\n else: # use bilinear interpolation\n x1 = int(np.floor(old_x))\n x2 = int(np.ceil(old_x)) if int(np.ceil(old_x)) < old_height else old_height - 1\n y1 = int(np.floor(old_y))\n y2 = int(np.ceil(old_y)) if int(np.ceil(old_y)) < old_width else old_width - 1\n\n q11 = input_img[x1, y1]\n q12 = input_img[x1, y2]\n q21 = input_img[x2, y1]\n q22 = input_img[x2, y2]\n\n output_img[xidx, yidx] = (q11 * (x2 - old_x) * (y2 - old_y)\n + q21 * (old_x - x1) * (y2 - old_y)\n + q12 * (x2 - old_x) * (old_y - y1)\n + q22 * (old_x - x1) * (old_y - y1)) \\\n / ((x2 - x1) * (y2 - y1) + 1e-10)\n\n return output_img","def task_scaling(input_array, scaling_factor):\n return(np.multiply(scaling_factor, input_array))","def scale(arrayin,Amin,Amax,mask=None):\r\n if (mask==None) and (arrayin.max() - arrayin.min())!=0.0 :\r\n Bmax = arrayin.max()\r\n Bmin = arrayin.min()\r\n elif (arrayin.max() - arrayin.min())!=0.0 :\r\n ny = arrayin.shape[0]\r\n nx = arrayin.shape[1]\r\n Bmax = arrayin.min()\r\n Bmin = arrayin.max()\r\n for i in range(ny):\r\n for j in range(ny):\r\n if mask[i,j] > 0.5e0 :\r\n if arrayin[i,j] < Bmin :\r\n Bmin = arrayin[i,j]\r\n if arrayin[i,j] > Bmax :\r\n Bmax = arrayin[i,j]\r\n else :\r\n print \"andrew.bagOfns.scale : warning (arrayin.max() - arrayin.min())=0.0 \"\r\n return np.copy(arrayin)\r\n\r\n arrayout = (arrayin - Bmin)*(Amax - Amin) / (Bmax - Bmin) + Amin\r\n return arrayout","def scale(x, a=5, b=10, xmin=-1, xmax=1):\n return (b - a)*(x - xmin)/(xmax - xmin) + a","def rescale(x):\n if x.min() != 0:\n raise ValueError('input should have min zero.')\n\n x /= x.max() # max 1\n x *= 2 # max 2\n x -= 1 # range -1, 1\n\n if x.min() != -1 and x.max() != 1:\n raise Exception\n\n return x","def scale(df, lower=-1, upper=1):\n\n scaler = MinMaxScaler(feature_range=(lower, upper))\n scaler = scaler.fit(df)\n\n # Replace values with the scaled dataframe\n df[['Input', 'Output']] = scaler.transform(df)\n\n return df","def scale_to_unit_interval(ndar, eps=1e-8):\r\n ndar = ndar.copy()\r\n ndar -= ndar.min()\r\n ndar *= 1.0 / (ndar.max() + eps)\r\n return ndar","def lin_scale( val, x1, y1, x2, y2 ):\r\n x_range = (x2 - x1)\r\n new_val = 0\r\n if x_range is 0:\r\n new_val = y1\r\n else:\r\n y_range = ( y2 - y1 )\r\n new_val = ( ( ( val - x1 ) * y_range ) / x_range ) + y1\r\n\r\n return new_val","def normalize(x, x_max, x_min):\n return (x - x_min) / (x_max - x_min)","def scale_servos(self, value, minrange=500, maxrange=2500):\n min_servo_range = -1\n max_servo_range = 1\n return min_servo_range + (max_servo_range - min_servo_range) / (maxrange - minrange) * (value - minrange)","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def unit_scale(x, eps=1e-8):\n\tx = x.copy()\n\tx -= x.min()\n\tx *= 1.0 / (x.max() + eps)\n\treturn x","def remap(self, value, from1, to1, from2, to2):\n return from2 + (value - from1) * (to2 - from2) / (to1 - from1)","def integrand_normalization(weight_function, intervals):\n\n def constant_rate(t):\n return 1.0\n\n return average_over_interval(constant_rate, weight_function, intervals)","def scale(x_range=1, y_range=1):\r\n x = rand_val(x_range)\r\n y = rand_val(y_range)\r\n return np.array(((x, 0, 0),\r\n (0, y, 0),\r\n (0, 0, 1)), dtype=np.float)","def shrink_image(image, output_size, interp_type=InterpolationType.INTEGRAL, output=None):\n\n if isinstance(output_size, (int, int)):\n scale = float(output_size) / max(image.getWidth(), image.getHeight())\n output_shape = (int(image.getHeight()*scale), int(image.getWidth()*scale))\n else:\n output_shape = output_size\n\n if image.getWidth() < output_shape[1] or image.getHeight() < output_shape[0]:\n raise RuntimeError(\"Either width or height is larger in output than input\")\n\n if output is None:\n output = image.createNew(output_shape[1], output_shape[0])\n else:\n output.reshape(output_shape[1], output_shape[0])\n\n if interp_type == InterpolationType.INTEGRAL:\n pbg.gateway.jvm.boofcv.alg.filter.misc.AverageDownSampleOps.down(image, output)\n else:\n scale_x = output_shape[1] / float(image.getWidth())\n scale_y = output_shape[0] / float(image.getHeight())\n\n fdist = pbg.gateway.jvm.boofcv.abst.distort.FDistort(image, output)\n fdist.interp(interpolation_type_to_java(interp_type))\n fdist.affine(scale_x, 0.0, 0.0, scale_y, 0.0, 0.0)\n fdist.apply()\n\n return output","def win_scale(data, wl, ww, dtype, out_range):\n\n data_new = np.empty(data.shape, dtype=np.double)\n data_new.fill(out_range[1] - 1)\n\n data_new[data <= (wl - ww / 2.0)] = out_range[0]\n data_new[(data > (wl - ww / 2.0)) & (data <= (wl + ww / 2.0))] = \\\n ((data[(data > (wl - ww / 2.0)) & (data <= (wl + ww / 2.0))] - (wl - 0.5)) / (ww - 1.0) + 0.5) * (\n out_range[1] - out_range[0]) + out_range[0]\n data_new[data > (wl + ww / 2.0)] = out_range[1] - 1\n\n return data_new.astype(dtype)","def _min_max_scale(arr, new_range=(0, 255)):\n # get array's current min and max\n mn = arr.min()\n mx = arr.max()\n\n # check if scaling needs to be done to be in new_range\n if mn < new_range[0] or mx > new_range[1]:\n # perform min-max scaling\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\n else:\n # return array if already in range\n scaled = arr\n\n return scaled","def scale(image, maxval=1024):\n image += maxval # minimum value is now 0\n image /= maxval*2\n\n return(image)","def scale_to_unit_interval(ndar, eps=1e-8):\n ndar = ndar.copy()\n ndar -= ndar.min()\n ndar = ndar*1.0 / (ndar.max() + eps)\n return ndar","def normalize_data(data, min=0, max=1):\r\n import numpy as np\r\n assert isinstance(data, np.ndarray)\r\n\r\n max_value = np.max(data)\r\n min_value = np.min(data)\r\n\r\n scaled = np.interp(data, [min_value, max_value], [min, max])\r\n # convert to float64\r\n scaled = scaled.astype(np.float64)\r\n\r\n return scaled","def scale_to_unit_interval(self,ndar, eps=1e-8):\n ndar = np.float64(ndar.copy())\n ndar -= ndar.min()\n ndar *= 1.0 / (ndar.max() + eps)\n return ndar","def rescale(self, xmin, xmax):\n\n # Normalise\n self.normalise()\n\n \n # Rescale\n range = xmax-xmin\n for seg in self.segments:\n seg.lower_bound = seg.lower_bound*range + xmin\n seg.upper_bound = seg.upper_bound*range + xmin","def normalizeToRange(v, a, b):\n return (v - a) / (b - a)","def convert_scale(g, op, block):\n\n scale = op.attr(\"scale\")\n bias = op.attr(\"bias\")\n bias_after_scale = op.attr(\"bias_after_scale\")\n x = g.get_node(op.input(\"X\")[0])\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\n out = x\n else:\n if np.isclose(bias, 0.0):\n out = x * _expr.const(np.array(scale).astype(\"float32\"))\n elif np.isclose(scale, 1.0):\n out = x + _expr.const(np.array(bias).astype(\"float32\"))\n else:\n if bias_after_scale:\n out = x * _expr.const(np.array(scale).astype(\"float32\")) + _expr.const(\n np.array(bias).astype(\"float32\")\n )\n else:\n out = (x + _expr.const(np.array(bias).astype(\"float32\"))) * _expr.const(\n np.array(scale).astype(\"float32\")\n )\n g.add_node(op.output(\"Out\")[0], out)","def normalize(x, min_x, max_x):\n\treturn (x - min_x) / (max_x - min_x)","def math_map(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def scale_ceil(value, old_max, new_max):\n\tassert value >= 0\n\tassert value <= old_max\n\treturn div_ceil(new_max * value, old_max)","def get_amount_out(amount_in, reserve_in, reserve_out):\n assert amount_in > 0\n assert reserve_in > 0 and reserve_out > 0\n amount_in_with_fee = amount_in*997\n numerator = amount_in_with_fee*reserve_out\n denominator = reserve_in*1000 + amount_in_with_fee\n return float(numerator/denominator)","def scale_between(minval, maxval, numStops):\n\n scale = []\n\n if numStops < 2:\n return [minval, maxval]\n elif maxval < minval:\n raise ValueError()\n else:\n domain = maxval - minval\n interval = float(domain) / float(numStops)\n for i in range(numStops):\n scale.append(round(minval + interval * i, 2))\n return scale","def RescaleByInterval(inputgdf, rescaledf, rescalefield, fillnaval=1):\n close = 'left' if rescaledf.iloc[0, 0] == 0 else 'right'\n rescale_interval = pd.IntervalIndex.from_arrays(rescaledf.iloc[:, 0], rescaledf.iloc[:, 1], closed=close)\n rescale_series = pd.cut(inputgdf[rescalefield], rescale_interval).cat.\\\n rename_categories(np.asarray(rescaledf.iloc[:, 2]))\n if rescale_series.isna().values.any():\n rescale_series.fillna(fillnaval, inplace=True)\n else:\n pass\n return rescale_series.astype(int)","def scale_to_baseline(X, baseline=None, crop_baseline=False):\n #X = X_.copy()\n\n if baseline is None:\n print(\"No baseline interval specified, sacling based on the whole epoch\")\n interval = np.arange(X.shape[-1])\n elif isinstance(baseline, tuple):\n print(\"Scaling to interval {:.1f} - {:.1f}\".format(*baseline))\n interval = np.arange(baseline[0], baseline[1])\n X0m = X[..., interval].mean(axis=2, keepdims=True)\n X0sd = X[..., interval].std(axis=(1,2), keepdims=True)\n\n X -= X0m\n X /= X0sd\n if crop_baseline and baseline is not None:\n X = np.delete(X, interval, axis=-1)\n #print(\"Scaling Done\")\n return X","def ramped_signal(start, end, time_interval, signal_start, signal_end, min_rate, max_rate, ramp_duration):\n\n if len(ramp_duration) > 2:\n raise UserWarning('Specify two ramps only (start and end).')\n\n if ramp_duration[0] is not None and ramp_duration[0] < time_interval:\n raise ValueError(\"The start ramp is shorter than the time interval. Specify either a bigger ramp or supply a \"\n \"higher resolution time series (`t')\")\n\n if ramp_duration[1] is not None and ramp_duration[1] < time_interval:\n raise ValueError(\"The end ramp is shorter than the time interval. Specify either a bigger ramp or supply a \"\n \"higher resolution time series (`t')\")\n\n start_datetime = datetime.strptime(start, '%Y-%m-%d %H:%M:%S')\n end_datetime = datetime.strptime(end, '%Y-%m-%d %H:%M:%S')\n run_duration = (end_datetime - start_datetime).days\n start_signal_datetime = datetime.strptime(signal_start, '%Y-%m-%d %H:%M:%S')\n end_signal_datetime = datetime.strptime(signal_end, '%Y-%m-%d %H:%M:%S')\n\n t = []\n for d in np.arange(run_duration):\n for h in np.arange(0, 1 - time_interval, time_interval):\n t.append(start_datetime + timedelta(days=float(d), hours=float(h) * 24.0))\n # Add the end of the requested period to the list and convert to array.\n t.append(end_datetime)\n t = np.asarray(t)\n\n signal = np.repeat(min_rate, len(t)).astype(float)\n\n if ramp_duration[0] is None:\n signal_start_index_offset = 0\n else:\n signal_start_index_offset = np.ceil(ramp_duration[0] / time_interval).astype(int)\n\n if ramp_duration[-1] is None:\n signal_end_index_offset = len(t) - 1\n elif ramp_duration[-1] < 0:\n signal_end_index_offset = signal_start_index_offset\n else:\n signal_end_index_offset = np.ceil(ramp_duration[-1] / time_interval).astype(int)\n\n start_index = np.argmin([np.abs((tt - start_signal_datetime).total_seconds()) for tt in t])\n start_max_index = start_index + signal_start_index_offset\n end_index = np.argmin([np.abs((tt - end_signal_datetime).total_seconds()) for tt in t])\n end_max_index = np.min((end_index + signal_end_index_offset, len(signal) - 1))\n\n hyperbolic_start = np.arange(-signal_start_index_offset / 2, signal_start_index_offset / 2)\n hyperbolic_end = np.arange(-signal_start_index_offset / 2, signal_end_index_offset / 2)\n ramp_start = np.tanh((hyperbolic_start / signal_start_index_offset) * np.pi * 2)\n ramp_end = np.tanh((hyperbolic_end / signal_end_index_offset) * np.pi * 2)\n if np.any(ramp_start):\n ramp_start = fix_range(ramp_start, min_rate, max_rate)\n if np.any(ramp_end):\n ramp_end = fix_range(ramp_end, min_rate, max_rate)\n\n signal[start_index:start_max_index] = ramp_start\n # If the end indices are the same, assume we're just running the signal to the end, otherwise taper it with the\n # reverse of the ramp up.\n if end_index != end_max_index:\n signal[start_max_index:end_index] = max_rate\n signal[end_index:end_max_index] = ramp_end[::-1]\n else:\n signal[start_max_index:end_index + 1] = max_rate\n\n return t, signal","def remap(\n n: int, start1: int, stop1: int, start2: int, stop2: int, withinBounds: bool = True\n) -> int:\n newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2\n if not withinBounds:\n return newval\n if start2 < stop2:\n return constrain(newval, start2, stop2)\n else:\n return constrain(newval, stop2, start2)","def stretch_image(img, max_val):\n\n @_decorate_validation\n def validate_input():\n _numeric('img', 'floating', shape=(-1, -1))\n _numeric('max_val', ('integer', 'floating'), range_='(0;inf)')\n\n validate_input()\n\n min_ = img.min()\n max_ = img.max()\n\n if max_ > min_:\n val = max_val / (max_ - min_) * (img - min_)\n else:\n val = img - min_\n\n return val","def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")","def dim_unit_scaling(in_unit, out_unit):\n\n unit_vals = {\n 'nm': 1e-9,\n 'um': 1e-6,\n 'mm': 1e-3,\n 'cm': 1e-2,\n 'm': 1.0,\n 'km': 1e3,\n }\n\n if in_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n if out_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n\n return unit_vals[in_unit]/unit_vals[out_unit]","def cv_compute_interpolation_weights(out_size, in_size, scale):\n # lower, upper, lerp\n res = [[0, 0, 0] for _ in range(out_size + 1)]\n res[-1] = [0, 0]\n for i in range(out_size - 1, -1, -1):\n val = (i + 0.5) * scale - 0.5\n res[i][0] = max(0, int(val))\n res[i][1] = min(res[i][0] + 1, in_size - 1)\n res[i][2] = max(0, val - int(val))\n return res","def __init__(self, min_value=0.0, max_value=1.0, input_name=\"image\", output_name=\"image\"):\n super().__init__(input_name=input_name, output_names=[output_name])\n self.min_value = min_value\n self.max_value = max_value"],"string":"[\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n convert = float (val - input_interval_start) / float ( input_interval_end - input_interval_start)\\n output1 = output_interval_start + convert* (output_interval_end - output_interval_start)\\n return output1\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n \\n return ((float(val-input_interval_start) * (output_interval_end-output_interval_start)) / (input_interval_end-input_interval_start)) + output_interval_start\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n return (val - input_interval_start)/float(input_interval_end - input_interval_start)*(\\n output_interval_end - output_interval_start) + output_interval_start\",\n \"def remap(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n weight_end = float(val-input_interval_start)/(input_interval_end-input_interval_start)\\n weight_start = float(input_interval_end-val)/(input_interval_end-input_interval_start)\\n\\n return (weight_end*output_interval_end)+(weight_start*output_interval_start)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n x=(float(val)-float(input_interval_start))\\n y=(float(input_interval_end)-float(input_interval_start))\\n z=x/y\\n return output_interval_start+(z*(output_interval_end-output_interval_start))\",\n \"def remap_interval(val, in_start, in_end, out_start, out_end):\\n in_range = in_end-in_start\\n out_range = out_end-out_start\\n return (val-in_start)/in_range*out_range+out_start\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n\\n\\t# shift the zero\\n\\tzero = (output_interval_start - input_interval_start)\\n\\t\\n\\t# stretch/compress after shifting\\n\\tchange_factor = float(output_interval_end)/ (input_interval_end + zero)\\n\\n\\t# apply stretching/compression\\n\\tnew_value = (val+zero)*change_factor\\n\\n\\treturn new_value\",\n \"def remap_interval(val,\\n input_interval_start,\\n input_interval_end,\\n output_interval_start,\\n output_interval_end):\\n if val is not None:\\n # make sure it stays as a float\\n ratio = 1.0*(val - input_interval_start)\\n ratio = ratio / (input_interval_end - input_interval_start)\\n num = ratio * (output_interval_end - output_interval_start)\\n num += output_interval_start\\n return num\\n else:\\n return 0\",\n \"def translate(value, input_min, input_max, output_min, output_max):\\n # Figure out how 'wide' each range is\\n input_span = input_max - input_min\\n output_span = output_max - output_min\\n\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - input_min) / float(input_span)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return output_min + (value_scaled * output_span)\",\n \"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\\n # your code goes here\",\n \"def scale(input):\\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))\",\n \"def scaled(values, output_min, output_max, input_min=0, input_max=1):\\n values = _normalize(values)\\n if input_min >= input_max:\\n raise ValueError('input_min must be smaller than input_max')\\n input_size = input_max - input_min\\n output_size = output_max - output_min\\n for v in values:\\n yield (((v - input_min) / input_size) * output_size) + output_min\",\n \"def scale_range(x, input_range, target_range):\\n\\n range = [np.amin(x), np.amax(x)]\\n x_std = (x - input_range[0]) / (1.0*(input_range[1] - input_range[0]))\\n x_scaled = x_std * (1.0*(target_range[1] - target_range[0])) + target_range[0]\\n return x_scaled, range\",\n \"def mapVal(inputPos, in_min, in_max, out_min, out_max):\\n \\n \\n scale = ((out_max - out_min) / (in_max - in_min))\\n return float(((inputPos - in_min) * scale) + out_min)\",\n \"def mapped(val, in_min, in_max, out_min, out_max):\\n return (val - in_min) * (out_max - out_min) / \\\\\\n (in_max - in_min) + out_min\",\n \"def map_range(x, in_min, in_max, out_min, out_max):\\n mapped = (x-in_min) * (out_max - out_min) / (in_max-in_min) + out_min\\n if out_min <= out_max:\\n return max(min(mapped, out_max), out_min)\\n return min(max(mapped, out_max), out_min)\",\n \"def map(value, in_low, in_high, out_low, out_high):\\n # example from /animation_nodes/nodes/number/map_range.py\\n # if inMin == inMax:\\n # newValue = 0\\n # # with clamping\\n # if inMin < inMax:\\n # _value = min(max(value, inMin), inMax)\\n # else:\\n # _value = min(max(value, inMax), inMin)\\n # with interpolation\\n # newValue = outMin + interpolation(\\n # (_value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # without interpolation\\n # newValue = outMin + (\\n # (_value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # # without clamping\\n # newValue = outMin + (\\n # (value - inMin) / (inMax - inMin)\\n # ) * (outMax - outMin)\\n # # without clamping - reworded\\n # result = (\\n # (\\n # ((value - in_low) / (in_high - in_low)) *\\n # (out_high - out_low)\\n # ) + out_low\\n # )\\n\\n result = None\\n\\n # based on http://arduino.cc/en/Reference/Map\\n # and http://stackoverflow.com/a/5650012/574981\\n result = (\\n (\\n ((value - in_low) * (out_high - out_low)) /\\n (in_high - in_low)\\n ) + out_low\\n )\\n\\n return result\",\n \"def linearscale(input, boundfrom, boundto, extrema=None):\\n\\n\\tminfrom,maxfrom = boundfrom\\n\\tminto,maxto = boundto\\n\\n\\t### default from bounds are min,max of the input\\n\\tif minfrom is None:\\n\\t\\tif extrema:\\n\\t\\t\\tminfrom = extrema[0]\\n\\t\\telse:\\n\\t\\t\\tminfrom = arraystats.min(input)\\n\\tif maxfrom is None:\\n\\t\\tif extrema:\\n\\t\\t\\tmaxfrom = extrema[1]\\n\\t\\telse:\\n\\t\\t\\tmaxfrom = arraystats.max(input)\\n\\n\\trangefrom = maxfrom - minfrom\\n\\tif rangefrom == 0:\\n\\t\\t# if min==max, do simple thresholding\\n\\t\\toutput = numpy.where(input>maxfrom, maxto, minto)\\n\\telse:\\n\\t\\trangeto = maxto - minto\\n\\t\\tscale = float(rangeto) / rangefrom\\n\\t\\toffset = minfrom * scale\\n\\t\\toutput = input * scale - offset\\n\\n\\treturn output\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def map_to_range(val, old_min, old_max, new_min, new_max):\\n return new_max - (val - old_min) * (new_max - new_min) / (old_max - old_min)\",\n \"def scale_value(value, ip_range, domain=(0,1)):\\n x1, x2 = domain\\n y1, y2 = ip_range\\n\\n assert(y1 <= value <= y2)\\n\\n m = (x2 - x1)/(y2 - y1)\\n b = y1 - m * x1\\n return m * value - b\",\n \"def scale(val, src, dst):\\r\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\\n # pass\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\",\n \"def scale(x, minimum, maximum):\\n return (x - minimum) / (maximum - minimum)\",\n \"def scale(self, value):\\n return (float(value) - float(self.minimum)) / \\\\\\n float(self.maximum - self.minimum) * 2.0 - 1.0\",\n \"def scale(self, value):\\r\\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0\",\n \"def translate(value, from_min, from_max, to_min, to_max):\\n # Figure out how 'wide' each range is\\n left_span = from_max - from_min\\n right_span = to_max - to_min\\n\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - from_min) / float(left_span)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return to_min + (value_scaled * right_span)\",\n \"def scale(val, src, dst):\\n try:\\n return ((val - src[0]) / (src[1]-src[0])) * (dst[1]-dst[0]) + dst[0]\\n except ZeroDivisionError:\\n return 0.0\",\n \"def rescale(num, old_min, old_max, new_min, new_max):\\n old_range = old_max - old_min\\n new_range = new_max - new_min\\n new_val = new_min + (((num - old_min) * new_range)/old_range)\\n\\n return new_val\",\n \"def normalize_index(x, input_scale, output_scale):\\n return np.round(x / input_scale[2] * output_scale[2])\",\n \"def scale(self, value):\\n\\t\\toldscale = self.oldmax - self.oldmin\\n\\t\\tnewscale = self.newmax - self.newmin\\n\\t\\treturn (newscale * (value - self.oldmin) / oldscale) + self.newmin\",\n \"def scale(inp: np.ndarray, new_min: float = 0., new_max: float = 1.,\\n axis: int = -1) -> np.ndarray:\\n xmax = inp.max(axis=axis, keepdims=True)\\n xmin = inp.min(axis=axis, keepdims=True)\\n a = (inp-xmin) / (xmax - xmin)\\n y = a * (new_max - new_min) + new_min\\n return y\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def map_between(value, start, stop):\\n\\n return (stop - start) * value + start\",\n \"def adjust_dynamic_range(data, drange_in=(-1, 1), drange_out=(0, 1)):\\r\\n if drange_in != drange_out:\\r\\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\\r\\n np.float32(drange_in[1]) - np.float32(drange_in[0]))\\r\\n bias = (np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale)\\r\\n data = data * scale + bias\\r\\n return torch.clamp(data, min=0, max=1)\",\n \"def scale_floor(value, old_max, new_max):\\n\\tassert value >= 0\\n\\tassert value <= old_max\\n\\treturn new_max * value / old_max\",\n \"def rescale(range1, range2):\\n min1, max1, min2, max2 = min(range1), max(range1), min(range2), max(range2)\\n def resize(value):\\n return (((value - min1) * (max2 - min2)) / (max1 - min1)) + min2\\n return resize\",\n \"def map_bound(value, in_low, in_high, out_low, out_high):\\n result = None\\n\\n if value <= in_low:\\n result = out_low\\n else:\\n if value >= in_high:\\n result = out_high\\n else:\\n # http://stackoverflow.com/a/5650012/574981\\n result = out_low + (\\n (out_high - out_low) * (value - in_low) / (in_high - in_low)\\n )\\n return result\",\n \"def adjust_uh_timestep(unit_hydrograph, t_uh, input_interval, output_interval, x_inds, y_inds):\\n if output_interval == input_interval:\\n log.debug('No need to aggregate (output_interval = input_interval) \\\\\\n Skipping the adjust_uh_timestep step')\\n uh_out = unit_hydrograph\\n ts_new = np.arange(t_uh)\\n elif np.remainder(output_interval, input_interval) == 0:\\n log.debug('Aggregating to %i from %i seconds' % (output_interval, input_interval))\\n fac = int(output_interval/input_interval)\\n t_uh_out = int(t_uh/fac)\\n ts_new = np.arange(t_uh_out)\\n uh_out = np.zeros((t_uh_out, unit_hydrograph.shape[1], unit_hydrograph.shape[2]))\\n for (y, x) in zip(y_inds, x_inds):\\n for t in xrange(t_uh_out):\\n uh_out[t, y, x] = np.sum(unit_hydrograph[t*fac:t*fac+fac, y, x])\\n elif np.remainder(input_interval, output_interval):\\n log.debug('Interpolating unit hydrograph from input_interval: %i to output_interval: %i' % (input_interval, output_interval))\\n fac = int(input_interval / output_interval)\\n t_uh_out = int(t_uh * fac)\\n uh_out = np.zeros((t_uh_out, unit_hydrograph.shape[1], unit_hydrograph.shape[2]))\\n ts_orig = np.linspace(0, t_uh, t_uh)\\n ts_new = np.linspace(0, t_uh, t_uh_out)\\n for (y, x) in zip(y_inds, x_inds):\\n f = interp1d(ts_orig, unit_hydrograph[:, y, x])\\n uh_out[:, y, x] = f(ts_new)\\n return uh_out, ts_new\",\n \"def translate(value, leftMin, leftMax, rightMin, rightMax):\\n # Figure out how 'wide' each range is\\n leftSpan = leftMax - leftMin\\n rightSpan = rightMax - rightMin\\n\\n # Convert the left range into a 0-1 range (float)\\n valueScaled = float(value - leftMin) / float(leftSpan)\\n\\n # Convert the 0-1 range into a value in the right range.\\n return rightMin + (valueScaled * rightSpan)\",\n \"def adjust_dynamic_range(\\n data: np.array,\\n drange_in: Tuple[int, int],\\n drange_out: Tuple[int, int],\\n slack: bool = False,\\n) -> np.array:\\n\\n if drange_in != drange_out:\\n if not slack:\\n old_min, old_max = np.float32(drange_in[0]), np.float32(drange_in[1])\\n new_min, new_max = np.float32(drange_out[0]), np.float32(drange_out[1])\\n data = (\\n (data - old_min) / (old_max - old_min) * (new_max - new_min)\\n ) + new_min\\n else:\\n scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / (\\n np.float32(drange_in[1]) - np.float32(drange_in[0])\\n )\\n bias = np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale\\n data = data * scale + bias\\n data = np.clip(data, a_min=drange_out[0], a_max=drange_out[1])\\n return data\",\n \"def scale(a, tmin=0.0, tmax=1.0):\\n return np.interp(a, (a.min(), a.max()), (tmin, tmax))\",\n \"def simple_scaling(input_data):\\n\\n # Insert debugging assertions\\n assert type(input_data) is np.ndarray, \\\"The 'input_data' must be numpy array.\\\"\\n\\n # Get the minimum values of the input numpy array along the axis \\n Max = np.max(input_data, axis = 0)\\n\\n # Simple sclaing \\n scaled_input_data = input_data / (Max + sys.float_info.min)\\n\\n # Return scaled input data\\n return scaled_input_data\",\n \"def __normalize(self, value, lower_bound, upper_bound):\\n\\n min_max_diff = self.max - self.min\\n bound_diff = upper_bound - lower_bound\\n return (value - self.min) / min_max_diff * bound_diff + lower_bound\",\n \"def scale_image(image, new_range):\\n min_val = np.min(image).astype(np.float32)\\n max_val = np.max(image).astype(np.float32)\\n min_val_new = np.array(min(new_range), dtype=np.float32)\\n max_val_new = np.array(max(new_range), dtype=np.float32)\\n scaled_image = (image - min_val) / (max_val - min_val) * (max_val_new - min_val_new) + min_val_new\\n return scaled_image.astype(np.uint8)\",\n \"def scale(x, feature_range=(-1,1)):\\r\\n x = x * 2 - 1\\r\\n return x\",\n \"def normalise_modular_range(value, min, max):\\n return numpy.mod(value-min, max-min)+min\",\n \"def scale_range(data, minTo, maxTo):\\n minFrom = np.min(data)\\n maxFrom = np.max(data)\\n \\n scaled_data = []\\n \\n for point in data:\\n new_point = minTo + (maxTo - minTo) * ((point - minFrom)/(maxFrom - minFrom))\\n scaled_data.append(new_point)\\n \\n return scaled_data\",\n \"def translate(self, value, left_min, left_max, right_min=None, right_max=None):\\n if right_min is None:\\n right_min = self.values['pulse_min'].data\\n if right_max is None:\\n right_max = self.values['pulse_max'].data\\n # Figure out how 'wide' each range is\\n left_span = left_max - left_min\\n right_span = right_max - right_min\\n # Convert the left range into a 0-1 range (float)\\n value_scaled = float(value - left_min) / float(left_span)\\n # Convert the 0-1 range into a value in the right range.\\n return int(right_min + (value_scaled * right_span))\",\n \"def scaleValues(values):\\n\\n values = values - values.min()\\n return values/values.max()\",\n \"def normalize_value_range(image,\\n vmin = -1,\\n vmax = 1,\\n in_min = 0,\\n in_max = 255.0,\\n clip_values = False):\\n if in_min >= in_max or vmin >= vmax:\\n raise ValueError('min must be strictly less than max')\\n\\n in_min_t = tf.constant(in_min, tf.float32)\\n in_max_t = tf.constant(in_max, tf.float32)\\n image = tf.cast(image, tf.float32)\\n image = (image - in_min_t) / (in_max_t - in_min_t)\\n image = vmin + image * (vmax - vmin)\\n if clip_values:\\n image = tf.clip_by_value(image, vmin, vmax)\\n return image\",\n \"def fit_to_range(val: float, a: float, b: float, a1: float, b1: float) -> float:\\n new_value = ((val - a) / (b - a)) * (b1 - a1) + a1\\n return new_value\",\n \"def compute_interpolation_weights(out_size, in_size, scale):\\n # lower, upper, lerp\\n res = [[0, 0, 0] for _ in range(out_size + 1)]\\n for i in range(out_size - 1, -1, -1):\\n val = i * scale\\n res[i][0] = int(val)\\n res[i][1] = min(res[i][0] + 1, in_size - 1)\\n res[i][2] = val - int(val)\\n return res\",\n \"def _scalar_conversion(self, p_input:float) -> float:\\n return (p_input/self.units[self._unit_in]*self.units[self._unit_out])\",\n \"def scale(input_img, size):\\n width, height = size\\n old_height, old_width = input_img.shape\\n x_scale = float(height) / old_height\\n y_scale = float(width) / old_width\\n\\n output_img = np.zeros((height, width), dtype=np.uint8)\\n for xidx in xrange(height):\\n old_x = float(xidx) / x_scale\\n for yidx in xrange(width):\\n old_y = float(yidx) / y_scale\\n if old_x.is_integer() or old_y.is_integer():\\n output_img[xidx, yidx] = input_img[int(old_x), int(old_y)]\\n else: # use bilinear interpolation\\n x1 = int(np.floor(old_x))\\n x2 = int(np.ceil(old_x)) if int(np.ceil(old_x)) < old_height else old_height - 1\\n y1 = int(np.floor(old_y))\\n y2 = int(np.ceil(old_y)) if int(np.ceil(old_y)) < old_width else old_width - 1\\n\\n q11 = input_img[x1, y1]\\n q12 = input_img[x1, y2]\\n q21 = input_img[x2, y1]\\n q22 = input_img[x2, y2]\\n\\n output_img[xidx, yidx] = (q11 * (x2 - old_x) * (y2 - old_y)\\n + q21 * (old_x - x1) * (y2 - old_y)\\n + q12 * (x2 - old_x) * (old_y - y1)\\n + q22 * (old_x - x1) * (old_y - y1)) \\\\\\n / ((x2 - x1) * (y2 - y1) + 1e-10)\\n\\n return output_img\",\n \"def task_scaling(input_array, scaling_factor):\\n return(np.multiply(scaling_factor, input_array))\",\n \"def scale(arrayin,Amin,Amax,mask=None):\\r\\n if (mask==None) and (arrayin.max() - arrayin.min())!=0.0 :\\r\\n Bmax = arrayin.max()\\r\\n Bmin = arrayin.min()\\r\\n elif (arrayin.max() - arrayin.min())!=0.0 :\\r\\n ny = arrayin.shape[0]\\r\\n nx = arrayin.shape[1]\\r\\n Bmax = arrayin.min()\\r\\n Bmin = arrayin.max()\\r\\n for i in range(ny):\\r\\n for j in range(ny):\\r\\n if mask[i,j] > 0.5e0 :\\r\\n if arrayin[i,j] < Bmin :\\r\\n Bmin = arrayin[i,j]\\r\\n if arrayin[i,j] > Bmax :\\r\\n Bmax = arrayin[i,j]\\r\\n else :\\r\\n print \\\"andrew.bagOfns.scale : warning (arrayin.max() - arrayin.min())=0.0 \\\"\\r\\n return np.copy(arrayin)\\r\\n\\r\\n arrayout = (arrayin - Bmin)*(Amax - Amin) / (Bmax - Bmin) + Amin\\r\\n return arrayout\",\n \"def scale(x, a=5, b=10, xmin=-1, xmax=1):\\n return (b - a)*(x - xmin)/(xmax - xmin) + a\",\n \"def rescale(x):\\n if x.min() != 0:\\n raise ValueError('input should have min zero.')\\n\\n x /= x.max() # max 1\\n x *= 2 # max 2\\n x -= 1 # range -1, 1\\n\\n if x.min() != -1 and x.max() != 1:\\n raise Exception\\n\\n return x\",\n \"def scale(df, lower=-1, upper=1):\\n\\n scaler = MinMaxScaler(feature_range=(lower, upper))\\n scaler = scaler.fit(df)\\n\\n # Replace values with the scaled dataframe\\n df[['Input', 'Output']] = scaler.transform(df)\\n\\n return df\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\r\\n ndar = ndar.copy()\\r\\n ndar -= ndar.min()\\r\\n ndar *= 1.0 / (ndar.max() + eps)\\r\\n return ndar\",\n \"def lin_scale( val, x1, y1, x2, y2 ):\\r\\n x_range = (x2 - x1)\\r\\n new_val = 0\\r\\n if x_range is 0:\\r\\n new_val = y1\\r\\n else:\\r\\n y_range = ( y2 - y1 )\\r\\n new_val = ( ( ( val - x1 ) * y_range ) / x_range ) + y1\\r\\n\\r\\n return new_val\",\n \"def normalize(x, x_max, x_min):\\n return (x - x_min) / (x_max - x_min)\",\n \"def scale_servos(self, value, minrange=500, maxrange=2500):\\n min_servo_range = -1\\n max_servo_range = 1\\n return min_servo_range + (max_servo_range - min_servo_range) / (maxrange - minrange) * (value - minrange)\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def unit_scale(x, eps=1e-8):\\n\\tx = x.copy()\\n\\tx -= x.min()\\n\\tx *= 1.0 / (x.max() + eps)\\n\\treturn x\",\n \"def remap(self, value, from1, to1, from2, to2):\\n return from2 + (value - from1) * (to2 - from2) / (to1 - from1)\",\n \"def integrand_normalization(weight_function, intervals):\\n\\n def constant_rate(t):\\n return 1.0\\n\\n return average_over_interval(constant_rate, weight_function, intervals)\",\n \"def scale(x_range=1, y_range=1):\\r\\n x = rand_val(x_range)\\r\\n y = rand_val(y_range)\\r\\n return np.array(((x, 0, 0),\\r\\n (0, y, 0),\\r\\n (0, 0, 1)), dtype=np.float)\",\n \"def shrink_image(image, output_size, interp_type=InterpolationType.INTEGRAL, output=None):\\n\\n if isinstance(output_size, (int, int)):\\n scale = float(output_size) / max(image.getWidth(), image.getHeight())\\n output_shape = (int(image.getHeight()*scale), int(image.getWidth()*scale))\\n else:\\n output_shape = output_size\\n\\n if image.getWidth() < output_shape[1] or image.getHeight() < output_shape[0]:\\n raise RuntimeError(\\\"Either width or height is larger in output than input\\\")\\n\\n if output is None:\\n output = image.createNew(output_shape[1], output_shape[0])\\n else:\\n output.reshape(output_shape[1], output_shape[0])\\n\\n if interp_type == InterpolationType.INTEGRAL:\\n pbg.gateway.jvm.boofcv.alg.filter.misc.AverageDownSampleOps.down(image, output)\\n else:\\n scale_x = output_shape[1] / float(image.getWidth())\\n scale_y = output_shape[0] / float(image.getHeight())\\n\\n fdist = pbg.gateway.jvm.boofcv.abst.distort.FDistort(image, output)\\n fdist.interp(interpolation_type_to_java(interp_type))\\n fdist.affine(scale_x, 0.0, 0.0, scale_y, 0.0, 0.0)\\n fdist.apply()\\n\\n return output\",\n \"def win_scale(data, wl, ww, dtype, out_range):\\n\\n data_new = np.empty(data.shape, dtype=np.double)\\n data_new.fill(out_range[1] - 1)\\n\\n data_new[data <= (wl - ww / 2.0)] = out_range[0]\\n data_new[(data > (wl - ww / 2.0)) & (data <= (wl + ww / 2.0))] = \\\\\\n ((data[(data > (wl - ww / 2.0)) & (data <= (wl + ww / 2.0))] - (wl - 0.5)) / (ww - 1.0) + 0.5) * (\\n out_range[1] - out_range[0]) + out_range[0]\\n data_new[data > (wl + ww / 2.0)] = out_range[1] - 1\\n\\n return data_new.astype(dtype)\",\n \"def _min_max_scale(arr, new_range=(0, 255)):\\n # get array's current min and max\\n mn = arr.min()\\n mx = arr.max()\\n\\n # check if scaling needs to be done to be in new_range\\n if mn < new_range[0] or mx > new_range[1]:\\n # perform min-max scaling\\n scaled = (new_range[1] - new_range[0]) * (arr - mn) / (mx - mn) + new_range[0]\\n else:\\n # return array if already in range\\n scaled = arr\\n\\n return scaled\",\n \"def scale(image, maxval=1024):\\n image += maxval # minimum value is now 0\\n image /= maxval*2\\n\\n return(image)\",\n \"def scale_to_unit_interval(ndar, eps=1e-8):\\n ndar = ndar.copy()\\n ndar -= ndar.min()\\n ndar = ndar*1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def normalize_data(data, min=0, max=1):\\r\\n import numpy as np\\r\\n assert isinstance(data, np.ndarray)\\r\\n\\r\\n max_value = np.max(data)\\r\\n min_value = np.min(data)\\r\\n\\r\\n scaled = np.interp(data, [min_value, max_value], [min, max])\\r\\n # convert to float64\\r\\n scaled = scaled.astype(np.float64)\\r\\n\\r\\n return scaled\",\n \"def scale_to_unit_interval(self,ndar, eps=1e-8):\\n ndar = np.float64(ndar.copy())\\n ndar -= ndar.min()\\n ndar *= 1.0 / (ndar.max() + eps)\\n return ndar\",\n \"def rescale(self, xmin, xmax):\\n\\n # Normalise\\n self.normalise()\\n\\n \\n # Rescale\\n range = xmax-xmin\\n for seg in self.segments:\\n seg.lower_bound = seg.lower_bound*range + xmin\\n seg.upper_bound = seg.upper_bound*range + xmin\",\n \"def normalizeToRange(v, a, b):\\n return (v - a) / (b - a)\",\n \"def convert_scale(g, op, block):\\n\\n scale = op.attr(\\\"scale\\\")\\n bias = op.attr(\\\"bias\\\")\\n bias_after_scale = op.attr(\\\"bias_after_scale\\\")\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\\n out = x\\n else:\\n if np.isclose(bias, 0.0):\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\"))\\n elif np.isclose(scale, 1.0):\\n out = x + _expr.const(np.array(bias).astype(\\\"float32\\\"))\\n else:\\n if bias_after_scale:\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\")) + _expr.const(\\n np.array(bias).astype(\\\"float32\\\")\\n )\\n else:\\n out = (x + _expr.const(np.array(bias).astype(\\\"float32\\\"))) * _expr.const(\\n np.array(scale).astype(\\\"float32\\\")\\n )\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def normalize(x, min_x, max_x):\\n\\treturn (x - min_x) / (max_x - min_x)\",\n \"def math_map(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def scale_ceil(value, old_max, new_max):\\n\\tassert value >= 0\\n\\tassert value <= old_max\\n\\treturn div_ceil(new_max * value, old_max)\",\n \"def get_amount_out(amount_in, reserve_in, reserve_out):\\n assert amount_in > 0\\n assert reserve_in > 0 and reserve_out > 0\\n amount_in_with_fee = amount_in*997\\n numerator = amount_in_with_fee*reserve_out\\n denominator = reserve_in*1000 + amount_in_with_fee\\n return float(numerator/denominator)\",\n \"def scale_between(minval, maxval, numStops):\\n\\n scale = []\\n\\n if numStops < 2:\\n return [minval, maxval]\\n elif maxval < minval:\\n raise ValueError()\\n else:\\n domain = maxval - minval\\n interval = float(domain) / float(numStops)\\n for i in range(numStops):\\n scale.append(round(minval + interval * i, 2))\\n return scale\",\n \"def RescaleByInterval(inputgdf, rescaledf, rescalefield, fillnaval=1):\\n close = 'left' if rescaledf.iloc[0, 0] == 0 else 'right'\\n rescale_interval = pd.IntervalIndex.from_arrays(rescaledf.iloc[:, 0], rescaledf.iloc[:, 1], closed=close)\\n rescale_series = pd.cut(inputgdf[rescalefield], rescale_interval).cat.\\\\\\n rename_categories(np.asarray(rescaledf.iloc[:, 2]))\\n if rescale_series.isna().values.any():\\n rescale_series.fillna(fillnaval, inplace=True)\\n else:\\n pass\\n return rescale_series.astype(int)\",\n \"def scale_to_baseline(X, baseline=None, crop_baseline=False):\\n #X = X_.copy()\\n\\n if baseline is None:\\n print(\\\"No baseline interval specified, sacling based on the whole epoch\\\")\\n interval = np.arange(X.shape[-1])\\n elif isinstance(baseline, tuple):\\n print(\\\"Scaling to interval {:.1f} - {:.1f}\\\".format(*baseline))\\n interval = np.arange(baseline[0], baseline[1])\\n X0m = X[..., interval].mean(axis=2, keepdims=True)\\n X0sd = X[..., interval].std(axis=(1,2), keepdims=True)\\n\\n X -= X0m\\n X /= X0sd\\n if crop_baseline and baseline is not None:\\n X = np.delete(X, interval, axis=-1)\\n #print(\\\"Scaling Done\\\")\\n return X\",\n \"def ramped_signal(start, end, time_interval, signal_start, signal_end, min_rate, max_rate, ramp_duration):\\n\\n if len(ramp_duration) > 2:\\n raise UserWarning('Specify two ramps only (start and end).')\\n\\n if ramp_duration[0] is not None and ramp_duration[0] < time_interval:\\n raise ValueError(\\\"The start ramp is shorter than the time interval. Specify either a bigger ramp or supply a \\\"\\n \\\"higher resolution time series (`t')\\\")\\n\\n if ramp_duration[1] is not None and ramp_duration[1] < time_interval:\\n raise ValueError(\\\"The end ramp is shorter than the time interval. Specify either a bigger ramp or supply a \\\"\\n \\\"higher resolution time series (`t')\\\")\\n\\n start_datetime = datetime.strptime(start, '%Y-%m-%d %H:%M:%S')\\n end_datetime = datetime.strptime(end, '%Y-%m-%d %H:%M:%S')\\n run_duration = (end_datetime - start_datetime).days\\n start_signal_datetime = datetime.strptime(signal_start, '%Y-%m-%d %H:%M:%S')\\n end_signal_datetime = datetime.strptime(signal_end, '%Y-%m-%d %H:%M:%S')\\n\\n t = []\\n for d in np.arange(run_duration):\\n for h in np.arange(0, 1 - time_interval, time_interval):\\n t.append(start_datetime + timedelta(days=float(d), hours=float(h) * 24.0))\\n # Add the end of the requested period to the list and convert to array.\\n t.append(end_datetime)\\n t = np.asarray(t)\\n\\n signal = np.repeat(min_rate, len(t)).astype(float)\\n\\n if ramp_duration[0] is None:\\n signal_start_index_offset = 0\\n else:\\n signal_start_index_offset = np.ceil(ramp_duration[0] / time_interval).astype(int)\\n\\n if ramp_duration[-1] is None:\\n signal_end_index_offset = len(t) - 1\\n elif ramp_duration[-1] < 0:\\n signal_end_index_offset = signal_start_index_offset\\n else:\\n signal_end_index_offset = np.ceil(ramp_duration[-1] / time_interval).astype(int)\\n\\n start_index = np.argmin([np.abs((tt - start_signal_datetime).total_seconds()) for tt in t])\\n start_max_index = start_index + signal_start_index_offset\\n end_index = np.argmin([np.abs((tt - end_signal_datetime).total_seconds()) for tt in t])\\n end_max_index = np.min((end_index + signal_end_index_offset, len(signal) - 1))\\n\\n hyperbolic_start = np.arange(-signal_start_index_offset / 2, signal_start_index_offset / 2)\\n hyperbolic_end = np.arange(-signal_start_index_offset / 2, signal_end_index_offset / 2)\\n ramp_start = np.tanh((hyperbolic_start / signal_start_index_offset) * np.pi * 2)\\n ramp_end = np.tanh((hyperbolic_end / signal_end_index_offset) * np.pi * 2)\\n if np.any(ramp_start):\\n ramp_start = fix_range(ramp_start, min_rate, max_rate)\\n if np.any(ramp_end):\\n ramp_end = fix_range(ramp_end, min_rate, max_rate)\\n\\n signal[start_index:start_max_index] = ramp_start\\n # If the end indices are the same, assume we're just running the signal to the end, otherwise taper it with the\\n # reverse of the ramp up.\\n if end_index != end_max_index:\\n signal[start_max_index:end_index] = max_rate\\n signal[end_index:end_max_index] = ramp_end[::-1]\\n else:\\n signal[start_max_index:end_index + 1] = max_rate\\n\\n return t, signal\",\n \"def remap(\\n n: int, start1: int, stop1: int, start2: int, stop2: int, withinBounds: bool = True\\n) -> int:\\n newval = (n - start1) / (stop1 - start1) * (stop2 - start2) + start2\\n if not withinBounds:\\n return newval\\n if start2 < stop2:\\n return constrain(newval, start2, stop2)\\n else:\\n return constrain(newval, stop2, start2)\",\n \"def stretch_image(img, max_val):\\n\\n @_decorate_validation\\n def validate_input():\\n _numeric('img', 'floating', shape=(-1, -1))\\n _numeric('max_val', ('integer', 'floating'), range_='(0;inf)')\\n\\n validate_input()\\n\\n min_ = img.min()\\n max_ = img.max()\\n\\n if max_ > min_:\\n val = max_val / (max_ - min_) * (img - min_)\\n else:\\n val = img - min_\\n\\n return val\",\n \"def scale(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def dim_unit_scaling(in_unit, out_unit):\\n\\n unit_vals = {\\n 'nm': 1e-9,\\n 'um': 1e-6,\\n 'mm': 1e-3,\\n 'cm': 1e-2,\\n 'm': 1.0,\\n 'km': 1e3,\\n }\\n\\n if in_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n if out_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n\\n return unit_vals[in_unit]/unit_vals[out_unit]\",\n \"def cv_compute_interpolation_weights(out_size, in_size, scale):\\n # lower, upper, lerp\\n res = [[0, 0, 0] for _ in range(out_size + 1)]\\n res[-1] = [0, 0]\\n for i in range(out_size - 1, -1, -1):\\n val = (i + 0.5) * scale - 0.5\\n res[i][0] = max(0, int(val))\\n res[i][1] = min(res[i][0] + 1, in_size - 1)\\n res[i][2] = max(0, val - int(val))\\n return res\",\n \"def __init__(self, min_value=0.0, max_value=1.0, input_name=\\\"image\\\", output_name=\\\"image\\\"):\\n super().__init__(input_name=input_name, output_names=[output_name])\\n self.min_value = min_value\\n self.max_value = max_value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79932183","0.7901168","0.7887289","0.7876046","0.7751076","0.7288981","0.7237463","0.7120831","0.7019347","0.6851704","0.68007386","0.66910595","0.6677727","0.6569077","0.6418457","0.62758476","0.625303","0.6198374","0.6172267","0.616496","0.616496","0.6164606","0.61345327","0.61230487","0.606431","0.6059691","0.5939111","0.59356374","0.59355015","0.59333473","0.5897703","0.5862136","0.5848296","0.5762929","0.57363003","0.56948143","0.5651834","0.56415975","0.56200683","0.55814004","0.5557659","0.5554465","0.5554066","0.5549263","0.552353","0.5494889","0.54713625","0.54617494","0.54510915","0.5412504","0.5384826","0.5363969","0.5358131","0.53390205","0.5335214","0.5327633","0.5323904","0.52519125","0.52394706","0.5235274","0.5225435","0.5222083","0.5220232","0.51931804","0.51884854","0.5188342","0.51848364","0.5179713","0.5179713","0.5179713","0.5179713","0.5179713","0.5178188","0.5172129","0.5167819","0.51476055","0.51455414","0.51417917","0.5130047","0.51257753","0.51180905","0.51129097","0.51125515","0.51054776","0.51020753","0.5069866","0.50684136","0.5052624","0.50506103","0.50487596","0.5035518","0.5019305","0.5016214","0.5002992","0.5001443","0.49912494","0.49883735","0.4988006","0.4971454","0.49668717"],"string":"[\n \"0.79932183\",\n \"0.7901168\",\n \"0.7887289\",\n \"0.7876046\",\n \"0.7751076\",\n \"0.7288981\",\n \"0.7237463\",\n \"0.7120831\",\n \"0.7019347\",\n \"0.6851704\",\n \"0.68007386\",\n \"0.66910595\",\n \"0.6677727\",\n \"0.6569077\",\n \"0.6418457\",\n \"0.62758476\",\n \"0.625303\",\n \"0.6198374\",\n \"0.6172267\",\n \"0.616496\",\n \"0.616496\",\n \"0.6164606\",\n \"0.61345327\",\n \"0.61230487\",\n \"0.606431\",\n \"0.6059691\",\n \"0.5939111\",\n \"0.59356374\",\n \"0.59355015\",\n \"0.59333473\",\n \"0.5897703\",\n \"0.5862136\",\n \"0.5848296\",\n \"0.5762929\",\n \"0.57363003\",\n \"0.56948143\",\n \"0.5651834\",\n \"0.56415975\",\n \"0.56200683\",\n \"0.55814004\",\n \"0.5557659\",\n \"0.5554465\",\n \"0.5554066\",\n \"0.5549263\",\n \"0.552353\",\n \"0.5494889\",\n \"0.54713625\",\n \"0.54617494\",\n \"0.54510915\",\n \"0.5412504\",\n \"0.5384826\",\n \"0.5363969\",\n \"0.5358131\",\n \"0.53390205\",\n \"0.5335214\",\n \"0.5327633\",\n \"0.5323904\",\n \"0.52519125\",\n \"0.52394706\",\n \"0.5235274\",\n \"0.5225435\",\n \"0.5222083\",\n \"0.5220232\",\n \"0.51931804\",\n \"0.51884854\",\n \"0.5188342\",\n \"0.51848364\",\n \"0.5179713\",\n \"0.5179713\",\n \"0.5179713\",\n \"0.5179713\",\n \"0.5179713\",\n \"0.5178188\",\n \"0.5172129\",\n \"0.5167819\",\n \"0.51476055\",\n \"0.51455414\",\n \"0.51417917\",\n \"0.5130047\",\n \"0.51257753\",\n \"0.51180905\",\n \"0.51129097\",\n \"0.51125515\",\n \"0.51054776\",\n \"0.51020753\",\n \"0.5069866\",\n \"0.50684136\",\n \"0.5052624\",\n \"0.50506103\",\n \"0.50487596\",\n \"0.5035518\",\n \"0.5019305\",\n \"0.5016214\",\n \"0.5002992\",\n \"0.5001443\",\n \"0.49912494\",\n \"0.49883735\",\n \"0.4988006\",\n \"0.4971454\",\n \"0.49668717\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8289255"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":93697,"cells":{"query":{"kind":"string","value":"Maps input value between 1 and 1 to an integer 0255, suitable for use as an RGB color code."},"document":{"kind":"string","value":"def color_map(val):\n # NOTE: This relies on remap_interval, which you must provide\n color_code = remap_interval(val, -1, 1, 0, 255)\n return int(color_code)"},"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 color_map(val):\n color_code = remap_interval(val, -1, 1, 0, 255)\n return int(color_code)","def c_map(val):\n return int(remap(val, -1, 1, 0, 255))","def get_color(self, value):\n value = min(max(0,value), 1) * 510\n\n if value < 255:\n redValue = 255\n greenValue = math.sqrt(value) * 16\n greenValue = int(greenValue)\n else:\n greenValue = 255\n value = value - 255\n redValue = 255 - (value * value / 255)\n redValue = int(redValue)\n return '#' + f\"{redValue:0{2}x}\" + f\"{greenValue:0{2}x}\" + '00'","def IntToColor(number):\n color = COLORS_INDEX.get(number)\n return color if color else 'default'","def mapper(value):\n\n out = scalarMap.to_rgba(value)\n\n if isinstance(out, tuple):\n return tuple([255 * out[i] for i in range(3)] + [alpha])\n\n elif isinstance(out, np.ndarray):\n out[:, :-1] *= 255\n out[:, 3] = alpha\n return out","def int2color(x):\n # r = int(1000 * x % 255)\n # g = int(10000 * x % 255)\n # b = int(100000 * x % 255)\n x = 0 if x == 0 else int(1/x)\n b = x & 0xff\n g = (x >> 8) & 0xff\n r = (x >> 16) & 0xff\n return [r, g, b]","def map_01_to_8bit(value):\n result = None\n result = int(map_bound(value, 0.0, 1.0, 0, 255))\n return result","def color_from_value(self, value):\n \n return ImageColor.getrgb(\"hsl(%d,%d%%,%d%%)\" % (int( (1.0 - value) * 360 ), 80, 50))","def _to_color(indx, base):\n base2 = base * base\n b = 2 - indx / base2\n r = 2 - (indx % base2) / base\n g = 2 - (indx % base2) % base\n return b * 127, r * 127, g * 127","def Amber_to_Green(val):\n\tif val == 1 :\n\t\treturn \"GREEN\"\n\telif val == -1:\n\t\treturn \"RED\"","def checkRGBRange(value):\n\ttry:\n\t\tv = int(value)\n\t\tif 0 <= v <= 255:\n\t\t\treturn v\n\texcept:\n\t\treturn 255","def normalize_01(x):\n return x / 255.0","def _to_code(rgb):\n code = 0\n if 'r' in rgb:\n code += 1\n\n if 'g' in rgb:\n code += 2\n\n if 'b' in rgb:\n code += 4\n return code","def fromInts(r, g, b):\n return IColor(r/255.,g/255.,b/255.)","def hue(value):\n value = int(value)\n if value < 0 or value > 65535:\n raise ValueError('Hue is a value between 0 and 65535')\n return value","def getColor(self,number):\n if number >= 0:\n if self.inverse:\n ret = cs.hsv_to_rgb(0,0,abs(number/self.maxp))\n else:\n ret = cs.hsv_to_rgb(0,0,1-abs(number/self.maxp))\n else:\n if self.inverse:\n ret = cs.hsv_to_rgb(0,1-abs(number/self.maxn),1)\n else:\n ret = cs.hsv_to_rgb(0,abs(number/self.maxn),1)\n return [ret[0]*255.0,ret[1]*255.0,ret[2]*255.0]","def _bool_to_color(value) -> int:\n if value is True:\n return RED\n return BLACK","def get_color(in_val, min_val=0, max_val=100):\n width = max_val - min_val\n unit = width / len(continuum)\n return continuum[min(int(in_val / unit), 19)]","def cmap(num,cmap = plt.cm.gist_earth_r):\n return cmap(np.linspace(0, 1, num))","def is_0to255(value):\n return 0 <= value <= 255","def getColor(self,number):\n if number >= 0:\n ret = cs.hsv_to_rgb(0,0,1-abs(number/self.maxp))\n else:\n ret = cs.hsv_to_rgb(0,abs(number/self.maxn),1)\n hexcolor = '#%02x%02x%02x' % (ret[0]*255,ret[1]*255,ret[2]*255)\n return hexcolor","def color_negative_red_positive_green(val):\n if val < 0:\n color = 'red'\n elif val > 0:\n color = 'green'\n else:\n color = 'black'\n\n return 'color: %s' % color","def set_rgb(self, value):\n act = RGBAction(self, value)\n return act.invoke()","def scale_to_01(color: C3I) -> C3F:\n r, g, b = color\n return r / 255, g / 255, b / 255","def color_negative_red(value):\n\n if value == 1:\n color = 'red'\n else:\n color = 'black'\n\n return 'color: %s' % color","def lut(threshold):\n\n return [255 if i<=threshold else 0 for i in range(256)]","def one_hot_encode_single(mapping: dict[str, int], value: Optional[str]) -> IntArray:\n encoded_value = np.zeros((1, len(mapping)))\n if not pd.isna(value):\n code = mapping[str(value)]\n encoded_value[0, code] = 1\n return encoded_value","def color_positive_green(val):\n\tif val > 0: \n\t\tcolor = 'green'\n\telse: \n\t\tcolor = 'red'\n\treturn 'background-color: %s' % color","def colorize_label_map(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label. Got {}'.format(label.shape))\n\n colormap = colormap_ade20k\n label_mod = np.mod(label, len(colormap))\n return colormap[label_mod].astype(np.uint8)","def test_color__int_arg(self):\n for value in (0x0, 0xFFFFFFFF, 0xAABBCCDD):\n color = pygame.Color(value)\n\n self.assertEqual(color.r, (value >> 24) & 0xFF)\n self.assertEqual(color.g, (value >> 16) & 0xFF)\n self.assertEqual(color.b, (value >> 8) & 0xFF)\n self.assertEqual(color.a, value & 0xFF)","def int2color_tuple(x):\n red_val = int(1000 * x % 255)\n green_val = int(10000 * x % 255)\n blue_val = int(100000 * x % 255)\n return red_val, green_val, blue_val","def change( p ):\n red = p[0]\n green = p[1]\n blue = p[2]\n return [ 255-red, 255-green, 255-blue ]","def colorToInt(color):\n color_table = reverse(COLORS_INDEX)\n color_number = color_table.get(color)\n return color_number if color_number else 0","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label.')\n\n colormap = create_pascal_label_colormap()\n\n if np.max(label) >= len(colormap):\n raise ValueError('Label value too large.')\n\n return colormap[label]","def color_conversion(string):\n if (string == 'J'):\n return 0.14\n if (string == 'I'):\n return 0.28\n if (string == 'H'):\n return 0.42\n if (string == 'G'):\n return 0.56\n if (string == 'F'):\n return 0.70\n if (string == 'E'):\n return 0.84\n if (string == 'D'):\n return 1","def rgb_2_scalar_idx(r, g, b):\n return 256 ** 2 * r + 256 * g + b","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label')\n\n colormap = create_pascal_label_colormap()\n\n if np.max(label) >= len(colormap):\n raise ValueError('label value too large.')\n\n return colormap[label]","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label')\n\n colormap = create_pascal_label_colormap()\n\n if np.max(label) >= len(colormap):\n raise ValueError('label value too large.')\n\n return colormap[label]","def toRGB(self):\n\t\treturn '#'+ (hex(self.politics)[2:].upper().rjust(6,'0'))","def color(value):\r\n return 'RGB({}, {}, {})'.format(value.red(), value.blue(), value.green())","def map_channels(self, map_function):\n return ScreenColor(map_function(self.red), map_function(self.green), map_function(self.blue))","def get_label_color_mapping(idx):\n # https://gist.github.com/wllhf/a4533e0adebe57e3ed06d4b50c8419ae\n def bitget(byteval, ch):\n return (byteval & (1 << ch)) != 0\n r = g = b = 0\n for j in range(8):\n r = r | (bitget(idx, 0) << 7 - j)\n g = g | (bitget(idx, 1) << 7 - j)\n b = b | (bitget(idx, 2) << 7 - j)\n idx = idx >> 3\n return np.array([r, g, b], dtype=np.uint8)","def my_color_function(field):\n if field > 100000000:\n return \"#ff0000\"\n else:\n return \"#008000\"","def gray_code(number: int) -> list:\n if number <= 0:\n return -1\n\n result: list = []\n result.append(\"0\")\n result.append(\"1\")\n num1 = 2\n\n while True:\n if num1 >= 1 << number:\n break\n\n for j in range (num1 - 1, -1, -1):\n result.append(result[j])\n\n for j in range (num1):\n result[j] = \"0\" + result[j]\n\n for j in range (num1, 2 * num1):\n result[j] = \"1\" + result[j]\n\n num1 = num1 << 1\n\n return result","def intensity(self, value: int, /) -> None:","def _get_color(self, c, x, max_num):\n\n ratio = 5*(float(x)/max_num)\n i = int(math.floor(ratio))\n j = int(math.ceil(ratio))\n ratio -= i\n r = (1 - ratio) * self._colors[i][c] + ratio*self._colors[j][c]\n return int(255*r)","def create_range_map(points_xyz: NDArrayFloat) -> NDArrayByte:\n range = points_xyz[..., 2]\n range = np.round(range).astype(int)\n color = plt.get_cmap(\"turbo\")(np.arange(0, range.max() + 1))\n color = color[range]\n range_cmap: NDArrayByte = (color * 255.0).astype(np.uint8)\n return range_cmap","def convert_to_RGB_255(colors):\n return (colors[0]*255.0, colors[1]*255.0, colors[2]*255.0)","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label')\n\n colormap = create_pascal_label_colormap()\n\n if np.max(label) >= len(colormap):\n raise ValueError('label value too large.')\n\n return colormap[label]","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label')\n\n colormap = create_pascal_label_colormap()\n\n if np.max(label) >= len(colormap):\n raise ValueError('label value too large.')\n\n return colormap[label]","def labelP_to_color_image(label):\r\n if label.ndim != 2:\r\n raise ValueError('Expect 2-D input label')\r\n\r\n colormap = create_pascal_label_colormap()\r\n\r\n if np.max(label) >= len(colormap):\r\n raise ValueError('label value too large.')\r\n\r\n return colormap[label]","def sanitizte_color(value):\n if len(value) == 7 and value[0] == '#':\n return \"#%06x\" % int(value[1:], 16)\n raise ValueError('invalid color')","def grayscaleColorTable(bits=8):\n conversion = 255./(2**bits-1)\n return ''.join([3*chr(int(conversion*i)) for i in range(2**bits)])","def binary_to_gray(self, num):\n return num ^ (num >> 1)","def _color_to_rgb(color, input):\n if input == \"hls\":\n color = colorsys.hls_to_rgb(*color)\n elif input == \"husl\":\n color = husl.husl_to_rgb(*color)\n elif input == \"xkcd\":\n color = xkcd_rgb[color]\n return color","def get_color(activePerMillion):\n activePer100k = activePerMillion / 10.0\n if activePer100k < 100:\n return \"#aaf0d1\"\n elif activePer100k < 500:\n return \"#a3f7bf\"\n elif activePer100k < 1000:\n return \"#90EE90\"\n elif activePer100k < 1500:\n return \"#00ff7f\"\n elif activePer100k < 2000:\n return \"#77dd77\"\n elif activePer100k < 2500:\n return \"#32cd32\"\n elif activePer100k < 3000:\n return \"#4cbb17\"\n elif activePer100k < 3500:\n return \"#228b22\"\n elif activePer100k < 4000:\n return \"#355e3b \"\n else:\n return \"#006400\"","def rgb(self, value):\n\n self._variable = value\n self._update()","def _gamut(component):\n return min(max(int(component), 0), 254)","def setColors255(self):\n #productive\n profprint()\n self.color255= [[0,0,0] for i in range(205)]\n self.color255[0]=[221,108,158]\n self.color255[1]=[128,174,128]\n self.color255[2]=[241,214,145]\n self.color255[3]=[177,122,101]\n self.color255[4]=[111,184,210]\n self.color255[5]=[216,101,79]\n self.color255[6]=[221,130,101]\n self.color255[7]=[144,238,144]\n self.color255[8]=[192,104,88]\n self.color255[9]=[220,245,20]\n self.color255[10]=[78,63,0]\n self.color255[11]=[255,250,220]\n self.color255[12]=[230,220,70]\n self.color255[13]=[200,200,235]\n self.color255[14]=[250,250,210]\n self.color255[15]=[244,214,49]\n self.color255[16]=[0,151,206]\n self.color255[17]=[183,156,220]\n self.color255[18]=[183,214,211]\n self.color255[19]=[152,189,207]\n self.color255[20]=[178,212,242]\n self.color255[21]=[68,172,100]\n self.color255[22]=[111,197,131]\n self.color255[23]=[85,188,255]\n self.color255[24]=[0,145,30]\n self.color255[25]=[214,230,130]\n self.color255[26]=[218,255,255]\n self.color255[27]=[170,250,250]\n self.color255[28]=[140,224,228]\n self.color255[29]=[188,65,28]\n self.color255[30]=[216,191,216]\n self.color255[31]=[145,60,66]\n self.color255[32]=[150,98,83]\n self.color255[33]=[250,250,225]\n self.color255[34]=[200,200,215]\n self.color255[35]=[68,131,98]\n self.color255[36]=[83,146,164]\n self.color255[37]=[162,115,105]\n self.color255[38]=[141,93,137]\n self.color255[39]=[182,166,110]\n self.color255[40]=[188,135,166]\n self.color255[41]=[154,150,201]\n self.color255[42]=[177,140,190]\n self.color255[43]=[30,111,85]\n self.color255[44]=[210,157,166]\n self.color255[45]=[48,129,126]\n self.color255[46]=[98,153,112]\n self.color255[47]=[69,110,53]\n self.color255[48]=[166,113,137]\n self.color255[49]=[122,101,38]\n self.color255[50]=[253,135,192]\n self.color255[51]=[145,92,109]\n self.color255[52]=[46,101,131]\n self.color255[53]=[0,108,112]\n self.color255[54]=[127,150,88]\n self.color255[55]=[159,116,163]\n self.color255[56]=[125,102,154]\n self.color255[57]=[106,174,155]\n self.color255[58]=[154,146,83]\n self.color255[59]=[126,126,55]\n self.color255[60]=[201,160,133]\n self.color255[61]=[78,152,141]\n self.color255[62]=[174,140,103]\n self.color255[63]=[139,126,177]\n self.color255[64]=[148,120,72]\n self.color255[65]=[186,135,135]\n self.color255[66]=[99,106,24]\n self.color255[67]=[156,171,108]\n self.color255[68]=[64,123,147]\n self.color255[69]=[138,95,74]\n self.color255[70]=[97,113,158]\n self.color255[71]=[126,161,197]\n self.color255[72]=[194,195,164]\n self.color255[73]=[88,106,215]\n self.color255[74]=[82,174,128]\n self.color255[75]=[57,157,110]\n self.color255[76]=[60,143,83]\n self.color255[77]=[92,162,109]\n self.color255[78]=[255,244,209]\n self.color255[79]=[201,121,77]\n self.color255[80]=[70,163,117]\n self.color255[81]=[188,91,95]\n self.color255[82]=[166,84,94]\n self.color255[83]=[182,105,107]\n self.color255[84]=[229,147,118]\n self.color255[85]=[174,122,90]\n self.color255[86]=[201,112,73]\n self.color255[87]=[194,142,0]\n self.color255[88]=[241,213,144]\n self.color255[89]=[203,179,77]\n self.color255[90]=[229,204,109]\n self.color255[91]=[255,243,152]\n self.color255[92]=[209,185,85]\n self.color255[93]=[248,223,131]\n self.color255[94]=[255,230,138]\n self.color255[95]=[196,172,68]\n self.color255[96]=[255,255,167]\n self.color255[97]=[255,250,160]\n self.color255[98]=[255,237,145]\n self.color255[99]=[242,217,123]\n self.color255[100]=[222,198,101]\n self.color255[101]=[213,124,109]\n self.color255[102]=[184,105,108]\n self.color255[103]=[150,208,243]\n self.color255[104]=[62,162,114]\n self.color255[105]=[242,206,142]\n self.color255[106]=[250,210,139]\n self.color255[107]=[255,255,207]\n self.color255[108]=[182,228,255]\n self.color255[109]=[175,216,244]\n self.color255[110]=[197,165,145]\n self.color255[111]=[172,138,115]\n self.color255[112]=[202,164,140]\n self.color255[113]=[224,186,162]\n self.color255[114]=[255,245,217]\n self.color255[115]=[206,110,84]\n self.color255[116]=[210,115,89]\n self.color255[117]=[203,108,81]\n self.color255[118]=[233,138,112]\n self.color255[119]=[195,100,73]\n self.color255[120]=[181,85,57]\n self.color255[121]=[152,55,13]\n self.color255[122]=[159,63,27]\n self.color255[123]=[166,70,38]\n self.color255[124]=[218,123,97]\n self.color255[125]=[225,130,104]\n self.color255[126]=[224,97,76]\n self.color255[127]=[184,122,154]\n self.color255[128]=[211,171,143]\n self.color255[129]=[47,150,103]\n self.color255[130]=[173,121,88]\n self.color255[131]=[188,95,76]\n self.color255[132]=[255,239,172]\n self.color255[133]=[226,202,134]\n self.color255[134]=[253,232,158]\n self.color255[135]=[244,217,154]\n self.color255[136]=[205,179,108]\n self.color255[137]=[186,124,161]\n self.color255[138]=[255,255,220]\n self.color255[139]=[234,234,194]\n self.color255[140]=[204,142,178]\n self.color255[141]=[180,119,153]\n self.color255[142]=[216,132,105]\n self.color255[143]=[255,253,229]\n self.color255[144]=[205,167,142]\n self.color255[145]=[204,168,143]\n self.color255[146]=[255,224,199]\n self.color255[147]=[139,150,98]\n self.color255[148]=[249,180,111]\n self.color255[149]=[157,108,162]\n self.color255[150]=[203,136,116]\n self.color255[151]=[185,102,83]\n self.color255[152]=[247,182,164]\n self.color255[153]=[222,154,132]\n self.color255[154]=[124,186,223]\n self.color255[155]=[249,186,150]\n self.color255[156]=[244,170,147]\n self.color255[157]=[255,181,158]\n self.color255[158]=[255,190,165]\n self.color255[159]=[227,153,130]\n self.color255[160]=[213,141,113]\n self.color255[161]=[193,123,103]\n self.color255[162]=[216,146,127]\n self.color255[163]=[230,158,140]\n self.color255[164]=[245,172,147]\n self.color255[165]=[241,172,151]\n self.color255[166]=[177,124,92]\n self.color255[167]=[171,85,68]\n self.color255[168]=[217,198,131]\n self.color255[169]=[212,188,102]\n self.color255[170]=[185,135,134]\n self.color255[171]=[198,175,125]\n self.color255[172]=[194,98,79]\n self.color255[173]=[255,238,170]\n self.color255[174]=[206,111,93]\n self.color255[175]=[216,186,0]\n self.color255[176]=[255,226,77]\n self.color255[177]=[255,243,106]\n self.color255[178]=[255,234,92]\n self.color255[179]=[240,210,35]\n self.color255[180]=[224,194,0]\n self.color255[181]=[213,99,79]\n self.color255[182]=[217,102,81]\n self.color255[183]=[0,147,202]\n self.color255[184]=[0,122,171]\n self.color255[185]=[186,77,64]\n self.color255[186]=[240,255,30]\n self.color255[187]=[185,232,61]\n self.color255[188]=[0,226,255]\n self.color255[189]=[251,159,255]\n self.color255[190]=[230,169,29]\n self.color255[191]=[0,194,113]\n self.color255[192]=[104,160,249]\n self.color255[193]=[221,108,158]\n self.color255[194]=[137,142,0]\n self.color255[195]=[230,70,0]\n self.color255[196]=[0,147,0]\n self.color255[197]=[0,147,248]\n self.color255[198]=[231,0,206]\n self.color255[199]=[129,78,0]\n self.color255[200]=[0,116,0]\n self.color255[201]=[0,0,255]\n self.color255[202]=[157,0,0]\n self.color255[203]=[100,100,130]\n self.color255[204]=[205,205,100]\n \n return self.color255","def toInt(self):\r\n rgb = self.toHex()[1:]\r\n return int(float.fromhex(rgb))","def convert_value(value):\n\n\t# print \"Attempting to match value: %s\" % value\n\n\tm = re.match('^(0(x|X)[0-9a-fA-F]+|[0-9]+)$', value)\n\tif m is None:\n\t\treturn None\n\n\tvalue = m.group(1)\n\tif value.startswith(\"0x\") or value.startswith(\"0X\"):\n\t\treturn int(value[2:], 16)\n\telse:\n\t\treturn int(value)","def brightness(value):\n value = int(value)\n if value < 1 or value > 254:\n raise ValueError('Minimum brightness is 1, to the maximum 254')\n return value","def reverse(color):\n return 255 - color","def to_hass_level(level):\n return int((level * 255) / 100)","def rgb(r, g, b):\n return \"\".join([\"%02X\" % max(0, min(x, 255)) for x in [r, g, b]])","def create_pascal_label_colormap():\r\n colormap = np.zeros((256, 3), dtype = int)\r\n ind = np.arange(256, dtype=int)\r\n\r\n for shift in reversed(range(8)):\r\n for channel in range(3):\r\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\r\n ind >>= 3\r\n\r\n return colormap","def set_param(self, name, val):\n # name will be 'colorR', 'colorG', 'colorB'\n rgb255 = int(val * 255)\n if name == 'colorR':\n self.color.r = rgb255\n elif name == 'colorG':\n self.color.g = rgb255\n elif name == 'colorB':\n self.color.b = rgb255","def colorize_xyz(xyz):\n xyz_vis = xyz - xyz.min()\n return (255 * xyz_vis / xyz_vis.max()).astype(np.uint8)","def setColor(val):\n if isinstance(val, str):\n val = val.upper()\n colors = {\"BLACK\": \"\\u001b[30m\",\n \"RED\": \"\\u001b[31m\",\n \"GREEN\": \"\\u001b[32m\",\n \"YELLOW\": \"\\u001b[33m\",\n \"BLUE\": \"\\u001b[34m\",\n \"MAGENTA\": \"\\u001b[35m\",\n \"CYAN\": \"\\u001b[36m\",\n \"WHITE\": \"\\u001b[37m\",\n \"RESET\": \"\\u001b[0m\"}\n if val in colors.keys():\n print(colors[val], end=\"\")\n return 0\n return -1","def ret(x):\n color = true_color if x else false_color\n return np.tile(color, (SIZE, SIZE, 1)).astype(np.uint8)","def binary_cmap(color='red', alpha=1.):\n if color == 'red':\n color_code = (1., 0., 0., alpha)\n elif color == 'green':\n color_code = (0., 1., 0., alpha)\n elif color == 'blue':\n color_code = (0., 0., 1., alpha)\n else:\n color_code = color\n transparent_code = (1., 1., 1., 0.)\n return ListedColormap([transparent_code, color_code])","def getColor(n, total = 255, decimal = False):\n\n value = round(255*n/(total * 1.0))\n\n #red value\n if value < 96:\n red = 0\n elif value < 160:\n red = 255/((160 - 96)*1.0) * (value - 96)\n elif value < 224:\n red = 255\n else:\n red = 255 - ((255 - 128)/((255 - 224) * 1.0) * (value - 224))\n\n\n #Green value\n if value < 32:\n green = 0\n elif value < 96:\n green = 255/((96 - 32)*1.0) * (value - 32)\n elif value < 160:\n green = 255\n elif value < 224:\n green = 255 - (255/((224 - 160) * 1.0) * (value - 160))\n else:\n green = 0\n\n\n #Blue value\n if value < 32:\n blue = 128 + (255 - 128)/((32 - 0) * 1.0) * (value - 0)\n elif value < 96:\n blue = 255\n elif value < 160:\n blue = 255 - ((255 - 0)/((160 - 96) * 1.0) * (value - 96))\n else:\n blue = 0\n\n if decimal:\n return (red / 255.0, green / 255.0, blue / 255.0)\n return (int(red), int(green), int(blue))","def create_colormap(seg_map):\n\tcolormap = np.zeros((256, 3), dtype=int)\n\tind = np.arange(256, dtype=int)\n\tfor shift in reversed(range(8)):\n\t\tfor channel in range(3):\n\t\t\tcolormap[:, channel] |= ((ind >> channel) & 1) << shift \n\t\tind >>= 3\n\treturn colormap[seg_map]","def compute_color_for_labels(label):\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\n return tuple(color)","def compute_color_for_labels(label):\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\n return tuple(color)","def compute_color_for_labels(label):\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\n return tuple(color)","def compute_color_for_labels(label):\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\n return tuple(color)","def color_obeject(val):\n if val == 'O':\n color = 'red'\n elif val == '<M8[ns]':\n color = 'blue'\n else:\n color = 'black'\n return 'color: %s' % color","def RGB_to_color(r: int, g: int, b: int, a: int=255):\n return np.clip(np.array([r, g, b, a], dtype='u1'), 0, 255)","def rgb_255(self):\n r, g, b = self.rgb\n return (r * 255, g * 255, b * 255)","def create_pascal_label_colormap():\n colormap = np.zeros((256, 3), dtype=int)\n ind = np.arange(256, dtype=int)\n\n for shift in reversed(range(8)):\n for channel in range(3):\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\n ind >>= 3\n\n return colormap","def create_pascal_label_colormap():\n colormap = np.zeros((256, 3), dtype=int)\n ind = np.arange(256, dtype=int)\n\n for shift in reversed(range(8)):\n for channel in range(3):\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\n ind >>= 3\n\n return colormap","def saturation(value):\n value = int(value)\n if value < 0 or value > 254:\n raise ValueError('Minimum saturation is 0, to the maximum 254')\n return value","def assert_int_255(i):\n i=int(i)\n if i<0:\n i=0\n if i>255:\n i=255\n return i","def label_to_color_image(label):\n if label.ndim != 2:\n raise ValueError('Expect 2-D input label')\n \n colormap = create_label_colormap()\n \n if np.max(label) >= len(colormap):\n raise ValueError('label value too large.')\n \n return colormap[label]","def label_color(label):\n if label < len(colors):\n return colors[label]\n else:\n warnings.warn('Label {} has no color, returning default.'.format(label))\n return (0, 255, 0)","def setColors255(self):\r\n # productive\r\n profprint()\r\n self.color255 = [[0, 0, 0] for i in range(MAXCOL)]\r\n self.color255[0] = [221, 108, 158]\r\n self.color255[1] = [128, 174, 128]\r\n self.color255[2] = [241, 214, 145]\r\n self.color255[3] = [177, 122, 101]\r\n self.color255[4] = [111, 184, 210]\r\n self.color255[5] = [216, 101, 79]\r\n self.color255[6] = [221, 130, 101]\r\n self.color255[7] = [144, 238, 144]\r\n self.color255[8] = [192, 104, 88]\r\n self.color255[9] = [220, 245, 20]\r\n self.color255[10] = [78, 63, 0]\r\n self.color255[11] = [255, 250, 220]\r\n self.color255[12] = [230, 220, 70]\r\n self.color255[13] = [200, 200, 235]\r\n self.color255[14] = [250, 250, 210]\r\n self.color255[15] = [244, 214, 49]\r\n self.color255[16] = [0, 151, 206]\r\n self.color255[17] = [183, 156, 220]\r\n self.color255[18] = [183, 214, 211]\r\n self.color255[19] = [152, 189, 207]\r\n self.color255[20] = [178, 212, 242]\r\n self.color255[21] = [68, 172, 100]\r\n self.color255[22] = [111, 197, 131]\r\n self.color255[23] = [85, 188, 255]\r\n self.color255[24] = [0, 145, 30]\r\n self.color255[25] = [214, 230, 130]\r\n self.color255[26] = [218, 255, 255]\r\n self.color255[27] = [170, 250, 250]\r\n self.color255[28] = [140, 224, 228]\r\n self.color255[29] = [188, 65, 28]\r\n self.color255[30] = [216, 191, 216]\r\n self.color255[31] = [145, 60, 66]\r\n self.color255[32] = [150, 98, 83]\r\n self.color255[33] = [250, 250, 225]\r\n self.color255[34] = [200, 200, 215]\r\n self.color255[35] = [68, 131, 98]\r\n self.color255[36] = [83, 146, 164]\r\n self.color255[37] = [162, 115, 105]\r\n self.color255[38] = [141, 93, 137]\r\n self.color255[39] = [182, 166, 110]\r\n self.color255[40] = [188, 135, 166]\r\n self.color255[41] = [154, 150, 201]\r\n self.color255[42] = [177, 140, 190]\r\n self.color255[43] = [30, 111, 85]\r\n self.color255[44] = [210, 157, 166]\r\n self.color255[45] = [48, 129, 126]\r\n self.color255[46] = [98, 153, 112]\r\n self.color255[47] = [69, 110, 53]\r\n self.color255[48] = [166, 113, 137]\r\n self.color255[49] = [122, 101, 38]\r\n self.color255[50] = [253, 135, 192]\r\n self.color255[51] = [145, 92, 109]\r\n self.color255[52] = [46, 101, 131]\r\n self.color255[53] = [0, 108, 112]\r\n self.color255[54] = [127, 150, 88]\r\n self.color255[55] = [159, 116, 163]\r\n self.color255[56] = [125, 102, 154]\r\n self.color255[57] = [106, 174, 155]\r\n self.color255[58] = [154, 146, 83]\r\n self.color255[59] = [126, 126, 55]\r\n self.color255[60] = [201, 160, 133]\r\n self.color255[61] = [78, 152, 141]\r\n self.color255[62] = [174, 140, 103]\r\n self.color255[63] = [139, 126, 177]\r\n self.color255[64] = [148, 120, 72]\r\n self.color255[65] = [186, 135, 135]\r\n self.color255[66] = [99, 106, 24]\r\n self.color255[67] = [156, 171, 108]\r\n self.color255[68] = [64, 123, 147]\r\n self.color255[69] = [138, 95, 74]\r\n self.color255[70] = [97, 113, 158]\r\n self.color255[71] = [126, 161, 197]\r\n self.color255[72] = [194, 195, 164]\r\n self.color255[73] = [88, 106, 215]\r\n self.color255[74] = [82, 174, 128]\r\n self.color255[75] = [57, 157, 110]\r\n self.color255[76] = [60, 143, 83]\r\n self.color255[77] = [92, 162, 109]\r\n self.color255[78] = [255, 244, 209]\r\n self.color255[79] = [201, 121, 77]\r\n self.color255[80] = [70, 163, 117]\r\n self.color255[81] = [188, 91, 95]\r\n self.color255[82] = [166, 84, 94]\r\n self.color255[83] = [182, 105, 107]\r\n self.color255[84] = [229, 147, 118]\r\n self.color255[85] = [174, 122, 90]\r\n self.color255[86] = [201, 112, 73]\r\n self.color255[87] = [194, 142, 0]\r\n self.color255[88] = [241, 213, 144]\r\n self.color255[89] = [203, 179, 77]\r\n self.color255[90] = [229, 204, 109]\r\n self.color255[91] = [255, 243, 152]\r\n self.color255[92] = [209, 185, 85]\r\n self.color255[93] = [248, 223, 131]\r\n self.color255[94] = [255, 230, 138]\r\n self.color255[95] = [196, 172, 68]\r\n self.color255[96] = [255, 255, 167]\r\n self.color255[97] = [255, 250, 160]\r\n self.color255[98] = [255, 237, 145]\r\n self.color255[99] = [242, 217, 123]\r\n self.color255[100] = [222, 198, 101]\r\n self.color255[101] = [213, 124, 109]\r\n self.color255[102] = [184, 105, 108]\r\n self.color255[103] = [150, 208, 243]\r\n self.color255[104] = [62, 162, 114]\r\n self.color255[105] = [242, 206, 142]\r\n self.color255[106] = [250, 210, 139]\r\n self.color255[107] = [255, 255, 207]\r\n self.color255[108] = [182, 228, 255]\r\n self.color255[109] = [175, 216, 244]\r\n self.color255[110] = [197, 165, 145]\r\n self.color255[111] = [172, 138, 115]\r\n self.color255[112] = [202, 164, 140]\r\n self.color255[113] = [224, 186, 162]\r\n self.color255[114] = [255, 245, 217]\r\n self.color255[115] = [206, 110, 84]\r\n self.color255[116] = [210, 115, 89]\r\n self.color255[117] = [203, 108, 81]\r\n self.color255[118] = [233, 138, 112]\r\n self.color255[119] = [195, 100, 73]\r\n self.color255[120] = [181, 85, 57]\r\n self.color255[121] = [152, 55, 13]\r\n self.color255[122] = [159, 63, 27]\r\n self.color255[123] = [166, 70, 38]\r\n self.color255[124] = [218, 123, 97]\r\n self.color255[125] = [225, 130, 104]\r\n self.color255[126] = [224, 97, 76]\r\n self.color255[127] = [184, 122, 154]\r\n self.color255[128] = [211, 171, 143]\r\n self.color255[129] = [47, 150, 103]\r\n self.color255[130] = [173, 121, 88]\r\n self.color255[131] = [188, 95, 76]\r\n self.color255[132] = [255, 239, 172]\r\n self.color255[133] = [226, 202, 134]\r\n self.color255[134] = [253, 232, 158]\r\n self.color255[135] = [244, 217, 154]\r\n self.color255[136] = [205, 179, 108]\r\n self.color255[137] = [186, 124, 161]\r\n self.color255[138] = [255, 255, 220]\r\n self.color255[139] = [234, 234, 194]\r\n self.color255[140] = [204, 142, 178]\r\n self.color255[141] = [180, 119, 153]\r\n self.color255[142] = [216, 132, 105]\r\n self.color255[143] = [255, 253, 229]\r\n self.color255[144] = [205, 167, 142]\r\n self.color255[145] = [204, 168, 143]\r\n self.color255[146] = [255, 224, 199]\r\n self.color255[147] = [139, 150, 98]\r\n self.color255[148] = [249, 180, 111]\r\n self.color255[149] = [157, 108, 162]\r\n self.color255[150] = [203, 136, 116]\r\n self.color255[151] = [185, 102, 83]\r\n self.color255[152] = [247, 182, 164]\r\n self.color255[153] = [222, 154, 132]\r\n self.color255[154] = [124, 186, 223]\r\n self.color255[155] = [249, 186, 150]\r\n self.color255[156] = [244, 170, 147]\r\n self.color255[157] = [255, 181, 158]\r\n self.color255[158] = [255, 190, 165]\r\n self.color255[159] = [227, 153, 130]\r\n self.color255[160] = [213, 141, 113]\r\n self.color255[161] = [193, 123, 103]\r\n self.color255[162] = [216, 146, 127]\r\n self.color255[163] = [230, 158, 140]\r\n self.color255[164] = [245, 172, 147]\r\n self.color255[165] = [241, 172, 151]\r\n self.color255[166] = [177, 124, 92]\r\n self.color255[167] = [171, 85, 68]\r\n self.color255[168] = [217, 198, 131]\r\n self.color255[169] = [212, 188, 102]\r\n self.color255[170] = [185, 135, 134]\r\n self.color255[171] = [198, 175, 125]\r\n self.color255[172] = [194, 98, 79]\r\n self.color255[173] = [255, 238, 170]\r\n self.color255[174] = [206, 111, 93]\r\n self.color255[175] = [216, 186, 0]\r\n self.color255[176] = [255, 226, 77]\r\n self.color255[177] = [255, 243, 106]\r\n self.color255[178] = [255, 234, 92]\r\n self.color255[179] = [240, 210, 35]\r\n self.color255[180] = [224, 194, 0]\r\n self.color255[181] = [213, 99, 79]\r\n self.color255[182] = [217, 102, 81]\r\n self.color255[183] = [0, 147, 202]\r\n self.color255[184] = [0, 122, 171]\r\n self.color255[185] = [186, 77, 64]\r\n self.color255[186] = [240, 255, 30]\r\n self.color255[187] = [185, 232, 61]\r\n self.color255[188] = [0, 226, 255]\r\n self.color255[189] = [251, 159, 255]\r\n self.color255[190] = [230, 169, 29]\r\n self.color255[191] = [0, 194, 113]\r\n self.color255[192] = [104, 160, 249]\r\n self.color255[193] = [221, 108, 158]\r\n self.color255[194] = [137, 142, 0]\r\n self.color255[195] = [230, 70, 0]\r\n self.color255[196] = [0, 147, 0]\r\n self.color255[197] = [0, 147, 248]\r\n self.color255[198] = [231, 0, 206]\r\n self.color255[199] = [129, 78, 0]\r\n self.color255[200] = [0, 116, 0]\r\n self.color255[201] = [0, 0, 255]\r\n self.color255[202] = [157, 0, 0]\r\n self.color255[203] = [100, 100, 130]\r\n self.color255[204] = [205, 205, 100]\r\n self.color255[205] = [255, 255, 0]\r\n\r\n return self.color255","def cmap(self, background_color='#000000'):\n return get_cmap(self.img.data.max() + 1,\n background_color=background_color)","def encode_labelmap(colour_img, colourlabelmap):\n colour_img = colour_img.astype(int)\n labels = np.zeros((colour_img.shape[0], colour_img.shape[1]), dtype=np.int16)\n for label_id, colour in enumerate(colourlabelmap):\n labels[np.where(np.all(colour == colour_img, axis=-1))] = label_id\n\n return labels","def __value2color(self, v):\n if np.isscalar(v):\n r = self.cmap(self.norm(np.asarray([v])))\n else:\n r = self.cmap(self.norm(v))\n return r.flatten()","def map_binary_values(x) -> int:\n return _bm.get(x, -1)","def randcolor():\n return (randint(0,255), randint(0,255), randint(0,255))","def __init__(self, bits=8):\n\n self.map = {}\n self.bits = bits\n for r, g, b in itertools.product(range(2 ** bits), repeat=3):\n self.map[(r << 2 * bits) + (g << bits) + b] = rgb2lab(r << (8 - bits), g << (8 - bits), b << (8 - bits))","def create_pascal_label_colormap():\n colormap = np.zeros((256, 3), dtype=int)\n ind = np.arange(256, dtype=int)\n\n for shift in reversed(range(8)):\n for channel in range(3):\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\n ind >>= 3\n\n return colormap","def create_pascal_label_colormap():\n colormap = np.zeros((256, 3), dtype=int)\n ind = np.arange(256, dtype=int)\n\n for shift in reversed(range(8)):\n for channel in range(3):\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\n ind >>= 3\n\n return colormap","def compute_color_for_labels(label):\n\tcolor = [int((p * (label**2 - label + 1)) % 255) for p in palette]\n\treturn tuple(color)","def getColorFlag(color):\n if color == 0: # MONO\n return 0\n elif color == 1: # BAYER\n return -1\n elif color == 2: # AS IS RBG\n return 1"],"string":"[\n \"def color_map(val):\\n color_code = remap_interval(val, -1, 1, 0, 255)\\n return int(color_code)\",\n \"def c_map(val):\\n return int(remap(val, -1, 1, 0, 255))\",\n \"def get_color(self, value):\\n value = min(max(0,value), 1) * 510\\n\\n if value < 255:\\n redValue = 255\\n greenValue = math.sqrt(value) * 16\\n greenValue = int(greenValue)\\n else:\\n greenValue = 255\\n value = value - 255\\n redValue = 255 - (value * value / 255)\\n redValue = int(redValue)\\n return '#' + f\\\"{redValue:0{2}x}\\\" + f\\\"{greenValue:0{2}x}\\\" + '00'\",\n \"def IntToColor(number):\\n color = COLORS_INDEX.get(number)\\n return color if color else 'default'\",\n \"def mapper(value):\\n\\n out = scalarMap.to_rgba(value)\\n\\n if isinstance(out, tuple):\\n return tuple([255 * out[i] for i in range(3)] + [alpha])\\n\\n elif isinstance(out, np.ndarray):\\n out[:, :-1] *= 255\\n out[:, 3] = alpha\\n return out\",\n \"def int2color(x):\\n # r = int(1000 * x % 255)\\n # g = int(10000 * x % 255)\\n # b = int(100000 * x % 255)\\n x = 0 if x == 0 else int(1/x)\\n b = x & 0xff\\n g = (x >> 8) & 0xff\\n r = (x >> 16) & 0xff\\n return [r, g, b]\",\n \"def map_01_to_8bit(value):\\n result = None\\n result = int(map_bound(value, 0.0, 1.0, 0, 255))\\n return result\",\n \"def color_from_value(self, value):\\n \\n return ImageColor.getrgb(\\\"hsl(%d,%d%%,%d%%)\\\" % (int( (1.0 - value) * 360 ), 80, 50))\",\n \"def _to_color(indx, base):\\n base2 = base * base\\n b = 2 - indx / base2\\n r = 2 - (indx % base2) / base\\n g = 2 - (indx % base2) % base\\n return b * 127, r * 127, g * 127\",\n \"def Amber_to_Green(val):\\n\\tif val == 1 :\\n\\t\\treturn \\\"GREEN\\\"\\n\\telif val == -1:\\n\\t\\treturn \\\"RED\\\"\",\n \"def checkRGBRange(value):\\n\\ttry:\\n\\t\\tv = int(value)\\n\\t\\tif 0 <= v <= 255:\\n\\t\\t\\treturn v\\n\\texcept:\\n\\t\\treturn 255\",\n \"def normalize_01(x):\\n return x / 255.0\",\n \"def _to_code(rgb):\\n code = 0\\n if 'r' in rgb:\\n code += 1\\n\\n if 'g' in rgb:\\n code += 2\\n\\n if 'b' in rgb:\\n code += 4\\n return code\",\n \"def fromInts(r, g, b):\\n return IColor(r/255.,g/255.,b/255.)\",\n \"def hue(value):\\n value = int(value)\\n if value < 0 or value > 65535:\\n raise ValueError('Hue is a value between 0 and 65535')\\n return value\",\n \"def getColor(self,number):\\n if number >= 0:\\n if self.inverse:\\n ret = cs.hsv_to_rgb(0,0,abs(number/self.maxp))\\n else:\\n ret = cs.hsv_to_rgb(0,0,1-abs(number/self.maxp))\\n else:\\n if self.inverse:\\n ret = cs.hsv_to_rgb(0,1-abs(number/self.maxn),1)\\n else:\\n ret = cs.hsv_to_rgb(0,abs(number/self.maxn),1)\\n return [ret[0]*255.0,ret[1]*255.0,ret[2]*255.0]\",\n \"def _bool_to_color(value) -> int:\\n if value is True:\\n return RED\\n return BLACK\",\n \"def get_color(in_val, min_val=0, max_val=100):\\n width = max_val - min_val\\n unit = width / len(continuum)\\n return continuum[min(int(in_val / unit), 19)]\",\n \"def cmap(num,cmap = plt.cm.gist_earth_r):\\n return cmap(np.linspace(0, 1, num))\",\n \"def is_0to255(value):\\n return 0 <= value <= 255\",\n \"def getColor(self,number):\\n if number >= 0:\\n ret = cs.hsv_to_rgb(0,0,1-abs(number/self.maxp))\\n else:\\n ret = cs.hsv_to_rgb(0,abs(number/self.maxn),1)\\n hexcolor = '#%02x%02x%02x' % (ret[0]*255,ret[1]*255,ret[2]*255)\\n return hexcolor\",\n \"def color_negative_red_positive_green(val):\\n if val < 0:\\n color = 'red'\\n elif val > 0:\\n color = 'green'\\n else:\\n color = 'black'\\n\\n return 'color: %s' % color\",\n \"def set_rgb(self, value):\\n act = RGBAction(self, value)\\n return act.invoke()\",\n \"def scale_to_01(color: C3I) -> C3F:\\n r, g, b = color\\n return r / 255, g / 255, b / 255\",\n \"def color_negative_red(value):\\n\\n if value == 1:\\n color = 'red'\\n else:\\n color = 'black'\\n\\n return 'color: %s' % color\",\n \"def lut(threshold):\\n\\n return [255 if i<=threshold else 0 for i in range(256)]\",\n \"def one_hot_encode_single(mapping: dict[str, int], value: Optional[str]) -> IntArray:\\n encoded_value = np.zeros((1, len(mapping)))\\n if not pd.isna(value):\\n code = mapping[str(value)]\\n encoded_value[0, code] = 1\\n return encoded_value\",\n \"def color_positive_green(val):\\n\\tif val > 0: \\n\\t\\tcolor = 'green'\\n\\telse: \\n\\t\\tcolor = 'red'\\n\\treturn 'background-color: %s' % color\",\n \"def colorize_label_map(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label. Got {}'.format(label.shape))\\n\\n colormap = colormap_ade20k\\n label_mod = np.mod(label, len(colormap))\\n return colormap[label_mod].astype(np.uint8)\",\n \"def test_color__int_arg(self):\\n for value in (0x0, 0xFFFFFFFF, 0xAABBCCDD):\\n color = pygame.Color(value)\\n\\n self.assertEqual(color.r, (value >> 24) & 0xFF)\\n self.assertEqual(color.g, (value >> 16) & 0xFF)\\n self.assertEqual(color.b, (value >> 8) & 0xFF)\\n self.assertEqual(color.a, value & 0xFF)\",\n \"def int2color_tuple(x):\\n red_val = int(1000 * x % 255)\\n green_val = int(10000 * x % 255)\\n blue_val = int(100000 * x % 255)\\n return red_val, green_val, blue_val\",\n \"def change( p ):\\n red = p[0]\\n green = p[1]\\n blue = p[2]\\n return [ 255-red, 255-green, 255-blue ]\",\n \"def colorToInt(color):\\n color_table = reverse(COLORS_INDEX)\\n color_number = color_table.get(color)\\n return color_number if color_number else 0\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label.')\\n\\n colormap = create_pascal_label_colormap()\\n\\n if np.max(label) >= len(colormap):\\n raise ValueError('Label value too large.')\\n\\n return colormap[label]\",\n \"def color_conversion(string):\\n if (string == 'J'):\\n return 0.14\\n if (string == 'I'):\\n return 0.28\\n if (string == 'H'):\\n return 0.42\\n if (string == 'G'):\\n return 0.56\\n if (string == 'F'):\\n return 0.70\\n if (string == 'E'):\\n return 0.84\\n if (string == 'D'):\\n return 1\",\n \"def rgb_2_scalar_idx(r, g, b):\\n return 256 ** 2 * r + 256 * g + b\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label')\\n\\n colormap = create_pascal_label_colormap()\\n\\n if np.max(label) >= len(colormap):\\n raise ValueError('label value too large.')\\n\\n return colormap[label]\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label')\\n\\n colormap = create_pascal_label_colormap()\\n\\n if np.max(label) >= len(colormap):\\n raise ValueError('label value too large.')\\n\\n return colormap[label]\",\n \"def toRGB(self):\\n\\t\\treturn '#'+ (hex(self.politics)[2:].upper().rjust(6,'0'))\",\n \"def color(value):\\r\\n return 'RGB({}, {}, {})'.format(value.red(), value.blue(), value.green())\",\n \"def map_channels(self, map_function):\\n return ScreenColor(map_function(self.red), map_function(self.green), map_function(self.blue))\",\n \"def get_label_color_mapping(idx):\\n # https://gist.github.com/wllhf/a4533e0adebe57e3ed06d4b50c8419ae\\n def bitget(byteval, ch):\\n return (byteval & (1 << ch)) != 0\\n r = g = b = 0\\n for j in range(8):\\n r = r | (bitget(idx, 0) << 7 - j)\\n g = g | (bitget(idx, 1) << 7 - j)\\n b = b | (bitget(idx, 2) << 7 - j)\\n idx = idx >> 3\\n return np.array([r, g, b], dtype=np.uint8)\",\n \"def my_color_function(field):\\n if field > 100000000:\\n return \\\"#ff0000\\\"\\n else:\\n return \\\"#008000\\\"\",\n \"def gray_code(number: int) -> list:\\n if number <= 0:\\n return -1\\n\\n result: list = []\\n result.append(\\\"0\\\")\\n result.append(\\\"1\\\")\\n num1 = 2\\n\\n while True:\\n if num1 >= 1 << number:\\n break\\n\\n for j in range (num1 - 1, -1, -1):\\n result.append(result[j])\\n\\n for j in range (num1):\\n result[j] = \\\"0\\\" + result[j]\\n\\n for j in range (num1, 2 * num1):\\n result[j] = \\\"1\\\" + result[j]\\n\\n num1 = num1 << 1\\n\\n return result\",\n \"def intensity(self, value: int, /) -> None:\",\n \"def _get_color(self, c, x, max_num):\\n\\n ratio = 5*(float(x)/max_num)\\n i = int(math.floor(ratio))\\n j = int(math.ceil(ratio))\\n ratio -= i\\n r = (1 - ratio) * self._colors[i][c] + ratio*self._colors[j][c]\\n return int(255*r)\",\n \"def create_range_map(points_xyz: NDArrayFloat) -> NDArrayByte:\\n range = points_xyz[..., 2]\\n range = np.round(range).astype(int)\\n color = plt.get_cmap(\\\"turbo\\\")(np.arange(0, range.max() + 1))\\n color = color[range]\\n range_cmap: NDArrayByte = (color * 255.0).astype(np.uint8)\\n return range_cmap\",\n \"def convert_to_RGB_255(colors):\\n return (colors[0]*255.0, colors[1]*255.0, colors[2]*255.0)\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label')\\n\\n colormap = create_pascal_label_colormap()\\n\\n if np.max(label) >= len(colormap):\\n raise ValueError('label value too large.')\\n\\n return colormap[label]\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label')\\n\\n colormap = create_pascal_label_colormap()\\n\\n if np.max(label) >= len(colormap):\\n raise ValueError('label value too large.')\\n\\n return colormap[label]\",\n \"def labelP_to_color_image(label):\\r\\n if label.ndim != 2:\\r\\n raise ValueError('Expect 2-D input label')\\r\\n\\r\\n colormap = create_pascal_label_colormap()\\r\\n\\r\\n if np.max(label) >= len(colormap):\\r\\n raise ValueError('label value too large.')\\r\\n\\r\\n return colormap[label]\",\n \"def sanitizte_color(value):\\n if len(value) == 7 and value[0] == '#':\\n return \\\"#%06x\\\" % int(value[1:], 16)\\n raise ValueError('invalid color')\",\n \"def grayscaleColorTable(bits=8):\\n conversion = 255./(2**bits-1)\\n return ''.join([3*chr(int(conversion*i)) for i in range(2**bits)])\",\n \"def binary_to_gray(self, num):\\n return num ^ (num >> 1)\",\n \"def _color_to_rgb(color, input):\\n if input == \\\"hls\\\":\\n color = colorsys.hls_to_rgb(*color)\\n elif input == \\\"husl\\\":\\n color = husl.husl_to_rgb(*color)\\n elif input == \\\"xkcd\\\":\\n color = xkcd_rgb[color]\\n return color\",\n \"def get_color(activePerMillion):\\n activePer100k = activePerMillion / 10.0\\n if activePer100k < 100:\\n return \\\"#aaf0d1\\\"\\n elif activePer100k < 500:\\n return \\\"#a3f7bf\\\"\\n elif activePer100k < 1000:\\n return \\\"#90EE90\\\"\\n elif activePer100k < 1500:\\n return \\\"#00ff7f\\\"\\n elif activePer100k < 2000:\\n return \\\"#77dd77\\\"\\n elif activePer100k < 2500:\\n return \\\"#32cd32\\\"\\n elif activePer100k < 3000:\\n return \\\"#4cbb17\\\"\\n elif activePer100k < 3500:\\n return \\\"#228b22\\\"\\n elif activePer100k < 4000:\\n return \\\"#355e3b \\\"\\n else:\\n return \\\"#006400\\\"\",\n \"def rgb(self, value):\\n\\n self._variable = value\\n self._update()\",\n \"def _gamut(component):\\n return min(max(int(component), 0), 254)\",\n \"def setColors255(self):\\n #productive\\n profprint()\\n self.color255= [[0,0,0] for i in range(205)]\\n self.color255[0]=[221,108,158]\\n self.color255[1]=[128,174,128]\\n self.color255[2]=[241,214,145]\\n self.color255[3]=[177,122,101]\\n self.color255[4]=[111,184,210]\\n self.color255[5]=[216,101,79]\\n self.color255[6]=[221,130,101]\\n self.color255[7]=[144,238,144]\\n self.color255[8]=[192,104,88]\\n self.color255[9]=[220,245,20]\\n self.color255[10]=[78,63,0]\\n self.color255[11]=[255,250,220]\\n self.color255[12]=[230,220,70]\\n self.color255[13]=[200,200,235]\\n self.color255[14]=[250,250,210]\\n self.color255[15]=[244,214,49]\\n self.color255[16]=[0,151,206]\\n self.color255[17]=[183,156,220]\\n self.color255[18]=[183,214,211]\\n self.color255[19]=[152,189,207]\\n self.color255[20]=[178,212,242]\\n self.color255[21]=[68,172,100]\\n self.color255[22]=[111,197,131]\\n self.color255[23]=[85,188,255]\\n self.color255[24]=[0,145,30]\\n self.color255[25]=[214,230,130]\\n self.color255[26]=[218,255,255]\\n self.color255[27]=[170,250,250]\\n self.color255[28]=[140,224,228]\\n self.color255[29]=[188,65,28]\\n self.color255[30]=[216,191,216]\\n self.color255[31]=[145,60,66]\\n self.color255[32]=[150,98,83]\\n self.color255[33]=[250,250,225]\\n self.color255[34]=[200,200,215]\\n self.color255[35]=[68,131,98]\\n self.color255[36]=[83,146,164]\\n self.color255[37]=[162,115,105]\\n self.color255[38]=[141,93,137]\\n self.color255[39]=[182,166,110]\\n self.color255[40]=[188,135,166]\\n self.color255[41]=[154,150,201]\\n self.color255[42]=[177,140,190]\\n self.color255[43]=[30,111,85]\\n self.color255[44]=[210,157,166]\\n self.color255[45]=[48,129,126]\\n self.color255[46]=[98,153,112]\\n self.color255[47]=[69,110,53]\\n self.color255[48]=[166,113,137]\\n self.color255[49]=[122,101,38]\\n self.color255[50]=[253,135,192]\\n self.color255[51]=[145,92,109]\\n self.color255[52]=[46,101,131]\\n self.color255[53]=[0,108,112]\\n self.color255[54]=[127,150,88]\\n self.color255[55]=[159,116,163]\\n self.color255[56]=[125,102,154]\\n self.color255[57]=[106,174,155]\\n self.color255[58]=[154,146,83]\\n self.color255[59]=[126,126,55]\\n self.color255[60]=[201,160,133]\\n self.color255[61]=[78,152,141]\\n self.color255[62]=[174,140,103]\\n self.color255[63]=[139,126,177]\\n self.color255[64]=[148,120,72]\\n self.color255[65]=[186,135,135]\\n self.color255[66]=[99,106,24]\\n self.color255[67]=[156,171,108]\\n self.color255[68]=[64,123,147]\\n self.color255[69]=[138,95,74]\\n self.color255[70]=[97,113,158]\\n self.color255[71]=[126,161,197]\\n self.color255[72]=[194,195,164]\\n self.color255[73]=[88,106,215]\\n self.color255[74]=[82,174,128]\\n self.color255[75]=[57,157,110]\\n self.color255[76]=[60,143,83]\\n self.color255[77]=[92,162,109]\\n self.color255[78]=[255,244,209]\\n self.color255[79]=[201,121,77]\\n self.color255[80]=[70,163,117]\\n self.color255[81]=[188,91,95]\\n self.color255[82]=[166,84,94]\\n self.color255[83]=[182,105,107]\\n self.color255[84]=[229,147,118]\\n self.color255[85]=[174,122,90]\\n self.color255[86]=[201,112,73]\\n self.color255[87]=[194,142,0]\\n self.color255[88]=[241,213,144]\\n self.color255[89]=[203,179,77]\\n self.color255[90]=[229,204,109]\\n self.color255[91]=[255,243,152]\\n self.color255[92]=[209,185,85]\\n self.color255[93]=[248,223,131]\\n self.color255[94]=[255,230,138]\\n self.color255[95]=[196,172,68]\\n self.color255[96]=[255,255,167]\\n self.color255[97]=[255,250,160]\\n self.color255[98]=[255,237,145]\\n self.color255[99]=[242,217,123]\\n self.color255[100]=[222,198,101]\\n self.color255[101]=[213,124,109]\\n self.color255[102]=[184,105,108]\\n self.color255[103]=[150,208,243]\\n self.color255[104]=[62,162,114]\\n self.color255[105]=[242,206,142]\\n self.color255[106]=[250,210,139]\\n self.color255[107]=[255,255,207]\\n self.color255[108]=[182,228,255]\\n self.color255[109]=[175,216,244]\\n self.color255[110]=[197,165,145]\\n self.color255[111]=[172,138,115]\\n self.color255[112]=[202,164,140]\\n self.color255[113]=[224,186,162]\\n self.color255[114]=[255,245,217]\\n self.color255[115]=[206,110,84]\\n self.color255[116]=[210,115,89]\\n self.color255[117]=[203,108,81]\\n self.color255[118]=[233,138,112]\\n self.color255[119]=[195,100,73]\\n self.color255[120]=[181,85,57]\\n self.color255[121]=[152,55,13]\\n self.color255[122]=[159,63,27]\\n self.color255[123]=[166,70,38]\\n self.color255[124]=[218,123,97]\\n self.color255[125]=[225,130,104]\\n self.color255[126]=[224,97,76]\\n self.color255[127]=[184,122,154]\\n self.color255[128]=[211,171,143]\\n self.color255[129]=[47,150,103]\\n self.color255[130]=[173,121,88]\\n self.color255[131]=[188,95,76]\\n self.color255[132]=[255,239,172]\\n self.color255[133]=[226,202,134]\\n self.color255[134]=[253,232,158]\\n self.color255[135]=[244,217,154]\\n self.color255[136]=[205,179,108]\\n self.color255[137]=[186,124,161]\\n self.color255[138]=[255,255,220]\\n self.color255[139]=[234,234,194]\\n self.color255[140]=[204,142,178]\\n self.color255[141]=[180,119,153]\\n self.color255[142]=[216,132,105]\\n self.color255[143]=[255,253,229]\\n self.color255[144]=[205,167,142]\\n self.color255[145]=[204,168,143]\\n self.color255[146]=[255,224,199]\\n self.color255[147]=[139,150,98]\\n self.color255[148]=[249,180,111]\\n self.color255[149]=[157,108,162]\\n self.color255[150]=[203,136,116]\\n self.color255[151]=[185,102,83]\\n self.color255[152]=[247,182,164]\\n self.color255[153]=[222,154,132]\\n self.color255[154]=[124,186,223]\\n self.color255[155]=[249,186,150]\\n self.color255[156]=[244,170,147]\\n self.color255[157]=[255,181,158]\\n self.color255[158]=[255,190,165]\\n self.color255[159]=[227,153,130]\\n self.color255[160]=[213,141,113]\\n self.color255[161]=[193,123,103]\\n self.color255[162]=[216,146,127]\\n self.color255[163]=[230,158,140]\\n self.color255[164]=[245,172,147]\\n self.color255[165]=[241,172,151]\\n self.color255[166]=[177,124,92]\\n self.color255[167]=[171,85,68]\\n self.color255[168]=[217,198,131]\\n self.color255[169]=[212,188,102]\\n self.color255[170]=[185,135,134]\\n self.color255[171]=[198,175,125]\\n self.color255[172]=[194,98,79]\\n self.color255[173]=[255,238,170]\\n self.color255[174]=[206,111,93]\\n self.color255[175]=[216,186,0]\\n self.color255[176]=[255,226,77]\\n self.color255[177]=[255,243,106]\\n self.color255[178]=[255,234,92]\\n self.color255[179]=[240,210,35]\\n self.color255[180]=[224,194,0]\\n self.color255[181]=[213,99,79]\\n self.color255[182]=[217,102,81]\\n self.color255[183]=[0,147,202]\\n self.color255[184]=[0,122,171]\\n self.color255[185]=[186,77,64]\\n self.color255[186]=[240,255,30]\\n self.color255[187]=[185,232,61]\\n self.color255[188]=[0,226,255]\\n self.color255[189]=[251,159,255]\\n self.color255[190]=[230,169,29]\\n self.color255[191]=[0,194,113]\\n self.color255[192]=[104,160,249]\\n self.color255[193]=[221,108,158]\\n self.color255[194]=[137,142,0]\\n self.color255[195]=[230,70,0]\\n self.color255[196]=[0,147,0]\\n self.color255[197]=[0,147,248]\\n self.color255[198]=[231,0,206]\\n self.color255[199]=[129,78,0]\\n self.color255[200]=[0,116,0]\\n self.color255[201]=[0,0,255]\\n self.color255[202]=[157,0,0]\\n self.color255[203]=[100,100,130]\\n self.color255[204]=[205,205,100]\\n \\n return self.color255\",\n \"def toInt(self):\\r\\n rgb = self.toHex()[1:]\\r\\n return int(float.fromhex(rgb))\",\n \"def convert_value(value):\\n\\n\\t# print \\\"Attempting to match value: %s\\\" % value\\n\\n\\tm = re.match('^(0(x|X)[0-9a-fA-F]+|[0-9]+)$', value)\\n\\tif m is None:\\n\\t\\treturn None\\n\\n\\tvalue = m.group(1)\\n\\tif value.startswith(\\\"0x\\\") or value.startswith(\\\"0X\\\"):\\n\\t\\treturn int(value[2:], 16)\\n\\telse:\\n\\t\\treturn int(value)\",\n \"def brightness(value):\\n value = int(value)\\n if value < 1 or value > 254:\\n raise ValueError('Minimum brightness is 1, to the maximum 254')\\n return value\",\n \"def reverse(color):\\n return 255 - color\",\n \"def to_hass_level(level):\\n return int((level * 255) / 100)\",\n \"def rgb(r, g, b):\\n return \\\"\\\".join([\\\"%02X\\\" % max(0, min(x, 255)) for x in [r, g, b]])\",\n \"def create_pascal_label_colormap():\\r\\n colormap = np.zeros((256, 3), dtype = int)\\r\\n ind = np.arange(256, dtype=int)\\r\\n\\r\\n for shift in reversed(range(8)):\\r\\n for channel in range(3):\\r\\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\\r\\n ind >>= 3\\r\\n\\r\\n return colormap\",\n \"def set_param(self, name, val):\\n # name will be 'colorR', 'colorG', 'colorB'\\n rgb255 = int(val * 255)\\n if name == 'colorR':\\n self.color.r = rgb255\\n elif name == 'colorG':\\n self.color.g = rgb255\\n elif name == 'colorB':\\n self.color.b = rgb255\",\n \"def colorize_xyz(xyz):\\n xyz_vis = xyz - xyz.min()\\n return (255 * xyz_vis / xyz_vis.max()).astype(np.uint8)\",\n \"def setColor(val):\\n if isinstance(val, str):\\n val = val.upper()\\n colors = {\\\"BLACK\\\": \\\"\\\\u001b[30m\\\",\\n \\\"RED\\\": \\\"\\\\u001b[31m\\\",\\n \\\"GREEN\\\": \\\"\\\\u001b[32m\\\",\\n \\\"YELLOW\\\": \\\"\\\\u001b[33m\\\",\\n \\\"BLUE\\\": \\\"\\\\u001b[34m\\\",\\n \\\"MAGENTA\\\": \\\"\\\\u001b[35m\\\",\\n \\\"CYAN\\\": \\\"\\\\u001b[36m\\\",\\n \\\"WHITE\\\": \\\"\\\\u001b[37m\\\",\\n \\\"RESET\\\": \\\"\\\\u001b[0m\\\"}\\n if val in colors.keys():\\n print(colors[val], end=\\\"\\\")\\n return 0\\n return -1\",\n \"def ret(x):\\n color = true_color if x else false_color\\n return np.tile(color, (SIZE, SIZE, 1)).astype(np.uint8)\",\n \"def binary_cmap(color='red', alpha=1.):\\n if color == 'red':\\n color_code = (1., 0., 0., alpha)\\n elif color == 'green':\\n color_code = (0., 1., 0., alpha)\\n elif color == 'blue':\\n color_code = (0., 0., 1., alpha)\\n else:\\n color_code = color\\n transparent_code = (1., 1., 1., 0.)\\n return ListedColormap([transparent_code, color_code])\",\n \"def getColor(n, total = 255, decimal = False):\\n\\n value = round(255*n/(total * 1.0))\\n\\n #red value\\n if value < 96:\\n red = 0\\n elif value < 160:\\n red = 255/((160 - 96)*1.0) * (value - 96)\\n elif value < 224:\\n red = 255\\n else:\\n red = 255 - ((255 - 128)/((255 - 224) * 1.0) * (value - 224))\\n\\n\\n #Green value\\n if value < 32:\\n green = 0\\n elif value < 96:\\n green = 255/((96 - 32)*1.0) * (value - 32)\\n elif value < 160:\\n green = 255\\n elif value < 224:\\n green = 255 - (255/((224 - 160) * 1.0) * (value - 160))\\n else:\\n green = 0\\n\\n\\n #Blue value\\n if value < 32:\\n blue = 128 + (255 - 128)/((32 - 0) * 1.0) * (value - 0)\\n elif value < 96:\\n blue = 255\\n elif value < 160:\\n blue = 255 - ((255 - 0)/((160 - 96) * 1.0) * (value - 96))\\n else:\\n blue = 0\\n\\n if decimal:\\n return (red / 255.0, green / 255.0, blue / 255.0)\\n return (int(red), int(green), int(blue))\",\n \"def create_colormap(seg_map):\\n\\tcolormap = np.zeros((256, 3), dtype=int)\\n\\tind = np.arange(256, dtype=int)\\n\\tfor shift in reversed(range(8)):\\n\\t\\tfor channel in range(3):\\n\\t\\t\\tcolormap[:, channel] |= ((ind >> channel) & 1) << shift \\n\\t\\tind >>= 3\\n\\treturn colormap[seg_map]\",\n \"def compute_color_for_labels(label):\\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\\n return tuple(color)\",\n \"def compute_color_for_labels(label):\\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\\n return tuple(color)\",\n \"def compute_color_for_labels(label):\\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\\n return tuple(color)\",\n \"def compute_color_for_labels(label):\\n color = [int((p * (label ** 2 - label + 1)) % 255) for p in palette]\\n return tuple(color)\",\n \"def color_obeject(val):\\n if val == 'O':\\n color = 'red'\\n elif val == '<M8[ns]':\\n color = 'blue'\\n else:\\n color = 'black'\\n return 'color: %s' % color\",\n \"def RGB_to_color(r: int, g: int, b: int, a: int=255):\\n return np.clip(np.array([r, g, b, a], dtype='u1'), 0, 255)\",\n \"def rgb_255(self):\\n r, g, b = self.rgb\\n return (r * 255, g * 255, b * 255)\",\n \"def create_pascal_label_colormap():\\n colormap = np.zeros((256, 3), dtype=int)\\n ind = np.arange(256, dtype=int)\\n\\n for shift in reversed(range(8)):\\n for channel in range(3):\\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\\n ind >>= 3\\n\\n return colormap\",\n \"def create_pascal_label_colormap():\\n colormap = np.zeros((256, 3), dtype=int)\\n ind = np.arange(256, dtype=int)\\n\\n for shift in reversed(range(8)):\\n for channel in range(3):\\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\\n ind >>= 3\\n\\n return colormap\",\n \"def saturation(value):\\n value = int(value)\\n if value < 0 or value > 254:\\n raise ValueError('Minimum saturation is 0, to the maximum 254')\\n return value\",\n \"def assert_int_255(i):\\n i=int(i)\\n if i<0:\\n i=0\\n if i>255:\\n i=255\\n return i\",\n \"def label_to_color_image(label):\\n if label.ndim != 2:\\n raise ValueError('Expect 2-D input label')\\n \\n colormap = create_label_colormap()\\n \\n if np.max(label) >= len(colormap):\\n raise ValueError('label value too large.')\\n \\n return colormap[label]\",\n \"def label_color(label):\\n if label < len(colors):\\n return colors[label]\\n else:\\n warnings.warn('Label {} has no color, returning default.'.format(label))\\n return (0, 255, 0)\",\n \"def setColors255(self):\\r\\n # productive\\r\\n profprint()\\r\\n self.color255 = [[0, 0, 0] for i in range(MAXCOL)]\\r\\n self.color255[0] = [221, 108, 158]\\r\\n self.color255[1] = [128, 174, 128]\\r\\n self.color255[2] = [241, 214, 145]\\r\\n self.color255[3] = [177, 122, 101]\\r\\n self.color255[4] = [111, 184, 210]\\r\\n self.color255[5] = [216, 101, 79]\\r\\n self.color255[6] = [221, 130, 101]\\r\\n self.color255[7] = [144, 238, 144]\\r\\n self.color255[8] = [192, 104, 88]\\r\\n self.color255[9] = [220, 245, 20]\\r\\n self.color255[10] = [78, 63, 0]\\r\\n self.color255[11] = [255, 250, 220]\\r\\n self.color255[12] = [230, 220, 70]\\r\\n self.color255[13] = [200, 200, 235]\\r\\n self.color255[14] = [250, 250, 210]\\r\\n self.color255[15] = [244, 214, 49]\\r\\n self.color255[16] = [0, 151, 206]\\r\\n self.color255[17] = [183, 156, 220]\\r\\n self.color255[18] = [183, 214, 211]\\r\\n self.color255[19] = [152, 189, 207]\\r\\n self.color255[20] = [178, 212, 242]\\r\\n self.color255[21] = [68, 172, 100]\\r\\n self.color255[22] = [111, 197, 131]\\r\\n self.color255[23] = [85, 188, 255]\\r\\n self.color255[24] = [0, 145, 30]\\r\\n self.color255[25] = [214, 230, 130]\\r\\n self.color255[26] = [218, 255, 255]\\r\\n self.color255[27] = [170, 250, 250]\\r\\n self.color255[28] = [140, 224, 228]\\r\\n self.color255[29] = [188, 65, 28]\\r\\n self.color255[30] = [216, 191, 216]\\r\\n self.color255[31] = [145, 60, 66]\\r\\n self.color255[32] = [150, 98, 83]\\r\\n self.color255[33] = [250, 250, 225]\\r\\n self.color255[34] = [200, 200, 215]\\r\\n self.color255[35] = [68, 131, 98]\\r\\n self.color255[36] = [83, 146, 164]\\r\\n self.color255[37] = [162, 115, 105]\\r\\n self.color255[38] = [141, 93, 137]\\r\\n self.color255[39] = [182, 166, 110]\\r\\n self.color255[40] = [188, 135, 166]\\r\\n self.color255[41] = [154, 150, 201]\\r\\n self.color255[42] = [177, 140, 190]\\r\\n self.color255[43] = [30, 111, 85]\\r\\n self.color255[44] = [210, 157, 166]\\r\\n self.color255[45] = [48, 129, 126]\\r\\n self.color255[46] = [98, 153, 112]\\r\\n self.color255[47] = [69, 110, 53]\\r\\n self.color255[48] = [166, 113, 137]\\r\\n self.color255[49] = [122, 101, 38]\\r\\n self.color255[50] = [253, 135, 192]\\r\\n self.color255[51] = [145, 92, 109]\\r\\n self.color255[52] = [46, 101, 131]\\r\\n self.color255[53] = [0, 108, 112]\\r\\n self.color255[54] = [127, 150, 88]\\r\\n self.color255[55] = [159, 116, 163]\\r\\n self.color255[56] = [125, 102, 154]\\r\\n self.color255[57] = [106, 174, 155]\\r\\n self.color255[58] = [154, 146, 83]\\r\\n self.color255[59] = [126, 126, 55]\\r\\n self.color255[60] = [201, 160, 133]\\r\\n self.color255[61] = [78, 152, 141]\\r\\n self.color255[62] = [174, 140, 103]\\r\\n self.color255[63] = [139, 126, 177]\\r\\n self.color255[64] = [148, 120, 72]\\r\\n self.color255[65] = [186, 135, 135]\\r\\n self.color255[66] = [99, 106, 24]\\r\\n self.color255[67] = [156, 171, 108]\\r\\n self.color255[68] = [64, 123, 147]\\r\\n self.color255[69] = [138, 95, 74]\\r\\n self.color255[70] = [97, 113, 158]\\r\\n self.color255[71] = [126, 161, 197]\\r\\n self.color255[72] = [194, 195, 164]\\r\\n self.color255[73] = [88, 106, 215]\\r\\n self.color255[74] = [82, 174, 128]\\r\\n self.color255[75] = [57, 157, 110]\\r\\n self.color255[76] = [60, 143, 83]\\r\\n self.color255[77] = [92, 162, 109]\\r\\n self.color255[78] = [255, 244, 209]\\r\\n self.color255[79] = [201, 121, 77]\\r\\n self.color255[80] = [70, 163, 117]\\r\\n self.color255[81] = [188, 91, 95]\\r\\n self.color255[82] = [166, 84, 94]\\r\\n self.color255[83] = [182, 105, 107]\\r\\n self.color255[84] = [229, 147, 118]\\r\\n self.color255[85] = [174, 122, 90]\\r\\n self.color255[86] = [201, 112, 73]\\r\\n self.color255[87] = [194, 142, 0]\\r\\n self.color255[88] = [241, 213, 144]\\r\\n self.color255[89] = [203, 179, 77]\\r\\n self.color255[90] = [229, 204, 109]\\r\\n self.color255[91] = [255, 243, 152]\\r\\n self.color255[92] = [209, 185, 85]\\r\\n self.color255[93] = [248, 223, 131]\\r\\n self.color255[94] = [255, 230, 138]\\r\\n self.color255[95] = [196, 172, 68]\\r\\n self.color255[96] = [255, 255, 167]\\r\\n self.color255[97] = [255, 250, 160]\\r\\n self.color255[98] = [255, 237, 145]\\r\\n self.color255[99] = [242, 217, 123]\\r\\n self.color255[100] = [222, 198, 101]\\r\\n self.color255[101] = [213, 124, 109]\\r\\n self.color255[102] = [184, 105, 108]\\r\\n self.color255[103] = [150, 208, 243]\\r\\n self.color255[104] = [62, 162, 114]\\r\\n self.color255[105] = [242, 206, 142]\\r\\n self.color255[106] = [250, 210, 139]\\r\\n self.color255[107] = [255, 255, 207]\\r\\n self.color255[108] = [182, 228, 255]\\r\\n self.color255[109] = [175, 216, 244]\\r\\n self.color255[110] = [197, 165, 145]\\r\\n self.color255[111] = [172, 138, 115]\\r\\n self.color255[112] = [202, 164, 140]\\r\\n self.color255[113] = [224, 186, 162]\\r\\n self.color255[114] = [255, 245, 217]\\r\\n self.color255[115] = [206, 110, 84]\\r\\n self.color255[116] = [210, 115, 89]\\r\\n self.color255[117] = [203, 108, 81]\\r\\n self.color255[118] = [233, 138, 112]\\r\\n self.color255[119] = [195, 100, 73]\\r\\n self.color255[120] = [181, 85, 57]\\r\\n self.color255[121] = [152, 55, 13]\\r\\n self.color255[122] = [159, 63, 27]\\r\\n self.color255[123] = [166, 70, 38]\\r\\n self.color255[124] = [218, 123, 97]\\r\\n self.color255[125] = [225, 130, 104]\\r\\n self.color255[126] = [224, 97, 76]\\r\\n self.color255[127] = [184, 122, 154]\\r\\n self.color255[128] = [211, 171, 143]\\r\\n self.color255[129] = [47, 150, 103]\\r\\n self.color255[130] = [173, 121, 88]\\r\\n self.color255[131] = [188, 95, 76]\\r\\n self.color255[132] = [255, 239, 172]\\r\\n self.color255[133] = [226, 202, 134]\\r\\n self.color255[134] = [253, 232, 158]\\r\\n self.color255[135] = [244, 217, 154]\\r\\n self.color255[136] = [205, 179, 108]\\r\\n self.color255[137] = [186, 124, 161]\\r\\n self.color255[138] = [255, 255, 220]\\r\\n self.color255[139] = [234, 234, 194]\\r\\n self.color255[140] = [204, 142, 178]\\r\\n self.color255[141] = [180, 119, 153]\\r\\n self.color255[142] = [216, 132, 105]\\r\\n self.color255[143] = [255, 253, 229]\\r\\n self.color255[144] = [205, 167, 142]\\r\\n self.color255[145] = [204, 168, 143]\\r\\n self.color255[146] = [255, 224, 199]\\r\\n self.color255[147] = [139, 150, 98]\\r\\n self.color255[148] = [249, 180, 111]\\r\\n self.color255[149] = [157, 108, 162]\\r\\n self.color255[150] = [203, 136, 116]\\r\\n self.color255[151] = [185, 102, 83]\\r\\n self.color255[152] = [247, 182, 164]\\r\\n self.color255[153] = [222, 154, 132]\\r\\n self.color255[154] = [124, 186, 223]\\r\\n self.color255[155] = [249, 186, 150]\\r\\n self.color255[156] = [244, 170, 147]\\r\\n self.color255[157] = [255, 181, 158]\\r\\n self.color255[158] = [255, 190, 165]\\r\\n self.color255[159] = [227, 153, 130]\\r\\n self.color255[160] = [213, 141, 113]\\r\\n self.color255[161] = [193, 123, 103]\\r\\n self.color255[162] = [216, 146, 127]\\r\\n self.color255[163] = [230, 158, 140]\\r\\n self.color255[164] = [245, 172, 147]\\r\\n self.color255[165] = [241, 172, 151]\\r\\n self.color255[166] = [177, 124, 92]\\r\\n self.color255[167] = [171, 85, 68]\\r\\n self.color255[168] = [217, 198, 131]\\r\\n self.color255[169] = [212, 188, 102]\\r\\n self.color255[170] = [185, 135, 134]\\r\\n self.color255[171] = [198, 175, 125]\\r\\n self.color255[172] = [194, 98, 79]\\r\\n self.color255[173] = [255, 238, 170]\\r\\n self.color255[174] = [206, 111, 93]\\r\\n self.color255[175] = [216, 186, 0]\\r\\n self.color255[176] = [255, 226, 77]\\r\\n self.color255[177] = [255, 243, 106]\\r\\n self.color255[178] = [255, 234, 92]\\r\\n self.color255[179] = [240, 210, 35]\\r\\n self.color255[180] = [224, 194, 0]\\r\\n self.color255[181] = [213, 99, 79]\\r\\n self.color255[182] = [217, 102, 81]\\r\\n self.color255[183] = [0, 147, 202]\\r\\n self.color255[184] = [0, 122, 171]\\r\\n self.color255[185] = [186, 77, 64]\\r\\n self.color255[186] = [240, 255, 30]\\r\\n self.color255[187] = [185, 232, 61]\\r\\n self.color255[188] = [0, 226, 255]\\r\\n self.color255[189] = [251, 159, 255]\\r\\n self.color255[190] = [230, 169, 29]\\r\\n self.color255[191] = [0, 194, 113]\\r\\n self.color255[192] = [104, 160, 249]\\r\\n self.color255[193] = [221, 108, 158]\\r\\n self.color255[194] = [137, 142, 0]\\r\\n self.color255[195] = [230, 70, 0]\\r\\n self.color255[196] = [0, 147, 0]\\r\\n self.color255[197] = [0, 147, 248]\\r\\n self.color255[198] = [231, 0, 206]\\r\\n self.color255[199] = [129, 78, 0]\\r\\n self.color255[200] = [0, 116, 0]\\r\\n self.color255[201] = [0, 0, 255]\\r\\n self.color255[202] = [157, 0, 0]\\r\\n self.color255[203] = [100, 100, 130]\\r\\n self.color255[204] = [205, 205, 100]\\r\\n self.color255[205] = [255, 255, 0]\\r\\n\\r\\n return self.color255\",\n \"def cmap(self, background_color='#000000'):\\n return get_cmap(self.img.data.max() + 1,\\n background_color=background_color)\",\n \"def encode_labelmap(colour_img, colourlabelmap):\\n colour_img = colour_img.astype(int)\\n labels = np.zeros((colour_img.shape[0], colour_img.shape[1]), dtype=np.int16)\\n for label_id, colour in enumerate(colourlabelmap):\\n labels[np.where(np.all(colour == colour_img, axis=-1))] = label_id\\n\\n return labels\",\n \"def __value2color(self, v):\\n if np.isscalar(v):\\n r = self.cmap(self.norm(np.asarray([v])))\\n else:\\n r = self.cmap(self.norm(v))\\n return r.flatten()\",\n \"def map_binary_values(x) -> int:\\n return _bm.get(x, -1)\",\n \"def randcolor():\\n return (randint(0,255), randint(0,255), randint(0,255))\",\n \"def __init__(self, bits=8):\\n\\n self.map = {}\\n self.bits = bits\\n for r, g, b in itertools.product(range(2 ** bits), repeat=3):\\n self.map[(r << 2 * bits) + (g << bits) + b] = rgb2lab(r << (8 - bits), g << (8 - bits), b << (8 - bits))\",\n \"def create_pascal_label_colormap():\\n colormap = np.zeros((256, 3), dtype=int)\\n ind = np.arange(256, dtype=int)\\n\\n for shift in reversed(range(8)):\\n for channel in range(3):\\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\\n ind >>= 3\\n\\n return colormap\",\n \"def create_pascal_label_colormap():\\n colormap = np.zeros((256, 3), dtype=int)\\n ind = np.arange(256, dtype=int)\\n\\n for shift in reversed(range(8)):\\n for channel in range(3):\\n colormap[:, channel] |= ((ind >> channel) & 1) << shift\\n ind >>= 3\\n\\n return colormap\",\n \"def compute_color_for_labels(label):\\n\\tcolor = [int((p * (label**2 - label + 1)) % 255) for p in palette]\\n\\treturn tuple(color)\",\n \"def getColorFlag(color):\\n if color == 0: # MONO\\n return 0\\n elif color == 1: # BAYER\\n return -1\\n elif color == 2: # AS IS RBG\\n return 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7930761","0.7340916","0.6859213","0.6619156","0.6548862","0.6361467","0.62869173","0.61980194","0.6166142","0.60413206","0.60389495","0.5965779","0.5909593","0.58895975","0.5883732","0.586125","0.5825624","0.58123803","0.5805797","0.58012986","0.57908845","0.57875663","0.57835186","0.5756781","0.57410437","0.5699737","0.56726754","0.5662316","0.5654792","0.56488675","0.5642108","0.5622926","0.56210524","0.5616603","0.56113887","0.5595577","0.55816144","0.55816144","0.55805695","0.5567403","0.5565475","0.556045","0.5559893","0.55522597","0.55486286","0.5543788","0.55190873","0.5519037","0.5518919","0.5518919","0.5512715","0.5504799","0.5494699","0.5494236","0.54927725","0.54913086","0.54822093","0.54816836","0.5464641","0.54552656","0.54463476","0.54437035","0.54357713","0.54278785","0.5427473","0.5422086","0.54208887","0.541911","0.5406038","0.5404903","0.54048514","0.54032147","0.53918105","0.5388228","0.5388228","0.5388228","0.5388228","0.5383827","0.5382057","0.53800243","0.53794414","0.53794414","0.5372558","0.5369048","0.536599","0.5364458","0.5357182","0.5356684","0.53460914","0.53441215","0.5332345","0.5331514","0.53281724","0.53239566","0.53239566","0.5323187","0.53229314"],"string":"[\n \"0.7930761\",\n \"0.7340916\",\n \"0.6859213\",\n \"0.6619156\",\n \"0.6548862\",\n \"0.6361467\",\n \"0.62869173\",\n \"0.61980194\",\n \"0.6166142\",\n \"0.60413206\",\n \"0.60389495\",\n \"0.5965779\",\n \"0.5909593\",\n \"0.58895975\",\n \"0.5883732\",\n \"0.586125\",\n \"0.5825624\",\n \"0.58123803\",\n \"0.5805797\",\n \"0.58012986\",\n \"0.57908845\",\n \"0.57875663\",\n \"0.57835186\",\n \"0.5756781\",\n \"0.57410437\",\n \"0.5699737\",\n \"0.56726754\",\n \"0.5662316\",\n \"0.5654792\",\n \"0.56488675\",\n \"0.5642108\",\n \"0.5622926\",\n \"0.56210524\",\n \"0.5616603\",\n \"0.56113887\",\n \"0.5595577\",\n \"0.55816144\",\n \"0.55816144\",\n \"0.55805695\",\n \"0.5567403\",\n \"0.5565475\",\n \"0.556045\",\n \"0.5559893\",\n \"0.55522597\",\n \"0.55486286\",\n \"0.5543788\",\n \"0.55190873\",\n \"0.5519037\",\n \"0.5518919\",\n \"0.5518919\",\n \"0.5512715\",\n \"0.5504799\",\n \"0.5494699\",\n \"0.5494236\",\n \"0.54927725\",\n \"0.54913086\",\n \"0.54822093\",\n \"0.54816836\",\n \"0.5464641\",\n \"0.54552656\",\n \"0.54463476\",\n \"0.54437035\",\n \"0.54357713\",\n \"0.54278785\",\n \"0.5427473\",\n \"0.5422086\",\n \"0.54208887\",\n \"0.541911\",\n \"0.5406038\",\n \"0.5404903\",\n \"0.54048514\",\n \"0.54032147\",\n \"0.53918105\",\n \"0.5388228\",\n \"0.5388228\",\n \"0.5388228\",\n \"0.5388228\",\n \"0.5383827\",\n \"0.5382057\",\n \"0.53800243\",\n \"0.53794414\",\n \"0.53794414\",\n \"0.5372558\",\n \"0.5369048\",\n \"0.536599\",\n \"0.5364458\",\n \"0.5357182\",\n \"0.5356684\",\n \"0.53460914\",\n \"0.53441215\",\n \"0.5332345\",\n \"0.5331514\",\n \"0.53281724\",\n \"0.53239566\",\n \"0.53239566\",\n \"0.5323187\",\n \"0.53229314\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7823721"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":93698,"cells":{"query":{"kind":"string","value":"Generate test image with random pixels and save as an image file."},"document":{"kind":"string","value":"def test_image(filename, x_size=350, y_size=350):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (random.randint(0, 255), # Red channel\n random.randint(0, 255), # Green channel\n random.randint(0, 255)) # Blue channel\n\n im.save(filename)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_image(filename, x_size=350, y_size=350):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n pixels[i, j] = (random.randint(0, 255), # Red channel\n random.randint(0, 255), # Green channel\n random.randint(0, 255)) # Blue channel\n im.save(filename)\n return 'saved'","def test_image(filename, x_size=350, y_size=350):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap(i, 0, x_size, -1, 1)\n y = remap(j, 0, y_size, -1, 1)\n pixels[i, j] = (random.randint(0, 255), # Red channel\n random.randint(0, 255), # Green channel\n random.randint(0, 255)) # Blue channel\n\n im.save(filename)","def test_image(filename, x_size=def_x_size, y_size=def_y_size):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (random.randint(0, 255), # Red channel\n random.randint(0, 255), # Green channel\n random.randint(0, 255)) # Blue channel\n im.save(filename)","def genrandimg(args) -> None:\n\n size = (int(args.x), int(args.y))\n fp = Image.new(\"RGB\", size)\n data = []\n\n if not args.c: # If color\n for i in range(size[0]*size[1]):\n r = random.choice([0x00, 0xff])\n data.append((r, r, r)) # Each RGB value is the same random value\n else: # Else black-and-white\n for i in range(size[0]*size[1]):\n r = [random.choice(range(0, 256)) for _ in range(0, 3)]\n r = (r[0], r[1], r[2]) # Choose 3 random numbers for different RGB values\n data.append(r)\n\n fp.putdata(data)\n print(\"Saving to %s...\" % args.o)\n fp.save(args.o)\n fp.close()","def new_test_image():\n warnings.warn(DeprecationWarning(\n \"new_test_image() is deprecated in favour of the get_sample_image() \"\n \"context manager.\"), stacklevel=2)\n image_name = 'test-{}.png'.format(uuid.uuid4())\n image = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))\n ImageDraw.Draw(image)\n byte_io = BytesIO()\n image.save(byte_io, 'png')\n byte_io.seek(0)\n return image_name, ContentFile(byte_io.read(), image_name)","def generate_image(filename, x_size=350, y_size=350):\n global timeflag\n timeflag = 0\n\n # Functions for red, green, and blue channels - where the magic happens!\n red_function = build_random_function(13, 15)\n green_function = build_random_function(13, 15)\n blue_function = build_random_function(13,15)\n print \"red_function:\\t\" + str(red_function)+\"\\n\"\n print \"green_function:\\t\" + str(green_function)+\"\\n\"\n print \"blue_function:\\t\" + str(blue_function)+\"\\n\"\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n\n im.save(filename)","def create_image(path, pxcount):\n img = Image.open(path, 'r').convert('L')\n pixels = img.load()\n for i in range(pxcount):\n x = randint(0, img.size[0]-1)\n y = randint(0, img.size[0]-1)\n if pixels[x, y] == 0:\n pixels[x, y] = 255\n else:\n pixels[x, y] = 0\n return img","def testImage():\n width = 200\n height = 200\n image = BitMap( width, height )\n \n # create a loop in order to draw some pixels\n \n for col in range(width):\n if col % 10 == 0: print 'col is', col\n for row in range(height):\n if col % 10 == 0 or row % 10 == 0:\n image.plotPoint( col, row ) \n \n # we have now looped through every image pixel\n # next, we write it out to a file\n \n image.saveFile( \"test.bmp\" )\n #changing the col and row number determines how big the grid is for the picture or how zoomed in it is. Changing the and to or just makes the grid go from dotted grid to lines.","def generate_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(6, 10)\n g_lb = random.randint(6, 10)\n b_lb = random.randint(6, 10)\n red_function = build_random_function(r_lb, r_lb+1)\n green_function = build_random_function(g_lb, g_lb+1)\n blue_function = build_random_function(b_lb, b_lb+1)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n im.save(filename+'.png')\n return 'saved'","def create_random_data(output_path: str, num_images: int = 5) -> None:\n train_path = os.path.join(output_path, \"train\")\n class1_train_path = os.path.join(train_path, \"class1\")\n class2_train_path = os.path.join(train_path, \"class2\")\n\n val_path = os.path.join(output_path, \"val\")\n class1_val_path = os.path.join(val_path, \"class1\")\n class2_val_path = os.path.join(val_path, \"class2\")\n\n test_path = os.path.join(output_path, \"test\")\n class1_test_path = os.path.join(test_path, \"class1\")\n class2_test_path = os.path.join(test_path, \"class2\")\n\n paths = [\n class1_train_path,\n class1_val_path,\n class1_test_path,\n class2_train_path,\n class2_val_path,\n class2_test_path,\n ]\n\n for path in paths:\n try:\n os.makedirs(path)\n except FileExistsError:\n pass\n\n for i in range(num_images):\n pixels = numpy.random.rand(64, 64, 3) * 255\n im = Image.fromarray(pixels.astype(\"uint8\")).convert(\"RGB\")\n im.save(os.path.join(path, f\"rand_image_{i}.jpeg\"))\n\n process_images(output_path)","def main():\n\n os.system(\"rm -rf images; mkdir images\")\n\n if (len(sys.argv) > 1):\n N = int(sys.argv[1])\n else:\n N = 10\n\n x_test = np.load(\"../../../../data/mnist/mnist_test_images.npy\")\n\n for i in range(N):\n r,c = random.randint(6,12), random.randint(6,12)\n g = np.zeros(r*c)\n for j in range(r*c):\n if (random.random() < 0.15):\n g[j] = 1\n g = g.reshape((r,c))\n g[:,0] = g[0,:] = g[:,-1] = g[-1,:] = 0\n\n img = np.zeros((28*r,28*c), dtype=\"uint8\")\n for x in range(r):\n for y in range(c):\n if (g[x,y] == 1):\n n = random.randint(0, x_test.shape[0])\n im = x_test[n]\n img[28*x:(28*x+28), 28*y:(28*y+28)] = im\n \n Image.fromarray(img).save(\"images/image_%04d.png\" % i)","def test_save_jpg():\n img = Image.new('RGB', (10, 20))\n\n parameters = {'path': 'green-dot.jpg', 'data': [img]}\n\n assert images.save(parameters)","def test_save_png():\n img = Image.new('RGB', (10, 20))\n\n parameters = {'path': 'green-dot.png', 'data': [img]}\n\n assert images.save(parameters)","def generate_image(noise_list, save_path):\n check_points_path = os.path.join(save_path, 'check_points')\n output_image_path = os.path.join(save_path, 'images')\n components.create_folder(output_image_path, False)\n latest_checkpoint = tf.train.latest_checkpoint(check_points_path)\n assert latest_checkpoint is not None, \"no check points found\"\n saver = tf.train.import_meta_graph(latest_checkpoint + '.meta')\n with tf.Session() as sess:\n saver.restore(sess, latest_checkpoint)\n iterations = sess.run('saved_iterations:0')\n for i in range(len(noise_list)):\n generated_images = sess.run('generator/output_layer/tanh/during_inference:0',\n feed_dict={\"noise_for_inference:0\": noise_list[i]})\n Gan.__save_images(output_image_path, generated_images, int(np.sqrt(generated_images.shape[0])), iterations, i)","def test_write_img(img_: Tensor, ext: str) -> None:\n with NamedTemporaryFile(\"w\") as f:\n path = f\"{f.name}{ext}\"\n write_img(img_, path)\n img = read_image(path)\n torch.testing.assert_allclose(img, img_)","def generate_image_file(color):\n img = generate_image(color)\n img.save(IMAGE_FILE)\n return IMAGE_FILE","def generate_images(generator_model, output_dir, epoch):\n test_image_stack = generator_model.predict(np.random.normal(size=(10, 100)))\n test_image_stack = (test_image_stack * 255)\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\n tiled_output = tile_images(test_image_stack)\n tiled_output = Image.fromarray(tiled_output)\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\n tiled_output.save(outfile)","def generate_art(filename, x_size=1920, y_size=1080):\n # Functions for red, green, and blue channels - where the magic happens!\n red_function = build_random_function(7,8)\n green_function = build_random_function(4,6)\n blue_function = build_random_function(3,5)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n\n im.save(filename)","def save_image(start, stop, imgcount, label):\n text = \"\"\n imgfile = select_file(label)\n for p in range(imgcount):\n pxcnt = randint(start, stop)\n imgcurrent = create_image(imgfile, pxcnt)\n filename = \"img_train_\" + str(label) + \"_\" + str(p) + \"_\" + str(pxcnt) + \".png\"\n text += \"ctq/dataset/train/\" + filename + \" \" + str(label) + \"\\n\"\n imgcurrent.save(filename)\n text_file = open(imgfile + \"_train_label.txt\", \"w\")\n text_file.write(text)\n text_file.close()","def test_save_tif():\n img = Image.new('RGB', (10, 20))\n\n parameters = {'path': 'green-dot.tif', 'data': [img]}\n\n assert images.save(parameters)","def generate_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n \n red_function = build_random_function(7,15)\n green_function = build_random_function(7,15)\n blue_function = build_random_function(7,15)\n \n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n\n im.save(filename)","def generate_image(self):\n pass","def test(train_out_dir):\n above = os.path.join(train_out_dir, '..')\n os.chdir(above)\n if not os.path.exists(\"test\"):\n os.mkdir(\"test\")\n\n for sdir in os.listdir(train_out_dir):\n cur_dir = os.path.join(train_out_dir, sdir)\n list_curr_dir = os.listdir(cur_dir)\n random.seed()\n rand_num = random.randint(0, len(list_curr_dir) - 1)\n rand_img = list_curr_dir[rand_num]\n rand_img_path = os.path.join(cur_dir, rand_img)\n dst_path = os.path.join(\"test\", sdir)\n if not os.path.exists(dst_path):\n os.mkdir(dst_path)\n\n shutil.move(rand_img_path, os.path.join(dst_path, os.path.basename(rand_img_path)))","def mock_raw_image(x_dim=1024, y_dim=1024, num_channels=3,\n output_path=None, write_image=True):\n\n rand_shape = (x_dim, y_dim, num_channels)\n\n if num_channels != 3:\n raise NotImplementedError(\"mock_raw_image for channels != 3 not yet \"\n \"implemented.\")\n\n img = np.random.random(rand_shape)\n img = np.uint8(img*255)\n\n if write_image:\n image_obj = allen_brain.PIL_Image()\n pil_img = image_obj.fromarray(img, mode=\"RGB\")\n with tf.gfile.Open(output_path, \"w\") as f:\n pil_img.save(f, \"jpeg\")\n\n return img","def test_image(self):\r\n self.testdata = open(TESTDATA_FILENAME).read()","def get_rand_img():\n import urllib\n import os\n import glob\n\n pics = glob.glob('/home/cody_techngs/PycharmProjects/ProjTest/ActiveAMT/ActiveAMT_FLASK/static/images/HITs/rand*')\n nums = []\n\n for pic in pics:\n nums.append(int(pic.split('rand_img')[1].split('.')[0]))\n\n unique_num = False\n new_rand_num = 0\n\n while not unique_num:\n new_rand_num = random.randrange(1, 2000)\n if new_rand_num not in nums:\n unique_num = True\n\n img_name = 'rand_img{}.jpg'.format(new_rand_num)\n dl_location = os.getcwd() + '/ActiveAMT/ActiveAMT_FLASK/static/images/HITs/' + img_name\n url = 'https://unsplash.it/400/300/?random'\n urllib.urlretrieve(url, dl_location)\n\n return 'static/images/HITs/{}'.format(img_name)","def sample_image(n_row, batches_done):\n # Sample noise\n z = Variable(Tensor(np.random.normal(0, 1, (n_row ** 2, opt.latent_dim))))\n gen_imgs = decoder(z)\n save_image(\n gen_imgs.data, \"images/%d.png\" % batches_done, nrow=n_row, normalize=True\n )","def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape, samples_limit=None):\n\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\n\n if samples_limit:\n image_paths = image_paths[0:samples_limit]\n\n for image_file in tqdm(image_paths, desc='Processing: ', unit='images', total=len(image_paths)):\n yield process_image_file(image_file, sess, logits, keep_prob, image_pl, image_shape)","def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, sample_dir='samples'):\n\n os.makedirs(sample_dir, exist_ok=True)\n\n fake_X = G_YtoX(fixed_Y)\n fake_Y = G_XtoY(fixed_X)\n\n X, fake_X = tensor_to_image(fixed_X), tensor_to_image(fake_X)\n Y, fake_Y = tensor_to_image(fixed_Y), tensor_to_image(fake_Y)\n \n grid_xy = merge_images(X, fake_Y)\n path = os.path.join(sample_dir, 'sample-{:05d}-X-Y.png'.format(iteration))\n imageio.imwrite(path, grid_xy)\n \n grid_yx = merge_images(Y, fake_X)\n path = os.path.join(sample_dir, 'sample-{:05d}-Y-X.png'.format(iteration))\n imageio.imwrite(path, grid_yx)","def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape):\n for image_file in glob(os.path.join(data_folder, 'image_2', '*.png')):\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\n\n im_softmax = sess.run(\n [tf.nn.softmax(logits)],\n {keep_prob: 1.0, image_pl: [image]})\n im_softmax_road = im_softmax[0][:, 1].reshape(image_shape[0], image_shape[1])\n segmentation_road = (im_softmax_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\n \n im_softmax_other_road = im_softmax[0][:, 2].reshape(image_shape[0], image_shape[1])\n segmentation_other_road = (im_softmax_other_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\n \n # green road\n mask_road = np.dot(segmentation_road, np.array([[0, 255, 0, 127]]))\n mask_road = scipy.misc.toimage(mask_road, mode=\"RGBA\")\n \n # blue other_road\n mask_other_road = np.dot(segmentation_other_road, np.array([[0, 0, 255, 127]]))\n mask_other_road = scipy.misc.toimage(mask_other_road, mode=\"RGBA\")\n \n street_im = scipy.misc.toimage(image)\n street_im.paste(mask_road, box=None, mask=mask_road)\n street_im.paste(mask_other_road, box=None, mask=mask_other_road)\n\n yield os.path.basename(image_file), np.array(street_im)","def gen_test_output(sess, logits, keep_prob, image_pl, screen, image_shape):\n image = scipy.misc.imresize(screen, image_shape)\n im_softmax = sess.run([tf.nn.softmax(logits)],{keep_prob: 1.0, image_pl: [image]})\n im_softmax = im_softmax[0][:, 1].reshape(image_shape[0], image_shape[1])\n segmentation = (im_softmax > 0.5).reshape(image_shape[0], image_shape[1], 1)\n mask = np.dot(segmentation, np.array([[0, 255, 0, 127]]))\n mask = scipy.misc.toimage(mask, mode=\"RGBA\")\n street_im = scipy.misc.toimage(image)\n street_im.paste(mask, box=None, mask=mask)\n street_im = np.array(street_im)\n\n return street_im","def test_write_rgb(self):\n with tempfile.TemporaryDirectory() as out_dir:\n image_name = os.path.join(out_dir, \"test.png\")\n img = np.random.rand(2, 3, 3)\n img_save_val = (255 * img).astype(np.uint8)\n writer_obj = PILWriter(output_dtype=np.uint8)\n writer_obj.set_data_array(img, channel_dim=-1)\n writer_obj.write(image_name)\n out = np.asarray(Image.open(image_name))\n out = np.moveaxis(out, 0, 1)\n np.testing.assert_allclose(out, img_save_val)","def generate_and_save_images(model, seed, output_path, title):\n\n predictions = model(tf.Variable(seed, trainable=False))\n\n fig = plt.figure(figsize=(4,4))\n\n for i in range(predictions.shape[0]):\n plt.subplot(4, 4, i+1)\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\n plt.axis('off')\n if not os.path.exists(output_path):\n os.mkdir(output_path)\n\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\n plt.close()","def __seed_output_image(self, src_image: Image, out_image: Image) -> None:\n src_pixel_array = src_image[:, :].reshape((src_image.area, 3))\n src_index_array = np.random.choice(np.arange(src_image.area), out_image.area)\n out_image[:, :] = np.take(src_pixel_array, src_index_array, axis=0).reshape(out_image.shape)","def test_read_img(\n img_: Tensor, ext: str, write_image: Callable[..., Any]\n) -> None:\n with NamedTemporaryFile(\"w\") as f:\n path = f.name + ext\n write_image(img_, path)\n img = read_img(path)\n torch.testing.assert_allclose(img, img_)","def test_create_image(self):\n pass","def gen_test_output(sess, logits, image_folder, image_pl, data_folder,\n learning_phase, image_shape, nw_shape):\n image_paths = glob(os.path.join(data_folder, image_folder, '*.png'))\n for image_file in image_paths[:5]:\n\n in_image = scipy.misc.imread(image_file, mode='RGB')\n image = scipy.misc.imresize(in_image, image_shape)\n\n street_im = get_seg_img(sess, logits, image_pl, image, image_shape,\n nw_shape, learning_phase)\n\n street_im = scipy.misc.imresize(street_im, in_image.shape)\n yield os.path.basename(image_file), np.array(street_im)","def imageSaveOutput(image,name,number):\n FileName = name +\" \"+number\n mpimg.imsave(\"test_images_output\"+'//'+FileName,image)\n return 0;","def sample_image(generator, n_row, batches_done):\r\n # Sample noise\r\n z = Variable(float_tensor(np.random.normal(0, 1, (n_row ** 2, args.latent_dim))))\r\n labels = np.array([num for _ in range(n_row) for num in range(n_row)])\r\n labels = Variable(long_tensor(labels))\r\n gen_imgs = generator(z, labels)\r\n save_image(gen_imgs.data, \"images/%d.png\" % batches_done, nrow=n_row, normalize=True)","def test_save_image(self):\n\n from m3_save_images.m3_save_images import save_images\n folder_destination_name = \"unittest-sorted-images\"\n path_source = \"../img\"\n image_name = [\"00ff00.png\", \"aqua.png\", \"black.jpg\", \"yellow.png\", \"red2.jpg\", \"green.jpg\"]\n image_color = [\"Lime\", \"Aqua\", \"Black\", \"Yellow\", \"Red\", \"Green\"]\n # new empty folder is needed for testing save_image() function\n if os.path.isdir(folder_destination_name):\n shutil.rmtree(folder_destination_name)\n os.mkdir(folder_destination_name)\n # creating folders\n for i in range(0, 4):\n save_images(folder_destination_name, path_source, image_name[i], image_color[i])\n self.assertEqual(''.join(os.listdir(os.path.join(folder_destination_name, image_color[i]))), image_name[i])\n save_images(folder_destination_name, path_source, image_name[i], image_color[5])\n self.assertNotEqual(''.join(os.listdir(os.path.join(folder_destination_name, image_color[i]))), image_name[5])","async def get_image(self):\n\n # generating\n fixed_latent = torch.randn(1, 512, 1, 1, device=self.device)\n\n with torch.no_grad():\n # passing through\n fake_images = self.model(fixed_latent)\n # saving\n save_image(fake_images, f'models/FaceGAN_dir/faces/fake.jpg')","def save_test_images(images):\n for description, img in images.items():\n save_to_image(img, description)\n save_to_netcdf(img, description)","def save_image(image, output_folder, output_name):\n\n\tfolder_path = compute_path(output_folder, 'dataset')\n\tos.makedirs(folder_path, exist_ok=True)\n\n\tfile_path = os.path.join(folder_path, output_name + '.png')\n\timage.save(file_path)","def test_save_fail():\n img = Image.new('RGB', (10, 20))\n\n parameters = {'path': 'foo.bar', 'data': [img]}\n\n images.save(parameters)","def test(file_path: str):\n # Build the generator network\n generator = build_generator()\n\n # Load model weights\n generator.load_weights(\"models/generator.h5\")\n\n # Make a low-res counterpart to predict upon\n image = imread(file_path, mode=\"RGB\")\n image = image.astype(np.float32)\n low_resolution_image = [imresize(image, low_resolution_shape)]\n\n low_resolution_image = np.array(low_resolution_image) / 127.5 - 1.0\n\n # Generate high-resolution images from low-resolution images\n generated_image = generator.predict_on_batch(low_resolution_image)\n\n # Make a common figure\n fig = plt.figure(figsize=(16, 9))\n\n # Add the low resolution image on the left side\n ax = fig.add_subplot(1, 2, 1)\n ax.imshow(low_resolution_image[0], interpolation=\"nearest\")\n ax.axis(\"off\")\n ax.set_title(\"Low-resolution\")\n\n # Add generated image to figure on the right side\n ax = fig.add_subplot(1, 2, 2)\n ax.imshow(generated_image[0], interpolation=\"nearest\")\n ax.axis(\"off\")\n ax.set_title(\"Generated\")\n\n # Save the figure\n plt.savefig(\"{0}{1}\".format(TEST_IMAGES_RESULT, file_path.split(\"/\")[-1]))","def new_image(x, y, out, data):\n img = Image.new('RGB', (x, y))\n img.putdata(data)\n img.save(out)","def create_artificial_image(self):\n background = self.BGI.create_background_image()\n star_PSF = self.PSF.create_star_PSF()\n header = self.HDR.create_header()\n\n fits.writeto(self.image_dir + self.image_name + '.fits',\n background + star_PSF, overwrite=True, header=header)","def test_save_images(self):\n save_file(self.quart.save_images, to_single_file=False)","def generate_rand_image(image, groundtruth, noise=True, flip=True):\n # Get the size of the image\n x_size, y_size = image.size\n\n def rotate_augmentation():\n \"\"\"Generate a function to perform a random rotation of an image\n using mirroring for padding\"\"\"\n rand_rotate = np.random.randint(180)\n return lambda image: rotate_with_extension(image, rand_rotate)\n\n def shift_augmentation():\n \"\"\"Generates a function to perform a random shift of the image using mirroring\n for padding\"\"\"\n shift = np.random.randint(-200, 201, size=2)\n return lambda image: shift_with_extension(image, shift)\n\n def zoom_augmentation():\n \"\"\"Generates a function that performs a random zoom on the image\"\"\"\n # Get the width and the height of the zoomed version\n x_len, y_len = np.random.randint(250, 350, size=2)\n # Get left upper ,right and lower bound of the pixels in the original image\n left = np.random.randint(x_size-x_len)\n upper = np.random.randint(y_size-y_len)\n right, lower = left + x_len, upper+y_len\n # Crops the box and resizes it to the original image size\n box = (left, upper, right, lower)\n return lambda image: image.transform(image.size, Image.EXTENT, box)\n\n def flip_augmentation():\n \"\"\"Generates a function to flip the image\"\"\"\n return lambda image: ImageOps.flip(image)\n\n def mirror_augmentation():\n \"\"\"Generates a function to mirror an image\"\"\"\n return lambda image: ImageOps.mirror(image)\n\n # All possible augmentations\n augmentations = [rotate_augmentation(), shift_augmentation(), zoom_augmentation(),\n flip_augmentation(), mirror_augmentation()]\n\n # Loop through all augmentations and apply each one with a probability of 0.5\n for augmentation in augmentations:\n if np.random.randint(2) == 1:\n image = augmentation(image)\n groundtruth = augmentation(groundtruth)\n\n # Add salt or pepper noise each one with a probability of 0.33\n if noise:\n noises = [\"s&p\", \"gauss\"]\n num_noises = len(noises)\n # Choose noise to apply\n noise_rand = np.random.randint(num_noises + 1)\n # apply the noise only to the image and not the groundtruth\n if noise_rand < num_noises:\n image = add_noise(image, type=noises[noise_rand])\n\n return (image, groundtruth)","def paint_a_picture():\n # Make a training set (many random i,j coord and an x by y box around that coord to start with)\n # Throw it into the net\n # Test how it does for some random coordinate inputs\n pass","def gen_simple_test():\n count = 1\n mdict = {\n 'operating_frequency': 3e8,\n 'sample_rate': 8e3,\n 'signal': [1] * 5,\n 'origin_pos': [1000, 0, 0],\n 'dest_pos': [300, 200, 50],\n 'origin_vel': [0] * 3,\n 'dest_vel': [0] * 3,\n }\n io.savemat('{}{}_input'.format(tests_path, count), mdict)","def imwrite(image, path):\n\n if image.ndim == 3 and image.shape[2] == 1: # for gray image\n image = np.array(image, copy=True)\n image.shape = image.shape[0:2]\n\n imgarray=((image+1.0)*127.5).astype(np.uint8)\n img=Image.fromarray(imgarray)\n img.save(path)","def test_generator(self, test_path):\n\n img_list = os.scandir(test_path)\n for img_entry in img_list:\n\n img = cv2.imread(img_entry.path, COLOR_TO_OPENCV[self.color_mode])\n if img.shape[-1] == 3:\n orig_shape = img.shape[-2::-1]\n else:\n orig_shape = img.shape[::-1]\n\n\n img = cv2.resize(img, tuple(self.target_size))\n img = img / 255\n if self.color_mode == \"grayscale\":\n img = np.reshape(img, img.shape + (1,))\n img = np.reshape(img, (1,) + img.shape)\n yield img, img_entry, orig_shape","def random_image(self, height, width):\n random_image_properties = {}\n # flip a coin to determine whether image should be synthetic or real\n if random.random() < self.prob_real:\n random_image_properties['real'] = True\n # select a random row from the list of filenames\n # random_row = self.df_real_images.sample(n=1)\n # print(random_row)\n # filename, x0, y0, x1, y1, x2, y2, x3, y3 = random_row\n random_index = random.choice(list(range(len(self.df_real_images))))\n filename = self.df_real_images['filename'].values[random_index]\n print(filename)\n x0 = self.df_real_images['x0'].values[random_index]\n y0 = self.df_real_images['y0'].values[random_index]\n x1 = self.df_real_images['x1'].values[random_index]\n y1 = self.df_real_images['y1'].values[random_index]\n x2 = self.df_real_images['x2'].values[random_index]\n y2 = self.df_real_images['y2'].values[random_index]\n x3 = self.df_real_images['x3'].values[random_index]\n y3 = self.df_real_images['y3'].values[random_index]\n random_image_properties['real_image_path'] = filename\n cornerpoints = np.array([[x0,y0],[x1,y1],[x2,y2],[x3,y3]], dtype=np.float32)\n\n abs_impath = os.path.join(self.real_image_dirpath, filename)\n im = cv2.imread(abs_impath, 1)\n print('Loaded image from {}'.format(abs_impath))\n h,w,c = im.shape\n sfx = float(width)/w\n sfy = float(height)/h\n scale_matrix = np.array([[sfx,0,0],\n [0,sfy,0],\n [0,0,1]], dtype=np.float32)\n\n # mask = np.zeros((h,w))\n # mask = cv2.fillPoly(mask, np.int32([cornerpoints]), 1)\n # utils.showims([im, mask], ['im', 'mask'])\n\n # im_shrunk = cv2.resize(im, (width, height))\n # mask_shrunk=np.zeros((height, width))\n\n cornerpoints_shrunk = coordinate_geometry.transform_cornerpoints_2D(scale_matrix, cornerpoints)\n cornerpoints = cornerpoints_shrunk\n\n # mask_shrunk = cv2.fillPoly(mask_shrunk, np.int32([cornerpoints_shrunk]), 1)\n # utils.showims([im_shrunk, mask_shrunk], ['im_shrunk', 'mask_shrunk'])\n\n # cornerpoints = coordinate_geometry.transform_cornerpoints_2D(scale_matrix, cornerpoints)\n random_image_properties['cornerpoints'] = np.int32(cornerpoints)\n\n\n # and set unused variables to None\n random_image_properties['card_template_path'] = None\n random_image_properties['background_image_path'] = None\n else:\n random_image_properties['real'] = False\n random_image_properties['card_template_path'] = random.choice(self.card_template_filenames)\n random_image_properties['background_image_path'] = random.choice(self.background_image_filenames)\n random_image_properties['cornerpoints'] = self.random_cornerpoints(height, width)\n\n # and set unused variables to NoneX\n random_image_properties['real_image_path'] = None\n\n return random_image_properties","def random_image(file_name=None, show=False, debug=False, seed=None):\n if seed:\n np.random.seed(seed)\n\n config = dict(\n # color, grayscale or black and white and their probabilities\n # for now V2 is only color\n s_colorset=[\"color\", \"gs\", \"bw\"],\n p_colorset=[1, 0, 0],\n\n # use alpha [False, True]\n p_use_alpha=[0.7, 0.3],\n\n s_quantity=[1, 2, 3, 4],\n p_quantity=[0.55, 0.30, 0.10, 0.05],\n\n # size of the canvas and the probability of each one\n s_size=[512, 1024, 2048],\n p_size=[0.3, 0.6, 0.1],\n\n s_aspect=[\"1:1\", \"4:3\", \"16:9\"],\n p_aspect=[0.3, 0.5, 0.2],\n\n # mirror a box\n s_mirror_box=[None, \"h\", \"v\"],\n p_mirror_box=[0.95, 0.025, 0.025],\n\n # mirroring in half, negative means lowerX or rightY\n s_mirroring=[None, \"h\", \"v\", \"-h\", \"-v\"],\n p_mirroring1=[0.90, 0.025, 0.025, 0.025, 0.025],\n p_mirroring2=[0.90, 0.025, 0.025, 0.025, 0.025]\n )\n\n # chose colorset, quantity of shapes and size from config\n colorset = choice(config[\"s_colorset\"], p=config[\"p_colorset\"])\n # v1.2\n use_alpha = choice([False, True], p=config[\"p_use_alpha\"])\n colorset_info = {\"colorset\": colorset, \"use_alpha\": use_alpha}\n quantity = choice(config[\"s_quantity\"], p=config[\"p_quantity\"])\n size = choice(config[\"s_size\"], p=config[\"p_size\"])\n\n # v1.2\n aspect = choice(config[\"s_aspect\"], p=config[\"p_aspect\"])\n aspect = int(aspect.split(\":\")[0]), int(aspect.split(\":\")[1])\n mirroring_axis1 = choice(config[\"s_mirroring\"], p=config[\"p_mirroring1\"])\n mirroring_axis2 = choice(config[\"s_mirroring\"], p=config[\"p_mirroring2\"])\n mirror_box_axis = choice(config[\"s_mirror_box\"], p=config[\"p_mirror_box\"])\n\n if debug:\n print(\"Selected values: \")\n print(\"colorset = %s\" % colorset_info['colorset'])\n print(\"use alpha = %s\" % colorset_info['use_alpha'])\n print(\"quantity of shapes = %d\" % quantity)\n print(\"size = %d\" % size)\n print(\"aspect ratio = %d:%d\" % (aspect[0], aspect[1]))\n print(\"mirroring box axis = %r\" % mirror_box_axis)\n print(\"mirroring axis 1 = %r\" % mirroring_axis1)\n print(\"mirroring axis 2 = %r\" % mirroring_axis2)\n\n factory = ShapeFactory(size)\n canvas = Image.new(\n 'RGB',\n (size, int((size/aspect[0])*aspect[1])),\n color=factory.get_color_from_set(colorset_info)\n )\n img = canvas.copy()\n\n # avoid empty canvas\n while ImageChops.difference(canvas, img).getbbox() is None:\n draw = ImageDraw.Draw(img, 'RGBA')\n for _ in range(quantity):\n factory.create_shape(colorset_info).draw(draw)\n # post effects\n img = mirror_box(img, mirror_box_axis)\n img = mirror(img, mirroring_axis1)\n img = mirror(img, mirroring_axis2)\n\n if file_name:\n if \".png\" not in file_name.lower():\n file_name += \".png\"\n img.save(file_name, \"PNG\")\n\n if show:\n img.show()","def generate_images(self, model, test_input, step, dst_dir):\n prediction = model(test_input)\n\n plt.figure(figsize=(12, 12))\n display_list = [test_input[0], prediction[0]]\n title = ['Input Image', 'Predicted Image']\n\n for i in range(2):\n plt.subplot(1, 2, i+1)\n plt.title(title[i])\n # getting the pixel values between [0, 1] to plot it.\n plt.imshow(display_list[i] * 0.5 + 0.5)\n plt.axis('off')\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\n plt.savefig(filename)","def generate_test_image(name, size=(36, 36)):\n return ContentFile(\n factory.django.ImageField()._make_data(\n {'width': size[0], 'height': size[1]}\n ), '{}.jpg'.format(name))","def GenerateImageSamples(self):\n self.generateImageSamples = GenerateImageSamples(self.trainDataDir,\n self.testDataDir,\n self.trainClassDir,\n self.testClassDir,\n self.cfgData)\n\n self.generateImageSamples.LoadDataSave(self.trainDataDir, 'train')\n # self.generateImageSamples.CopyFiles(self.trainClassDir)\n\n self.generateImageSamples.LoadDataSave(self.testDataDir, 'test')\n # self.generateImageSamples.CopyFiles(self.testClassDir)","def make_sample_image(state_info, sample, epoch):\n\n img_path = utils.make_directory(os.path.join(utils.default_model_dir, 'image'))\n sample_hat, _, _, _ = state_info.forward(sample)\n sample, sample_hat = to_data(sample), to_data(sample_hat)\n image = merge_images(sample, sample_hat)\n save_image(image.data, os.path.join(img_path, '%d.png' % epoch), normalize=True)","def generate(self, chars, format='png'):\n im = self.generate_image(chars)\n out = BytesIO()\n im.save(out, format=format)\n out.seek(0)\n return out","def test_image_mock_produces_expected_shape(self):\n\n with TemporaryDirectory() as tmp_dir:\n\n cases = [\n {\n \"x_dim\": 8,\n \"y_dim\": 8,\n \"num_channels\": 3,\n \"output_path\": \"/foo\",\n \"write_image\": True\n }\n ]\n\n for cid, case in enumerate(cases):\n output_path = os.path.join(tmp_dir, \"dummy%s.jpg\" % cid)\n img = mock_raw_image(x_dim=case[\"x_dim\"],\n y_dim=case[\"y_dim\"],\n num_channels=case[\"num_channels\"],\n output_path=output_path,\n write_image=case[\"write_image\"])\n\n self.assertEqual(img.shape, (case[\"x_dim\"], case[\"y_dim\"],\n case[\"num_channels\"]))\n if case[\"write_image\"]:\n self.assertTrue(tf.gfile.Exists(output_path))","def add_random(fr_data_path, random_path, output_path):\n with h5py.File(random_path, 'r') as data:\n random = np.asarray(data['images'].value)\n \n means = np.mean(np.mean(random, axis=-1), axis=-1)\n empty = means == 0.0\n error = np.isnan(means)\n discard = empty | error\n\n random_i = np.where(~discard)\n random = random[random_i]\n\n random = center_on_brightest(random)\n \n with h5py.File(fr_data_path, 'r') as data:\n images = np.asarray(data[\"images\"].value) \n images = center_on_brightest(images)\n \n labels = np.where(np.asarray(data['labels']), 2, 1)\n\n images = np.concatenate((images, random), axis=0)\n labels = np.concatenate((labels, np.full((random.shape[0],), \n fill_value=0)), axis=0)\n\n with h5py.File(output_path, 'w') as f:\n f.create_dataset('images', data=images)\n f.create_dataset('labels', data=labels)\n\n with h5py.File(fr_data_path, 'r') as data: \n f.copy(data, 'fri_data')\n f.copy(data, 'frii_data')","def exportImg(self):\n if self.superSampling:\n print(\"Exporting with size adjusted\")\n self.img = self.img.resize((int(self.width/2),int(self.height/2)),Image.NEAREST)\n self.img.save(self.fileName,\"PNG\")","def maketestimage(self, *args, **kwargs):\n return _image.image_maketestimage(self, *args, **kwargs)","def testBinaryImage():\n ALIEN = \"0\"*8 + \"11011011\"*2 + \"0\"*8 + \"00001000\" + \\\n \"01000010\" + \"01111110\" + \"0\"*8\n # this function is imported from cs5png.py\n NUM_ROWS = 8\n NUM_COLS = 8\n binaryIm( ALIEN, NUM_COLS, NUM_ROWS )\n # that should create a file, binary.png, in this\n # directory with the 8x8 image...","def evaluate(self):\n eval_save_dir = os.path.join(self.imsave_dir, \"test\")\n samples = self.sample(np.random.uniform(-1, 1, (self.batch_size, self.z_dim)))\n if not os.path.exists(eval_save_dir):\n os.makedirs(eval_save_dir)\n # save images\n for index, sample in enumerate(samples):\n if self.C == 1:\n imsave(os.path.join(eval_save_dir, \"%s.png\" % index), samples[index].reshape(self.H, self.W))\n else:\n imsave(os.path.join(eval_save_dir, \"%s.png\" % index),\n recover_img(samples[index].reshape(self.H, self.W, self.C)))\n\n # display some images\n row, col = 4, 4\n random_index = np.random.randint(0, self.batch_size, size=row * col)\n for i in range(row*col):\n plt.subplot(row, col, i+1)\n plt.imshow(recover_img(samples[random_index[i]].reshape(self.H, self.W, self.C))\n , cmap=\"gray\" if self.C==1 else None)\n plt.gca().axis(\"off\")\n plt.show()","def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\n viz.evaluate()\n if upsampled == True:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\n else:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\n viz.visualizer.show(outpath=outpath_, clear_figure=True)","def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, opts):\n fake_X = G_YtoX(fixed_Y, False)\n fake_Y = G_XtoY(fixed_X, False)\n\n X, fake_X = fixed_X.cpu().data.numpy(), fake_X.cpu().data.numpy()\n Y, fake_Y = fixed_Y.cpu().data.numpy(), fake_Y.cpu().data.numpy()\n\n merged = merge_images(X, fake_Y, opts)\n path = os.path.join(opts.sample_dir, 'sample-{:06d}-X-Y.png'.format(iteration))\n scipy.misc.imsave(path, merged)\n print('Saved {}'.format(path))\n\n merged = merge_images(Y, fake_X, opts)\n path = os.path.join(opts.sample_dir, 'sample-{:06d}-Y-X.png'.format(iteration))\n scipy.misc.imsave(path, merged)\n print('Saved {}'.format(path))","def write_image(self, filename):\n cv2.imwrite(filename, self.image)","def get_sample(self, index: int) -> Mapping[str, io.BytesIO]:\n del index\n if self._generated_image:\n return dict(images=self._generated_image)\n\n image_shape = (self._image_width, self._image_height, 3)\n array = np.uint8(np.random.rand(*image_shape) * 255)\n pil_image = Image.fromarray(array)\n image_io = io.BytesIO()\n pil_image.save(image_io, format=self._image_format)\n self._generated_image = image_io.getvalue()\n\n return dict(images=self._generated_image)","def generateRandomImage(size, lims=[0,255]):\n a,b = lims\n image_array = (b-a)*np.random.random(size) + a\n image = sitk.GetImageFromArray(image_array.astype(int))\n return image","def generate_art_3(filename, x_size=350, y_size=350, t_size=30):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(1, 5)\n g_lb = random.randint(1, 10)\n b_lb = random.randint(1, 5)\n red_function = build_random_function_3(r_lb, r_lb+1)\n green_function = build_random_function_3(g_lb, g_lb+1)\n blue_function = build_random_function_3(b_lb, b_lb+1)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for time in range(t_size):\n for i in range(x_size):\n for j in range(y_size):\n t = remap_interval(time, 0, t_size, -1, 1)\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(eval_r_func_3(red_function, x, y, t)),\n color_map(eval_r_func_3(green_function, x, y, t)),\n color_map(eval_r_func_3(blue_function, x, y, t))\n )\n str_num = '0' * (5 - len(str(time))) + str(time)\n print(str_num)\n im.save(filename + str_num + '.png')\n return 'saved'","def run(self):\n generated_gif = self.generate()\n with open(self.out_filename, 'wb') as out_fd:\n out_fd.write(generated_gif)","def myapp():\n image = random_image()\n return send_file(image, mimetype='image/png')","def randomize_pixels(image):\n shape_ = image.size()\n image_flat = image.view(-1, image.size(-1))\n shuffled_image = shuffle(image_flat)\n return shuffled_image.view(shape_)","def generate_and_save_images(model, epoch, test_input):\n #Training is set to false\n #so all layers run in inference mode (batchnorm)(?)\n predictions = model(test_input, training=False)\n fig = plt.figure(figsize=(4,4))\n for i in range(predictions.shape[0]):\n plt.subplot(4,4, i+1)\n img = tf.constant(predictions[i]) #Turn prediction into tf.constant\n #so it can easily be transformed int a uint8 array\n img = tf.image.convert_image_dtype(img, tf.uint8)\n plt.imshow(img)#Show the images in color\n plt.axis(\"off\")\n #for()\n\n #update epoch_total or create a new tracker\n if os.path.exists(os.path.join(\"outputColor\",\"epoch_total.txt\")):\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"r\")\n epoch = int(f.readline()) + 1\n print(\"Total Epochs:{}\".format(epoch))\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"w\")\n f.write(str(epoch))\n #if()\n else:\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"w\")\n f.write(str(epoch))\n #else()\n f.close()\n\n plt.savefig(\"outputPhotosColor/image_at_epoch_{:04d}.png\".format(epoch)) #save image\n #plt.show() # Turn on to show each new image after it's made\n plt.close()","def imwrite(image, path):\n return scipy.misc.imsave(path, to_range(image, 0, 255, np.uint8))","def testQuestionFour(self):\n self.assertTrue(os.path.exists(\"./mandelbrot.png\"), \"Question 4's output (mandelbrot.png) does not exist.\")","def save_output_image_to_directory(self):\n curr_directory = os.path.dirname(os.path.abspath(__file__))\n images_dir = curr_directory + \"/images/\"\n if not os.path.exists(images_dir):\n os.makedirs(images_dir)\n self.output_image_name = md5(str(uuid4()).encode()).hexdigest() + \".png\"\n image_file_name = images_dir + self.output_image_name\n self.output_image.save(image_file_name)\n logger.info(\"Image file saved locally : %s\", image_file_name)","def save_images(filepath, ground_truth, noisy_image=None, clean_image=None):\n # assert the pixel value range is 0-255\n ground_truth = np.squeeze(ground_truth)\n noisy_image = np.squeeze(noisy_image)\n clean_image = np.squeeze(clean_image)\n if not clean_image.any():\n cat_image = ground_truth\n else:\n cat_image = np.concatenate([ground_truth, noisy_image, clean_image], axis=1)\n im = Image.fromarray(cat_image.astype('uint8')).convert('L')\n im.save(filepath, 'png')","def random_image():\n\n # select random photo from sample table\n result = db.engine.execute(\"\"\"SELECT photo_id\n FROM sample\n ORDER BY rand() LIMIT 1\"\"\")\n photo_id = result.first()[0]\n\n # extract classification vector from database\n class_columns = \",\".join(\"Label{}\".format(i) for i in range(num_labels))\n result = db.engine.execute(\"\"\"SELECT yfcc.download_url, {}\n FROM placesCNN INNER JOIN yfcc\n ON placesCNN.photo_id = yfcc.photo_id\n WHERE yfcc.photo_id = {}\"\"\".format(class_columns,\n photo_id))\n\n row = result.first()\n download_url = row[0]\n classification = np.array(row[1:])\n\n return {\"suggested_tags\": predicted_tags(classification),\n \"classification_vector\": classification,\n \"image_url\": download_url}","def test_draw(self):\n image_name = filename(sys._getframe().f_code.co_name)\n result_file, reference_file = get_path(image_name)\n\n ''' This function is to create an empty image with a specific dimension\n with white background, and black/white colored '''\n\n image, canvas = get_image('L', (15,90),'white')\n\n for i in range(len(draw_points) - 1):\n draw(canvas, (draw_points[i + 0], draw_points[i + 1]), 'A')\n\n \"\"\" saving the file and closing it \"\"\"\n\n image.save(result_file)\n image.close()\n\n \"\"\" validate the resultant file against the reference images\"\"\"\n\n validate(reference_file, result_file)","def sample_images(self, epoch):\n synth_data = self.generator(self.constNoise)\n utils.vector_to_img(synth_data, \"./outputs/trial{}/gan{}/epoch{}.jpg\".format(self.trial, self.id, epoch))","def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, batch_size=16, sample_dir='samples_cyclegan'):\n # move input data to correct device\n device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n\n fake_X = G_YtoX(fixed_Y.to(device))\n fake_Y = G_XtoY(fixed_X.to(device))\n \n X, fake_X = to_data(fixed_X), to_data(fake_X)\n Y, fake_Y = to_data(fixed_Y), to_data(fake_Y)\n \n merged = merge_images(X, fake_Y, batch_size)\n path = os.path.join(sample_dir, 'sample-{:06d}-X-Y.png'.format(iteration))\n scipy.misc.imsave(path, merged)\n print('Saved {}'.format(path))\n \n merged = merge_images(Y, fake_X, batch_size)\n path = os.path.join(sample_dir, 'sample-{:06d}-Y-X.png'.format(iteration))\n scipy.misc.imsave(path, merged)\n print('Saved {}'.format(path))","def generate_images(generator_model, output_dir, epoch, n_class, batch_size=128):\n label = np.random.randint(0, n_class, size=(batch_size, 1))\n label = np_utils.to_categorical(label, num_classes=n_class)\n test_image_stack = generator_model.predict([np.random.rand(10, 100), label])\n test_image_stack = (test_image_stack * 127.5) + 127.5\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\n tiled_output = tile_images(test_image_stack)\n tiled_output = Image.fromarray(tiled_output, mode='L') # L specifies greyscale\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\n tiled_output.save(outfile)","def generate_random_testing(file_name, nb_points):\n file_name = _format_file_extension(file_name)\n acoustic_data = _generate_random_acoustic(nb_points)\n data = pd.DataFrame(acoustic_data, columns=[fmd.COLUMN_NAME[0]])\n data.to_csv(file_name, index=False)","def create_test_image(dirname, array, normalization=None):\n filename = str(dirname / 'tmp.tif')\n create_test_file(filename, array)\n satellite = 'quickbird'\n image = Image(filename, satellite, normalization_parameters=normalization)\n return image","def save_result(save_path, npyfile):\n for i, item in enumerate(npyfile):\n img = item[:, :, 0]\n io.imsave(os.path.join(save_path, '%d_pred.png' % i), img)","def save_groudtruth(im, coords, filename):\n print 'Saving ground truth ......{0}'.format(filename)\n img_draw = Image.fromarray(cv2.cvtColor(im, cv2.COLOR_BGR2RGB))\n draw = ImageDraw.Draw(img_draw)\n for coord in coords:\n draw.polygon([(float(coord[0]), float(coord[1])), (float(coord[2]), float(coord[3])),\n (float(coord[4]), float(coord[5])), (float(coord[6]), float(coord[7]))],\n outline=\"red\", fill=\"blue\")\n img_draw = np.array(img_draw)\n img_draw = cv2.cvtColor(img_draw, cv2.COLOR_RGB2BGR)\n bname_excludepoint = filename.split('/')[-1].split('.')[0]\n image_path = '/home/yuquanjie/Documents/deep-direct-regression/result/' + bname_excludepoint + '_gt.jpg'\n cv2.imwrite(image_path, img_draw[0: img_draw.shape[0], 0: img_draw.shape[1]])","def new_func():\n dirname, _ = os.path.split(os.path.abspath(__file__))\n pngfile = os.path.sep.join([dirname, \"out.png\"])\n img = [\"110010010011\", \"101011010100\", \"110010110101\", \"100010010011\"]\n img = [[int(val) for val in value] for value in img]\n writer = png.Writer(len(img[0]), len(img), greyscale=True, bitdepth=16)\n with open(pngfile, \"wb\") as file:\n writer.write(file, img)\n try:\n func(pngfile)\n finally:\n os.remove(pngfile)","def save_image(name, image):\n image_name = 'output/' + name + '.png'\n cv2.imwrite(image_name, image)","def write_image_to_file_incrementally(image):\r\n i = 0\r\n while os.path.exists(\"sample%s.jpeg\" % i):\r\n i += 1\r\n with open(\"sample%s.jpeg\" % i, \"wb\") as f:\r\n f.write(image)","def generate_images(self, count):\n # Generate images from the currently loaded model\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\n return self.generator.predict(noise)","def genImage(self, img_num=1, mode=\"stabilization\"):\n self.Gmodel.eval()\n with torch.no_grad():\n for i in range(img_num):\n latent_z = torch.randn(1, 512, 1, 1).normal_().to(self.device)\n output = self.Gmodel(latent_z, mode)\n print(\"output size: \", output.size())\n output = torch.clamp(output, min=0, max=1)\n output = output.cpu().squeeze().numpy()\n fake_img = output.transpose(1, 2, 0)\n print(\"fake image size: \", fake_img.shape)\n plt.imshow(fake_img)\n plt.show()\n save_file = os.path.join(self.save_dir, str(self.load_resl), \"%05d.jpg\" % i)\n os.makedirs(os.path.dirname(save_file), exist_ok=True)\n plt.imsave(save_file, fake_img)","def setUp(self):\n self.image = np.random.randint(\n 0, 256, size=(10, 10, 3)).astype('uint8')","def get_test_image(storage):\n # Generate unique name.\n storage_name = 'test-{}.png'.format(uuid.uuid4())\n\n # Create image.\n image_file = Image.new('RGBA', size=(50, 50), color=(255, 0, 0))\n ImageDraw.Draw(image_file)\n storage_file = storage.open(storage_name, 'wb')\n image_file.save(storage_file, 'png')\n\n # Yield storage name.\n yield storage_name\n\n # Delete thumbnails, if they exist.\n if hasattr(settings, 'THUMBNAIL_BASEDIR'):\n THUMBNAIL_ROOT = os.path.join(\n settings.MEDIA_ROOT,\n settings.THUMBNAIL_BASEDIR,\n )\n thumbs = glob.glob(os.path.join(THUMBNAIL_ROOT, storage_name + '*'))\n for filename in thumbs:\n os.unlink(filename)\n # Delete empty thumbnail directories.\n try:\n os.removedirs(THUMBNAIL_ROOT)\n except OSError:\n pass\n\n # Delete image.\n storage.delete(storage_name)","def save_samples(data_loader, generator_1, epoch, path):\n A2B = np.zeros((config.crop_size * 3, 0, 3))\n\n with torch.no_grad():\n for i in range(config.val_batch_size):\n\n # Prepare Data #\n real_A = next(iter(data_loader))\n real_A = real_A.to(device)\n\n # Generate Fake Images #\n fake_B, _, fake_B_heatmap = generator_1(real_A)\n\n A2B = np.concatenate((A2B, np.concatenate((RGB2BGR(tensor2npy(denorm(real_A[0]))),\n cam(tensor2npy(fake_B_heatmap[0]), config.crop_size),\n RGB2BGR(tensor2npy(denorm(fake_B[0])))), 0)), 1)\n\n cv2.imwrite(os.path.join(path, 'U-GAT-IT_Samples_Epoch_%03d.png' % (epoch + 1)), A2B * 255.0)","def create_test_set(self):\n test_files = os.listdir(self.image_folder_path)\n test_files = sorted_alphanumeric(test_files)\n delete_files(self.root_name, \"/VOC2021/ImageSets/Main\")\n write_txt(\"test.txt\", self.txt_path, test_files)"],"string":"[\n \"def test_image(filename, x_size=350, y_size=350):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n pixels[i, j] = (random.randint(0, 255), # Red channel\\n random.randint(0, 255), # Green channel\\n random.randint(0, 255)) # Blue channel\\n im.save(filename)\\n return 'saved'\",\n \"def test_image(filename, x_size=350, y_size=350):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap(i, 0, x_size, -1, 1)\\n y = remap(j, 0, y_size, -1, 1)\\n pixels[i, j] = (random.randint(0, 255), # Red channel\\n random.randint(0, 255), # Green channel\\n random.randint(0, 255)) # Blue channel\\n\\n im.save(filename)\",\n \"def test_image(filename, x_size=def_x_size, y_size=def_y_size):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (random.randint(0, 255), # Red channel\\n random.randint(0, 255), # Green channel\\n random.randint(0, 255)) # Blue channel\\n im.save(filename)\",\n \"def genrandimg(args) -> None:\\n\\n size = (int(args.x), int(args.y))\\n fp = Image.new(\\\"RGB\\\", size)\\n data = []\\n\\n if not args.c: # If color\\n for i in range(size[0]*size[1]):\\n r = random.choice([0x00, 0xff])\\n data.append((r, r, r)) # Each RGB value is the same random value\\n else: # Else black-and-white\\n for i in range(size[0]*size[1]):\\n r = [random.choice(range(0, 256)) for _ in range(0, 3)]\\n r = (r[0], r[1], r[2]) # Choose 3 random numbers for different RGB values\\n data.append(r)\\n\\n fp.putdata(data)\\n print(\\\"Saving to %s...\\\" % args.o)\\n fp.save(args.o)\\n fp.close()\",\n \"def new_test_image():\\n warnings.warn(DeprecationWarning(\\n \\\"new_test_image() is deprecated in favour of the get_sample_image() \\\"\\n \\\"context manager.\\\"), stacklevel=2)\\n image_name = 'test-{}.png'.format(uuid.uuid4())\\n image = Image.new('RGBA', size=(50, 50), color=(256, 0, 0))\\n ImageDraw.Draw(image)\\n byte_io = BytesIO()\\n image.save(byte_io, 'png')\\n byte_io.seek(0)\\n return image_name, ContentFile(byte_io.read(), image_name)\",\n \"def generate_image(filename, x_size=350, y_size=350):\\n global timeflag\\n timeflag = 0\\n\\n # Functions for red, green, and blue channels - where the magic happens!\\n red_function = build_random_function(13, 15)\\n green_function = build_random_function(13, 15)\\n blue_function = build_random_function(13,15)\\n print \\\"red_function:\\\\t\\\" + str(red_function)+\\\"\\\\n\\\"\\n print \\\"green_function:\\\\t\\\" + str(green_function)+\\\"\\\\n\\\"\\n print \\\"blue_function:\\\\t\\\" + str(blue_function)+\\\"\\\\n\\\"\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n\\n im.save(filename)\",\n \"def create_image(path, pxcount):\\n img = Image.open(path, 'r').convert('L')\\n pixels = img.load()\\n for i in range(pxcount):\\n x = randint(0, img.size[0]-1)\\n y = randint(0, img.size[0]-1)\\n if pixels[x, y] == 0:\\n pixels[x, y] = 255\\n else:\\n pixels[x, y] = 0\\n return img\",\n \"def testImage():\\n width = 200\\n height = 200\\n image = BitMap( width, height )\\n \\n # create a loop in order to draw some pixels\\n \\n for col in range(width):\\n if col % 10 == 0: print 'col is', col\\n for row in range(height):\\n if col % 10 == 0 or row % 10 == 0:\\n image.plotPoint( col, row ) \\n \\n # we have now looped through every image pixel\\n # next, we write it out to a file\\n \\n image.saveFile( \\\"test.bmp\\\" )\\n #changing the col and row number determines how big the grid is for the picture or how zoomed in it is. Changing the and to or just makes the grid go from dotted grid to lines.\",\n \"def generate_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(6, 10)\\n g_lb = random.randint(6, 10)\\n b_lb = random.randint(6, 10)\\n red_function = build_random_function(r_lb, r_lb+1)\\n green_function = build_random_function(g_lb, g_lb+1)\\n blue_function = build_random_function(b_lb, b_lb+1)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n im.save(filename+'.png')\\n return 'saved'\",\n \"def create_random_data(output_path: str, num_images: int = 5) -> None:\\n train_path = os.path.join(output_path, \\\"train\\\")\\n class1_train_path = os.path.join(train_path, \\\"class1\\\")\\n class2_train_path = os.path.join(train_path, \\\"class2\\\")\\n\\n val_path = os.path.join(output_path, \\\"val\\\")\\n class1_val_path = os.path.join(val_path, \\\"class1\\\")\\n class2_val_path = os.path.join(val_path, \\\"class2\\\")\\n\\n test_path = os.path.join(output_path, \\\"test\\\")\\n class1_test_path = os.path.join(test_path, \\\"class1\\\")\\n class2_test_path = os.path.join(test_path, \\\"class2\\\")\\n\\n paths = [\\n class1_train_path,\\n class1_val_path,\\n class1_test_path,\\n class2_train_path,\\n class2_val_path,\\n class2_test_path,\\n ]\\n\\n for path in paths:\\n try:\\n os.makedirs(path)\\n except FileExistsError:\\n pass\\n\\n for i in range(num_images):\\n pixels = numpy.random.rand(64, 64, 3) * 255\\n im = Image.fromarray(pixels.astype(\\\"uint8\\\")).convert(\\\"RGB\\\")\\n im.save(os.path.join(path, f\\\"rand_image_{i}.jpeg\\\"))\\n\\n process_images(output_path)\",\n \"def main():\\n\\n os.system(\\\"rm -rf images; mkdir images\\\")\\n\\n if (len(sys.argv) > 1):\\n N = int(sys.argv[1])\\n else:\\n N = 10\\n\\n x_test = np.load(\\\"../../../../data/mnist/mnist_test_images.npy\\\")\\n\\n for i in range(N):\\n r,c = random.randint(6,12), random.randint(6,12)\\n g = np.zeros(r*c)\\n for j in range(r*c):\\n if (random.random() < 0.15):\\n g[j] = 1\\n g = g.reshape((r,c))\\n g[:,0] = g[0,:] = g[:,-1] = g[-1,:] = 0\\n\\n img = np.zeros((28*r,28*c), dtype=\\\"uint8\\\")\\n for x in range(r):\\n for y in range(c):\\n if (g[x,y] == 1):\\n n = random.randint(0, x_test.shape[0])\\n im = x_test[n]\\n img[28*x:(28*x+28), 28*y:(28*y+28)] = im\\n \\n Image.fromarray(img).save(\\\"images/image_%04d.png\\\" % i)\",\n \"def test_save_jpg():\\n img = Image.new('RGB', (10, 20))\\n\\n parameters = {'path': 'green-dot.jpg', 'data': [img]}\\n\\n assert images.save(parameters)\",\n \"def test_save_png():\\n img = Image.new('RGB', (10, 20))\\n\\n parameters = {'path': 'green-dot.png', 'data': [img]}\\n\\n assert images.save(parameters)\",\n \"def generate_image(noise_list, save_path):\\n check_points_path = os.path.join(save_path, 'check_points')\\n output_image_path = os.path.join(save_path, 'images')\\n components.create_folder(output_image_path, False)\\n latest_checkpoint = tf.train.latest_checkpoint(check_points_path)\\n assert latest_checkpoint is not None, \\\"no check points found\\\"\\n saver = tf.train.import_meta_graph(latest_checkpoint + '.meta')\\n with tf.Session() as sess:\\n saver.restore(sess, latest_checkpoint)\\n iterations = sess.run('saved_iterations:0')\\n for i in range(len(noise_list)):\\n generated_images = sess.run('generator/output_layer/tanh/during_inference:0',\\n feed_dict={\\\"noise_for_inference:0\\\": noise_list[i]})\\n Gan.__save_images(output_image_path, generated_images, int(np.sqrt(generated_images.shape[0])), iterations, i)\",\n \"def test_write_img(img_: Tensor, ext: str) -> None:\\n with NamedTemporaryFile(\\\"w\\\") as f:\\n path = f\\\"{f.name}{ext}\\\"\\n write_img(img_, path)\\n img = read_image(path)\\n torch.testing.assert_allclose(img, img_)\",\n \"def generate_image_file(color):\\n img = generate_image(color)\\n img.save(IMAGE_FILE)\\n return IMAGE_FILE\",\n \"def generate_images(generator_model, output_dir, epoch):\\n test_image_stack = generator_model.predict(np.random.normal(size=(10, 100)))\\n test_image_stack = (test_image_stack * 255)\\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\\n tiled_output = tile_images(test_image_stack)\\n tiled_output = Image.fromarray(tiled_output)\\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\\n tiled_output.save(outfile)\",\n \"def generate_art(filename, x_size=1920, y_size=1080):\\n # Functions for red, green, and blue channels - where the magic happens!\\n red_function = build_random_function(7,8)\\n green_function = build_random_function(4,6)\\n blue_function = build_random_function(3,5)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n\\n im.save(filename)\",\n \"def save_image(start, stop, imgcount, label):\\n text = \\\"\\\"\\n imgfile = select_file(label)\\n for p in range(imgcount):\\n pxcnt = randint(start, stop)\\n imgcurrent = create_image(imgfile, pxcnt)\\n filename = \\\"img_train_\\\" + str(label) + \\\"_\\\" + str(p) + \\\"_\\\" + str(pxcnt) + \\\".png\\\"\\n text += \\\"ctq/dataset/train/\\\" + filename + \\\" \\\" + str(label) + \\\"\\\\n\\\"\\n imgcurrent.save(filename)\\n text_file = open(imgfile + \\\"_train_label.txt\\\", \\\"w\\\")\\n text_file.write(text)\\n text_file.close()\",\n \"def test_save_tif():\\n img = Image.new('RGB', (10, 20))\\n\\n parameters = {'path': 'green-dot.tif', 'data': [img]}\\n\\n assert images.save(parameters)\",\n \"def generate_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n \\n red_function = build_random_function(7,15)\\n green_function = build_random_function(7,15)\\n blue_function = build_random_function(7,15)\\n \\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n\\n im.save(filename)\",\n \"def generate_image(self):\\n pass\",\n \"def test(train_out_dir):\\n above = os.path.join(train_out_dir, '..')\\n os.chdir(above)\\n if not os.path.exists(\\\"test\\\"):\\n os.mkdir(\\\"test\\\")\\n\\n for sdir in os.listdir(train_out_dir):\\n cur_dir = os.path.join(train_out_dir, sdir)\\n list_curr_dir = os.listdir(cur_dir)\\n random.seed()\\n rand_num = random.randint(0, len(list_curr_dir) - 1)\\n rand_img = list_curr_dir[rand_num]\\n rand_img_path = os.path.join(cur_dir, rand_img)\\n dst_path = os.path.join(\\\"test\\\", sdir)\\n if not os.path.exists(dst_path):\\n os.mkdir(dst_path)\\n\\n shutil.move(rand_img_path, os.path.join(dst_path, os.path.basename(rand_img_path)))\",\n \"def mock_raw_image(x_dim=1024, y_dim=1024, num_channels=3,\\n output_path=None, write_image=True):\\n\\n rand_shape = (x_dim, y_dim, num_channels)\\n\\n if num_channels != 3:\\n raise NotImplementedError(\\\"mock_raw_image for channels != 3 not yet \\\"\\n \\\"implemented.\\\")\\n\\n img = np.random.random(rand_shape)\\n img = np.uint8(img*255)\\n\\n if write_image:\\n image_obj = allen_brain.PIL_Image()\\n pil_img = image_obj.fromarray(img, mode=\\\"RGB\\\")\\n with tf.gfile.Open(output_path, \\\"w\\\") as f:\\n pil_img.save(f, \\\"jpeg\\\")\\n\\n return img\",\n \"def test_image(self):\\r\\n self.testdata = open(TESTDATA_FILENAME).read()\",\n \"def get_rand_img():\\n import urllib\\n import os\\n import glob\\n\\n pics = glob.glob('/home/cody_techngs/PycharmProjects/ProjTest/ActiveAMT/ActiveAMT_FLASK/static/images/HITs/rand*')\\n nums = []\\n\\n for pic in pics:\\n nums.append(int(pic.split('rand_img')[1].split('.')[0]))\\n\\n unique_num = False\\n new_rand_num = 0\\n\\n while not unique_num:\\n new_rand_num = random.randrange(1, 2000)\\n if new_rand_num not in nums:\\n unique_num = True\\n\\n img_name = 'rand_img{}.jpg'.format(new_rand_num)\\n dl_location = os.getcwd() + '/ActiveAMT/ActiveAMT_FLASK/static/images/HITs/' + img_name\\n url = 'https://unsplash.it/400/300/?random'\\n urllib.urlretrieve(url, dl_location)\\n\\n return 'static/images/HITs/{}'.format(img_name)\",\n \"def sample_image(n_row, batches_done):\\n # Sample noise\\n z = Variable(Tensor(np.random.normal(0, 1, (n_row ** 2, opt.latent_dim))))\\n gen_imgs = decoder(z)\\n save_image(\\n gen_imgs.data, \\\"images/%d.png\\\" % batches_done, nrow=n_row, normalize=True\\n )\",\n \"def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape, samples_limit=None):\\n\\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\\n\\n if samples_limit:\\n image_paths = image_paths[0:samples_limit]\\n\\n for image_file in tqdm(image_paths, desc='Processing: ', unit='images', total=len(image_paths)):\\n yield process_image_file(image_file, sess, logits, keep_prob, image_pl, image_shape)\",\n \"def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, sample_dir='samples'):\\n\\n os.makedirs(sample_dir, exist_ok=True)\\n\\n fake_X = G_YtoX(fixed_Y)\\n fake_Y = G_XtoY(fixed_X)\\n\\n X, fake_X = tensor_to_image(fixed_X), tensor_to_image(fake_X)\\n Y, fake_Y = tensor_to_image(fixed_Y), tensor_to_image(fake_Y)\\n \\n grid_xy = merge_images(X, fake_Y)\\n path = os.path.join(sample_dir, 'sample-{:05d}-X-Y.png'.format(iteration))\\n imageio.imwrite(path, grid_xy)\\n \\n grid_yx = merge_images(Y, fake_X)\\n path = os.path.join(sample_dir, 'sample-{:05d}-Y-X.png'.format(iteration))\\n imageio.imwrite(path, grid_yx)\",\n \"def gen_test_output(sess, logits, keep_prob, image_pl, data_folder, image_shape):\\n for image_file in glob(os.path.join(data_folder, 'image_2', '*.png')):\\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\\n\\n im_softmax = sess.run(\\n [tf.nn.softmax(logits)],\\n {keep_prob: 1.0, image_pl: [image]})\\n im_softmax_road = im_softmax[0][:, 1].reshape(image_shape[0], image_shape[1])\\n segmentation_road = (im_softmax_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\\n \\n im_softmax_other_road = im_softmax[0][:, 2].reshape(image_shape[0], image_shape[1])\\n segmentation_other_road = (im_softmax_other_road > 0.5).reshape(image_shape[0], image_shape[1], 1)\\n \\n # green road\\n mask_road = np.dot(segmentation_road, np.array([[0, 255, 0, 127]]))\\n mask_road = scipy.misc.toimage(mask_road, mode=\\\"RGBA\\\")\\n \\n # blue other_road\\n mask_other_road = np.dot(segmentation_other_road, np.array([[0, 0, 255, 127]]))\\n mask_other_road = scipy.misc.toimage(mask_other_road, mode=\\\"RGBA\\\")\\n \\n street_im = scipy.misc.toimage(image)\\n street_im.paste(mask_road, box=None, mask=mask_road)\\n street_im.paste(mask_other_road, box=None, mask=mask_other_road)\\n\\n yield os.path.basename(image_file), np.array(street_im)\",\n \"def gen_test_output(sess, logits, keep_prob, image_pl, screen, image_shape):\\n image = scipy.misc.imresize(screen, image_shape)\\n im_softmax = sess.run([tf.nn.softmax(logits)],{keep_prob: 1.0, image_pl: [image]})\\n im_softmax = im_softmax[0][:, 1].reshape(image_shape[0], image_shape[1])\\n segmentation = (im_softmax > 0.5).reshape(image_shape[0], image_shape[1], 1)\\n mask = np.dot(segmentation, np.array([[0, 255, 0, 127]]))\\n mask = scipy.misc.toimage(mask, mode=\\\"RGBA\\\")\\n street_im = scipy.misc.toimage(image)\\n street_im.paste(mask, box=None, mask=mask)\\n street_im = np.array(street_im)\\n\\n return street_im\",\n \"def test_write_rgb(self):\\n with tempfile.TemporaryDirectory() as out_dir:\\n image_name = os.path.join(out_dir, \\\"test.png\\\")\\n img = np.random.rand(2, 3, 3)\\n img_save_val = (255 * img).astype(np.uint8)\\n writer_obj = PILWriter(output_dtype=np.uint8)\\n writer_obj.set_data_array(img, channel_dim=-1)\\n writer_obj.write(image_name)\\n out = np.asarray(Image.open(image_name))\\n out = np.moveaxis(out, 0, 1)\\n np.testing.assert_allclose(out, img_save_val)\",\n \"def generate_and_save_images(model, seed, output_path, title):\\n\\n predictions = model(tf.Variable(seed, trainable=False))\\n\\n fig = plt.figure(figsize=(4,4))\\n\\n for i in range(predictions.shape[0]):\\n plt.subplot(4, 4, i+1)\\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\\n plt.axis('off')\\n if not os.path.exists(output_path):\\n os.mkdir(output_path)\\n\\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\\n plt.close()\",\n \"def __seed_output_image(self, src_image: Image, out_image: Image) -> None:\\n src_pixel_array = src_image[:, :].reshape((src_image.area, 3))\\n src_index_array = np.random.choice(np.arange(src_image.area), out_image.area)\\n out_image[:, :] = np.take(src_pixel_array, src_index_array, axis=0).reshape(out_image.shape)\",\n \"def test_read_img(\\n img_: Tensor, ext: str, write_image: Callable[..., Any]\\n) -> None:\\n with NamedTemporaryFile(\\\"w\\\") as f:\\n path = f.name + ext\\n write_image(img_, path)\\n img = read_img(path)\\n torch.testing.assert_allclose(img, img_)\",\n \"def test_create_image(self):\\n pass\",\n \"def gen_test_output(sess, logits, image_folder, image_pl, data_folder,\\n learning_phase, image_shape, nw_shape):\\n image_paths = glob(os.path.join(data_folder, image_folder, '*.png'))\\n for image_file in image_paths[:5]:\\n\\n in_image = scipy.misc.imread(image_file, mode='RGB')\\n image = scipy.misc.imresize(in_image, image_shape)\\n\\n street_im = get_seg_img(sess, logits, image_pl, image, image_shape,\\n nw_shape, learning_phase)\\n\\n street_im = scipy.misc.imresize(street_im, in_image.shape)\\n yield os.path.basename(image_file), np.array(street_im)\",\n \"def imageSaveOutput(image,name,number):\\n FileName = name +\\\" \\\"+number\\n mpimg.imsave(\\\"test_images_output\\\"+'//'+FileName,image)\\n return 0;\",\n \"def sample_image(generator, n_row, batches_done):\\r\\n # Sample noise\\r\\n z = Variable(float_tensor(np.random.normal(0, 1, (n_row ** 2, args.latent_dim))))\\r\\n labels = np.array([num for _ in range(n_row) for num in range(n_row)])\\r\\n labels = Variable(long_tensor(labels))\\r\\n gen_imgs = generator(z, labels)\\r\\n save_image(gen_imgs.data, \\\"images/%d.png\\\" % batches_done, nrow=n_row, normalize=True)\",\n \"def test_save_image(self):\\n\\n from m3_save_images.m3_save_images import save_images\\n folder_destination_name = \\\"unittest-sorted-images\\\"\\n path_source = \\\"../img\\\"\\n image_name = [\\\"00ff00.png\\\", \\\"aqua.png\\\", \\\"black.jpg\\\", \\\"yellow.png\\\", \\\"red2.jpg\\\", \\\"green.jpg\\\"]\\n image_color = [\\\"Lime\\\", \\\"Aqua\\\", \\\"Black\\\", \\\"Yellow\\\", \\\"Red\\\", \\\"Green\\\"]\\n # new empty folder is needed for testing save_image() function\\n if os.path.isdir(folder_destination_name):\\n shutil.rmtree(folder_destination_name)\\n os.mkdir(folder_destination_name)\\n # creating folders\\n for i in range(0, 4):\\n save_images(folder_destination_name, path_source, image_name[i], image_color[i])\\n self.assertEqual(''.join(os.listdir(os.path.join(folder_destination_name, image_color[i]))), image_name[i])\\n save_images(folder_destination_name, path_source, image_name[i], image_color[5])\\n self.assertNotEqual(''.join(os.listdir(os.path.join(folder_destination_name, image_color[i]))), image_name[5])\",\n \"async def get_image(self):\\n\\n # generating\\n fixed_latent = torch.randn(1, 512, 1, 1, device=self.device)\\n\\n with torch.no_grad():\\n # passing through\\n fake_images = self.model(fixed_latent)\\n # saving\\n save_image(fake_images, f'models/FaceGAN_dir/faces/fake.jpg')\",\n \"def save_test_images(images):\\n for description, img in images.items():\\n save_to_image(img, description)\\n save_to_netcdf(img, description)\",\n \"def save_image(image, output_folder, output_name):\\n\\n\\tfolder_path = compute_path(output_folder, 'dataset')\\n\\tos.makedirs(folder_path, exist_ok=True)\\n\\n\\tfile_path = os.path.join(folder_path, output_name + '.png')\\n\\timage.save(file_path)\",\n \"def test_save_fail():\\n img = Image.new('RGB', (10, 20))\\n\\n parameters = {'path': 'foo.bar', 'data': [img]}\\n\\n images.save(parameters)\",\n \"def test(file_path: str):\\n # Build the generator network\\n generator = build_generator()\\n\\n # Load model weights\\n generator.load_weights(\\\"models/generator.h5\\\")\\n\\n # Make a low-res counterpart to predict upon\\n image = imread(file_path, mode=\\\"RGB\\\")\\n image = image.astype(np.float32)\\n low_resolution_image = [imresize(image, low_resolution_shape)]\\n\\n low_resolution_image = np.array(low_resolution_image) / 127.5 - 1.0\\n\\n # Generate high-resolution images from low-resolution images\\n generated_image = generator.predict_on_batch(low_resolution_image)\\n\\n # Make a common figure\\n fig = plt.figure(figsize=(16, 9))\\n\\n # Add the low resolution image on the left side\\n ax = fig.add_subplot(1, 2, 1)\\n ax.imshow(low_resolution_image[0], interpolation=\\\"nearest\\\")\\n ax.axis(\\\"off\\\")\\n ax.set_title(\\\"Low-resolution\\\")\\n\\n # Add generated image to figure on the right side\\n ax = fig.add_subplot(1, 2, 2)\\n ax.imshow(generated_image[0], interpolation=\\\"nearest\\\")\\n ax.axis(\\\"off\\\")\\n ax.set_title(\\\"Generated\\\")\\n\\n # Save the figure\\n plt.savefig(\\\"{0}{1}\\\".format(TEST_IMAGES_RESULT, file_path.split(\\\"/\\\")[-1]))\",\n \"def new_image(x, y, out, data):\\n img = Image.new('RGB', (x, y))\\n img.putdata(data)\\n img.save(out)\",\n \"def create_artificial_image(self):\\n background = self.BGI.create_background_image()\\n star_PSF = self.PSF.create_star_PSF()\\n header = self.HDR.create_header()\\n\\n fits.writeto(self.image_dir + self.image_name + '.fits',\\n background + star_PSF, overwrite=True, header=header)\",\n \"def test_save_images(self):\\n save_file(self.quart.save_images, to_single_file=False)\",\n \"def generate_rand_image(image, groundtruth, noise=True, flip=True):\\n # Get the size of the image\\n x_size, y_size = image.size\\n\\n def rotate_augmentation():\\n \\\"\\\"\\\"Generate a function to perform a random rotation of an image\\n using mirroring for padding\\\"\\\"\\\"\\n rand_rotate = np.random.randint(180)\\n return lambda image: rotate_with_extension(image, rand_rotate)\\n\\n def shift_augmentation():\\n \\\"\\\"\\\"Generates a function to perform a random shift of the image using mirroring\\n for padding\\\"\\\"\\\"\\n shift = np.random.randint(-200, 201, size=2)\\n return lambda image: shift_with_extension(image, shift)\\n\\n def zoom_augmentation():\\n \\\"\\\"\\\"Generates a function that performs a random zoom on the image\\\"\\\"\\\"\\n # Get the width and the height of the zoomed version\\n x_len, y_len = np.random.randint(250, 350, size=2)\\n # Get left upper ,right and lower bound of the pixels in the original image\\n left = np.random.randint(x_size-x_len)\\n upper = np.random.randint(y_size-y_len)\\n right, lower = left + x_len, upper+y_len\\n # Crops the box and resizes it to the original image size\\n box = (left, upper, right, lower)\\n return lambda image: image.transform(image.size, Image.EXTENT, box)\\n\\n def flip_augmentation():\\n \\\"\\\"\\\"Generates a function to flip the image\\\"\\\"\\\"\\n return lambda image: ImageOps.flip(image)\\n\\n def mirror_augmentation():\\n \\\"\\\"\\\"Generates a function to mirror an image\\\"\\\"\\\"\\n return lambda image: ImageOps.mirror(image)\\n\\n # All possible augmentations\\n augmentations = [rotate_augmentation(), shift_augmentation(), zoom_augmentation(),\\n flip_augmentation(), mirror_augmentation()]\\n\\n # Loop through all augmentations and apply each one with a probability of 0.5\\n for augmentation in augmentations:\\n if np.random.randint(2) == 1:\\n image = augmentation(image)\\n groundtruth = augmentation(groundtruth)\\n\\n # Add salt or pepper noise each one with a probability of 0.33\\n if noise:\\n noises = [\\\"s&p\\\", \\\"gauss\\\"]\\n num_noises = len(noises)\\n # Choose noise to apply\\n noise_rand = np.random.randint(num_noises + 1)\\n # apply the noise only to the image and not the groundtruth\\n if noise_rand < num_noises:\\n image = add_noise(image, type=noises[noise_rand])\\n\\n return (image, groundtruth)\",\n \"def paint_a_picture():\\n # Make a training set (many random i,j coord and an x by y box around that coord to start with)\\n # Throw it into the net\\n # Test how it does for some random coordinate inputs\\n pass\",\n \"def gen_simple_test():\\n count = 1\\n mdict = {\\n 'operating_frequency': 3e8,\\n 'sample_rate': 8e3,\\n 'signal': [1] * 5,\\n 'origin_pos': [1000, 0, 0],\\n 'dest_pos': [300, 200, 50],\\n 'origin_vel': [0] * 3,\\n 'dest_vel': [0] * 3,\\n }\\n io.savemat('{}{}_input'.format(tests_path, count), mdict)\",\n \"def imwrite(image, path):\\n\\n if image.ndim == 3 and image.shape[2] == 1: # for gray image\\n image = np.array(image, copy=True)\\n image.shape = image.shape[0:2]\\n\\n imgarray=((image+1.0)*127.5).astype(np.uint8)\\n img=Image.fromarray(imgarray)\\n img.save(path)\",\n \"def test_generator(self, test_path):\\n\\n img_list = os.scandir(test_path)\\n for img_entry in img_list:\\n\\n img = cv2.imread(img_entry.path, COLOR_TO_OPENCV[self.color_mode])\\n if img.shape[-1] == 3:\\n orig_shape = img.shape[-2::-1]\\n else:\\n orig_shape = img.shape[::-1]\\n\\n\\n img = cv2.resize(img, tuple(self.target_size))\\n img = img / 255\\n if self.color_mode == \\\"grayscale\\\":\\n img = np.reshape(img, img.shape + (1,))\\n img = np.reshape(img, (1,) + img.shape)\\n yield img, img_entry, orig_shape\",\n \"def random_image(self, height, width):\\n random_image_properties = {}\\n # flip a coin to determine whether image should be synthetic or real\\n if random.random() < self.prob_real:\\n random_image_properties['real'] = True\\n # select a random row from the list of filenames\\n # random_row = self.df_real_images.sample(n=1)\\n # print(random_row)\\n # filename, x0, y0, x1, y1, x2, y2, x3, y3 = random_row\\n random_index = random.choice(list(range(len(self.df_real_images))))\\n filename = self.df_real_images['filename'].values[random_index]\\n print(filename)\\n x0 = self.df_real_images['x0'].values[random_index]\\n y0 = self.df_real_images['y0'].values[random_index]\\n x1 = self.df_real_images['x1'].values[random_index]\\n y1 = self.df_real_images['y1'].values[random_index]\\n x2 = self.df_real_images['x2'].values[random_index]\\n y2 = self.df_real_images['y2'].values[random_index]\\n x3 = self.df_real_images['x3'].values[random_index]\\n y3 = self.df_real_images['y3'].values[random_index]\\n random_image_properties['real_image_path'] = filename\\n cornerpoints = np.array([[x0,y0],[x1,y1],[x2,y2],[x3,y3]], dtype=np.float32)\\n\\n abs_impath = os.path.join(self.real_image_dirpath, filename)\\n im = cv2.imread(abs_impath, 1)\\n print('Loaded image from {}'.format(abs_impath))\\n h,w,c = im.shape\\n sfx = float(width)/w\\n sfy = float(height)/h\\n scale_matrix = np.array([[sfx,0,0],\\n [0,sfy,0],\\n [0,0,1]], dtype=np.float32)\\n\\n # mask = np.zeros((h,w))\\n # mask = cv2.fillPoly(mask, np.int32([cornerpoints]), 1)\\n # utils.showims([im, mask], ['im', 'mask'])\\n\\n # im_shrunk = cv2.resize(im, (width, height))\\n # mask_shrunk=np.zeros((height, width))\\n\\n cornerpoints_shrunk = coordinate_geometry.transform_cornerpoints_2D(scale_matrix, cornerpoints)\\n cornerpoints = cornerpoints_shrunk\\n\\n # mask_shrunk = cv2.fillPoly(mask_shrunk, np.int32([cornerpoints_shrunk]), 1)\\n # utils.showims([im_shrunk, mask_shrunk], ['im_shrunk', 'mask_shrunk'])\\n\\n # cornerpoints = coordinate_geometry.transform_cornerpoints_2D(scale_matrix, cornerpoints)\\n random_image_properties['cornerpoints'] = np.int32(cornerpoints)\\n\\n\\n # and set unused variables to None\\n random_image_properties['card_template_path'] = None\\n random_image_properties['background_image_path'] = None\\n else:\\n random_image_properties['real'] = False\\n random_image_properties['card_template_path'] = random.choice(self.card_template_filenames)\\n random_image_properties['background_image_path'] = random.choice(self.background_image_filenames)\\n random_image_properties['cornerpoints'] = self.random_cornerpoints(height, width)\\n\\n # and set unused variables to NoneX\\n random_image_properties['real_image_path'] = None\\n\\n return random_image_properties\",\n \"def random_image(file_name=None, show=False, debug=False, seed=None):\\n if seed:\\n np.random.seed(seed)\\n\\n config = dict(\\n # color, grayscale or black and white and their probabilities\\n # for now V2 is only color\\n s_colorset=[\\\"color\\\", \\\"gs\\\", \\\"bw\\\"],\\n p_colorset=[1, 0, 0],\\n\\n # use alpha [False, True]\\n p_use_alpha=[0.7, 0.3],\\n\\n s_quantity=[1, 2, 3, 4],\\n p_quantity=[0.55, 0.30, 0.10, 0.05],\\n\\n # size of the canvas and the probability of each one\\n s_size=[512, 1024, 2048],\\n p_size=[0.3, 0.6, 0.1],\\n\\n s_aspect=[\\\"1:1\\\", \\\"4:3\\\", \\\"16:9\\\"],\\n p_aspect=[0.3, 0.5, 0.2],\\n\\n # mirror a box\\n s_mirror_box=[None, \\\"h\\\", \\\"v\\\"],\\n p_mirror_box=[0.95, 0.025, 0.025],\\n\\n # mirroring in half, negative means lowerX or rightY\\n s_mirroring=[None, \\\"h\\\", \\\"v\\\", \\\"-h\\\", \\\"-v\\\"],\\n p_mirroring1=[0.90, 0.025, 0.025, 0.025, 0.025],\\n p_mirroring2=[0.90, 0.025, 0.025, 0.025, 0.025]\\n )\\n\\n # chose colorset, quantity of shapes and size from config\\n colorset = choice(config[\\\"s_colorset\\\"], p=config[\\\"p_colorset\\\"])\\n # v1.2\\n use_alpha = choice([False, True], p=config[\\\"p_use_alpha\\\"])\\n colorset_info = {\\\"colorset\\\": colorset, \\\"use_alpha\\\": use_alpha}\\n quantity = choice(config[\\\"s_quantity\\\"], p=config[\\\"p_quantity\\\"])\\n size = choice(config[\\\"s_size\\\"], p=config[\\\"p_size\\\"])\\n\\n # v1.2\\n aspect = choice(config[\\\"s_aspect\\\"], p=config[\\\"p_aspect\\\"])\\n aspect = int(aspect.split(\\\":\\\")[0]), int(aspect.split(\\\":\\\")[1])\\n mirroring_axis1 = choice(config[\\\"s_mirroring\\\"], p=config[\\\"p_mirroring1\\\"])\\n mirroring_axis2 = choice(config[\\\"s_mirroring\\\"], p=config[\\\"p_mirroring2\\\"])\\n mirror_box_axis = choice(config[\\\"s_mirror_box\\\"], p=config[\\\"p_mirror_box\\\"])\\n\\n if debug:\\n print(\\\"Selected values: \\\")\\n print(\\\"colorset = %s\\\" % colorset_info['colorset'])\\n print(\\\"use alpha = %s\\\" % colorset_info['use_alpha'])\\n print(\\\"quantity of shapes = %d\\\" % quantity)\\n print(\\\"size = %d\\\" % size)\\n print(\\\"aspect ratio = %d:%d\\\" % (aspect[0], aspect[1]))\\n print(\\\"mirroring box axis = %r\\\" % mirror_box_axis)\\n print(\\\"mirroring axis 1 = %r\\\" % mirroring_axis1)\\n print(\\\"mirroring axis 2 = %r\\\" % mirroring_axis2)\\n\\n factory = ShapeFactory(size)\\n canvas = Image.new(\\n 'RGB',\\n (size, int((size/aspect[0])*aspect[1])),\\n color=factory.get_color_from_set(colorset_info)\\n )\\n img = canvas.copy()\\n\\n # avoid empty canvas\\n while ImageChops.difference(canvas, img).getbbox() is None:\\n draw = ImageDraw.Draw(img, 'RGBA')\\n for _ in range(quantity):\\n factory.create_shape(colorset_info).draw(draw)\\n # post effects\\n img = mirror_box(img, mirror_box_axis)\\n img = mirror(img, mirroring_axis1)\\n img = mirror(img, mirroring_axis2)\\n\\n if file_name:\\n if \\\".png\\\" not in file_name.lower():\\n file_name += \\\".png\\\"\\n img.save(file_name, \\\"PNG\\\")\\n\\n if show:\\n img.show()\",\n \"def generate_images(self, model, test_input, step, dst_dir):\\n prediction = model(test_input)\\n\\n plt.figure(figsize=(12, 12))\\n display_list = [test_input[0], prediction[0]]\\n title = ['Input Image', 'Predicted Image']\\n\\n for i in range(2):\\n plt.subplot(1, 2, i+1)\\n plt.title(title[i])\\n # getting the pixel values between [0, 1] to plot it.\\n plt.imshow(display_list[i] * 0.5 + 0.5)\\n plt.axis('off')\\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\\n plt.savefig(filename)\",\n \"def generate_test_image(name, size=(36, 36)):\\n return ContentFile(\\n factory.django.ImageField()._make_data(\\n {'width': size[0], 'height': size[1]}\\n ), '{}.jpg'.format(name))\",\n \"def GenerateImageSamples(self):\\n self.generateImageSamples = GenerateImageSamples(self.trainDataDir,\\n self.testDataDir,\\n self.trainClassDir,\\n self.testClassDir,\\n self.cfgData)\\n\\n self.generateImageSamples.LoadDataSave(self.trainDataDir, 'train')\\n # self.generateImageSamples.CopyFiles(self.trainClassDir)\\n\\n self.generateImageSamples.LoadDataSave(self.testDataDir, 'test')\\n # self.generateImageSamples.CopyFiles(self.testClassDir)\",\n \"def make_sample_image(state_info, sample, epoch):\\n\\n img_path = utils.make_directory(os.path.join(utils.default_model_dir, 'image'))\\n sample_hat, _, _, _ = state_info.forward(sample)\\n sample, sample_hat = to_data(sample), to_data(sample_hat)\\n image = merge_images(sample, sample_hat)\\n save_image(image.data, os.path.join(img_path, '%d.png' % epoch), normalize=True)\",\n \"def generate(self, chars, format='png'):\\n im = self.generate_image(chars)\\n out = BytesIO()\\n im.save(out, format=format)\\n out.seek(0)\\n return out\",\n \"def test_image_mock_produces_expected_shape(self):\\n\\n with TemporaryDirectory() as tmp_dir:\\n\\n cases = [\\n {\\n \\\"x_dim\\\": 8,\\n \\\"y_dim\\\": 8,\\n \\\"num_channels\\\": 3,\\n \\\"output_path\\\": \\\"/foo\\\",\\n \\\"write_image\\\": True\\n }\\n ]\\n\\n for cid, case in enumerate(cases):\\n output_path = os.path.join(tmp_dir, \\\"dummy%s.jpg\\\" % cid)\\n img = mock_raw_image(x_dim=case[\\\"x_dim\\\"],\\n y_dim=case[\\\"y_dim\\\"],\\n num_channels=case[\\\"num_channels\\\"],\\n output_path=output_path,\\n write_image=case[\\\"write_image\\\"])\\n\\n self.assertEqual(img.shape, (case[\\\"x_dim\\\"], case[\\\"y_dim\\\"],\\n case[\\\"num_channels\\\"]))\\n if case[\\\"write_image\\\"]:\\n self.assertTrue(tf.gfile.Exists(output_path))\",\n \"def add_random(fr_data_path, random_path, output_path):\\n with h5py.File(random_path, 'r') as data:\\n random = np.asarray(data['images'].value)\\n \\n means = np.mean(np.mean(random, axis=-1), axis=-1)\\n empty = means == 0.0\\n error = np.isnan(means)\\n discard = empty | error\\n\\n random_i = np.where(~discard)\\n random = random[random_i]\\n\\n random = center_on_brightest(random)\\n \\n with h5py.File(fr_data_path, 'r') as data:\\n images = np.asarray(data[\\\"images\\\"].value) \\n images = center_on_brightest(images)\\n \\n labels = np.where(np.asarray(data['labels']), 2, 1)\\n\\n images = np.concatenate((images, random), axis=0)\\n labels = np.concatenate((labels, np.full((random.shape[0],), \\n fill_value=0)), axis=0)\\n\\n with h5py.File(output_path, 'w') as f:\\n f.create_dataset('images', data=images)\\n f.create_dataset('labels', data=labels)\\n\\n with h5py.File(fr_data_path, 'r') as data: \\n f.copy(data, 'fri_data')\\n f.copy(data, 'frii_data')\",\n \"def exportImg(self):\\n if self.superSampling:\\n print(\\\"Exporting with size adjusted\\\")\\n self.img = self.img.resize((int(self.width/2),int(self.height/2)),Image.NEAREST)\\n self.img.save(self.fileName,\\\"PNG\\\")\",\n \"def maketestimage(self, *args, **kwargs):\\n return _image.image_maketestimage(self, *args, **kwargs)\",\n \"def testBinaryImage():\\n ALIEN = \\\"0\\\"*8 + \\\"11011011\\\"*2 + \\\"0\\\"*8 + \\\"00001000\\\" + \\\\\\n \\\"01000010\\\" + \\\"01111110\\\" + \\\"0\\\"*8\\n # this function is imported from cs5png.py\\n NUM_ROWS = 8\\n NUM_COLS = 8\\n binaryIm( ALIEN, NUM_COLS, NUM_ROWS )\\n # that should create a file, binary.png, in this\\n # directory with the 8x8 image...\",\n \"def evaluate(self):\\n eval_save_dir = os.path.join(self.imsave_dir, \\\"test\\\")\\n samples = self.sample(np.random.uniform(-1, 1, (self.batch_size, self.z_dim)))\\n if not os.path.exists(eval_save_dir):\\n os.makedirs(eval_save_dir)\\n # save images\\n for index, sample in enumerate(samples):\\n if self.C == 1:\\n imsave(os.path.join(eval_save_dir, \\\"%s.png\\\" % index), samples[index].reshape(self.H, self.W))\\n else:\\n imsave(os.path.join(eval_save_dir, \\\"%s.png\\\" % index),\\n recover_img(samples[index].reshape(self.H, self.W, self.C)))\\n\\n # display some images\\n row, col = 4, 4\\n random_index = np.random.randint(0, self.batch_size, size=row * col)\\n for i in range(row*col):\\n plt.subplot(row, col, i+1)\\n plt.imshow(recover_img(samples[random_index[i]].reshape(self.H, self.W, self.C))\\n , cmap=\\\"gray\\\" if self.C==1 else None)\\n plt.gca().axis(\\\"off\\\")\\n plt.show()\",\n \"def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\\n viz.evaluate()\\n if upsampled == True:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\\n else:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\\n viz.visualizer.show(outpath=outpath_, clear_figure=True)\",\n \"def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, opts):\\n fake_X = G_YtoX(fixed_Y, False)\\n fake_Y = G_XtoY(fixed_X, False)\\n\\n X, fake_X = fixed_X.cpu().data.numpy(), fake_X.cpu().data.numpy()\\n Y, fake_Y = fixed_Y.cpu().data.numpy(), fake_Y.cpu().data.numpy()\\n\\n merged = merge_images(X, fake_Y, opts)\\n path = os.path.join(opts.sample_dir, 'sample-{:06d}-X-Y.png'.format(iteration))\\n scipy.misc.imsave(path, merged)\\n print('Saved {}'.format(path))\\n\\n merged = merge_images(Y, fake_X, opts)\\n path = os.path.join(opts.sample_dir, 'sample-{:06d}-Y-X.png'.format(iteration))\\n scipy.misc.imsave(path, merged)\\n print('Saved {}'.format(path))\",\n \"def write_image(self, filename):\\n cv2.imwrite(filename, self.image)\",\n \"def get_sample(self, index: int) -> Mapping[str, io.BytesIO]:\\n del index\\n if self._generated_image:\\n return dict(images=self._generated_image)\\n\\n image_shape = (self._image_width, self._image_height, 3)\\n array = np.uint8(np.random.rand(*image_shape) * 255)\\n pil_image = Image.fromarray(array)\\n image_io = io.BytesIO()\\n pil_image.save(image_io, format=self._image_format)\\n self._generated_image = image_io.getvalue()\\n\\n return dict(images=self._generated_image)\",\n \"def generateRandomImage(size, lims=[0,255]):\\n a,b = lims\\n image_array = (b-a)*np.random.random(size) + a\\n image = sitk.GetImageFromArray(image_array.astype(int))\\n return image\",\n \"def generate_art_3(filename, x_size=350, y_size=350, t_size=30):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(1, 5)\\n g_lb = random.randint(1, 10)\\n b_lb = random.randint(1, 5)\\n red_function = build_random_function_3(r_lb, r_lb+1)\\n green_function = build_random_function_3(g_lb, g_lb+1)\\n blue_function = build_random_function_3(b_lb, b_lb+1)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for time in range(t_size):\\n for i in range(x_size):\\n for j in range(y_size):\\n t = remap_interval(time, 0, t_size, -1, 1)\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(eval_r_func_3(red_function, x, y, t)),\\n color_map(eval_r_func_3(green_function, x, y, t)),\\n color_map(eval_r_func_3(blue_function, x, y, t))\\n )\\n str_num = '0' * (5 - len(str(time))) + str(time)\\n print(str_num)\\n im.save(filename + str_num + '.png')\\n return 'saved'\",\n \"def run(self):\\n generated_gif = self.generate()\\n with open(self.out_filename, 'wb') as out_fd:\\n out_fd.write(generated_gif)\",\n \"def myapp():\\n image = random_image()\\n return send_file(image, mimetype='image/png')\",\n \"def randomize_pixels(image):\\n shape_ = image.size()\\n image_flat = image.view(-1, image.size(-1))\\n shuffled_image = shuffle(image_flat)\\n return shuffled_image.view(shape_)\",\n \"def generate_and_save_images(model, epoch, test_input):\\n #Training is set to false\\n #so all layers run in inference mode (batchnorm)(?)\\n predictions = model(test_input, training=False)\\n fig = plt.figure(figsize=(4,4))\\n for i in range(predictions.shape[0]):\\n plt.subplot(4,4, i+1)\\n img = tf.constant(predictions[i]) #Turn prediction into tf.constant\\n #so it can easily be transformed int a uint8 array\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n plt.imshow(img)#Show the images in color\\n plt.axis(\\\"off\\\")\\n #for()\\n\\n #update epoch_total or create a new tracker\\n if os.path.exists(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\")):\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"r\\\")\\n epoch = int(f.readline()) + 1\\n print(\\\"Total Epochs:{}\\\".format(epoch))\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"w\\\")\\n f.write(str(epoch))\\n #if()\\n else:\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"w\\\")\\n f.write(str(epoch))\\n #else()\\n f.close()\\n\\n plt.savefig(\\\"outputPhotosColor/image_at_epoch_{:04d}.png\\\".format(epoch)) #save image\\n #plt.show() # Turn on to show each new image after it's made\\n plt.close()\",\n \"def imwrite(image, path):\\n return scipy.misc.imsave(path, to_range(image, 0, 255, np.uint8))\",\n \"def testQuestionFour(self):\\n self.assertTrue(os.path.exists(\\\"./mandelbrot.png\\\"), \\\"Question 4's output (mandelbrot.png) does not exist.\\\")\",\n \"def save_output_image_to_directory(self):\\n curr_directory = os.path.dirname(os.path.abspath(__file__))\\n images_dir = curr_directory + \\\"/images/\\\"\\n if not os.path.exists(images_dir):\\n os.makedirs(images_dir)\\n self.output_image_name = md5(str(uuid4()).encode()).hexdigest() + \\\".png\\\"\\n image_file_name = images_dir + self.output_image_name\\n self.output_image.save(image_file_name)\\n logger.info(\\\"Image file saved locally : %s\\\", image_file_name)\",\n \"def save_images(filepath, ground_truth, noisy_image=None, clean_image=None):\\n # assert the pixel value range is 0-255\\n ground_truth = np.squeeze(ground_truth)\\n noisy_image = np.squeeze(noisy_image)\\n clean_image = np.squeeze(clean_image)\\n if not clean_image.any():\\n cat_image = ground_truth\\n else:\\n cat_image = np.concatenate([ground_truth, noisy_image, clean_image], axis=1)\\n im = Image.fromarray(cat_image.astype('uint8')).convert('L')\\n im.save(filepath, 'png')\",\n \"def random_image():\\n\\n # select random photo from sample table\\n result = db.engine.execute(\\\"\\\"\\\"SELECT photo_id\\n FROM sample\\n ORDER BY rand() LIMIT 1\\\"\\\"\\\")\\n photo_id = result.first()[0]\\n\\n # extract classification vector from database\\n class_columns = \\\",\\\".join(\\\"Label{}\\\".format(i) for i in range(num_labels))\\n result = db.engine.execute(\\\"\\\"\\\"SELECT yfcc.download_url, {}\\n FROM placesCNN INNER JOIN yfcc\\n ON placesCNN.photo_id = yfcc.photo_id\\n WHERE yfcc.photo_id = {}\\\"\\\"\\\".format(class_columns,\\n photo_id))\\n\\n row = result.first()\\n download_url = row[0]\\n classification = np.array(row[1:])\\n\\n return {\\\"suggested_tags\\\": predicted_tags(classification),\\n \\\"classification_vector\\\": classification,\\n \\\"image_url\\\": download_url}\",\n \"def test_draw(self):\\n image_name = filename(sys._getframe().f_code.co_name)\\n result_file, reference_file = get_path(image_name)\\n\\n ''' This function is to create an empty image with a specific dimension\\n with white background, and black/white colored '''\\n\\n image, canvas = get_image('L', (15,90),'white')\\n\\n for i in range(len(draw_points) - 1):\\n draw(canvas, (draw_points[i + 0], draw_points[i + 1]), 'A')\\n\\n \\\"\\\"\\\" saving the file and closing it \\\"\\\"\\\"\\n\\n image.save(result_file)\\n image.close()\\n\\n \\\"\\\"\\\" validate the resultant file against the reference images\\\"\\\"\\\"\\n\\n validate(reference_file, result_file)\",\n \"def sample_images(self, epoch):\\n synth_data = self.generator(self.constNoise)\\n utils.vector_to_img(synth_data, \\\"./outputs/trial{}/gan{}/epoch{}.jpg\\\".format(self.trial, self.id, epoch))\",\n \"def save_samples(iteration, fixed_Y, fixed_X, G_YtoX, G_XtoY, batch_size=16, sample_dir='samples_cyclegan'):\\n # move input data to correct device\\n device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n fake_X = G_YtoX(fixed_Y.to(device))\\n fake_Y = G_XtoY(fixed_X.to(device))\\n \\n X, fake_X = to_data(fixed_X), to_data(fake_X)\\n Y, fake_Y = to_data(fixed_Y), to_data(fake_Y)\\n \\n merged = merge_images(X, fake_Y, batch_size)\\n path = os.path.join(sample_dir, 'sample-{:06d}-X-Y.png'.format(iteration))\\n scipy.misc.imsave(path, merged)\\n print('Saved {}'.format(path))\\n \\n merged = merge_images(Y, fake_X, batch_size)\\n path = os.path.join(sample_dir, 'sample-{:06d}-Y-X.png'.format(iteration))\\n scipy.misc.imsave(path, merged)\\n print('Saved {}'.format(path))\",\n \"def generate_images(generator_model, output_dir, epoch, n_class, batch_size=128):\\n label = np.random.randint(0, n_class, size=(batch_size, 1))\\n label = np_utils.to_categorical(label, num_classes=n_class)\\n test_image_stack = generator_model.predict([np.random.rand(10, 100), label])\\n test_image_stack = (test_image_stack * 127.5) + 127.5\\n test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\\n tiled_output = tile_images(test_image_stack)\\n tiled_output = Image.fromarray(tiled_output, mode='L') # L specifies greyscale\\n outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\\n tiled_output.save(outfile)\",\n \"def generate_random_testing(file_name, nb_points):\\n file_name = _format_file_extension(file_name)\\n acoustic_data = _generate_random_acoustic(nb_points)\\n data = pd.DataFrame(acoustic_data, columns=[fmd.COLUMN_NAME[0]])\\n data.to_csv(file_name, index=False)\",\n \"def create_test_image(dirname, array, normalization=None):\\n filename = str(dirname / 'tmp.tif')\\n create_test_file(filename, array)\\n satellite = 'quickbird'\\n image = Image(filename, satellite, normalization_parameters=normalization)\\n return image\",\n \"def save_result(save_path, npyfile):\\n for i, item in enumerate(npyfile):\\n img = item[:, :, 0]\\n io.imsave(os.path.join(save_path, '%d_pred.png' % i), img)\",\n \"def save_groudtruth(im, coords, filename):\\n print 'Saving ground truth ......{0}'.format(filename)\\n img_draw = Image.fromarray(cv2.cvtColor(im, cv2.COLOR_BGR2RGB))\\n draw = ImageDraw.Draw(img_draw)\\n for coord in coords:\\n draw.polygon([(float(coord[0]), float(coord[1])), (float(coord[2]), float(coord[3])),\\n (float(coord[4]), float(coord[5])), (float(coord[6]), float(coord[7]))],\\n outline=\\\"red\\\", fill=\\\"blue\\\")\\n img_draw = np.array(img_draw)\\n img_draw = cv2.cvtColor(img_draw, cv2.COLOR_RGB2BGR)\\n bname_excludepoint = filename.split('/')[-1].split('.')[0]\\n image_path = '/home/yuquanjie/Documents/deep-direct-regression/result/' + bname_excludepoint + '_gt.jpg'\\n cv2.imwrite(image_path, img_draw[0: img_draw.shape[0], 0: img_draw.shape[1]])\",\n \"def new_func():\\n dirname, _ = os.path.split(os.path.abspath(__file__))\\n pngfile = os.path.sep.join([dirname, \\\"out.png\\\"])\\n img = [\\\"110010010011\\\", \\\"101011010100\\\", \\\"110010110101\\\", \\\"100010010011\\\"]\\n img = [[int(val) for val in value] for value in img]\\n writer = png.Writer(len(img[0]), len(img), greyscale=True, bitdepth=16)\\n with open(pngfile, \\\"wb\\\") as file:\\n writer.write(file, img)\\n try:\\n func(pngfile)\\n finally:\\n os.remove(pngfile)\",\n \"def save_image(name, image):\\n image_name = 'output/' + name + '.png'\\n cv2.imwrite(image_name, image)\",\n \"def write_image_to_file_incrementally(image):\\r\\n i = 0\\r\\n while os.path.exists(\\\"sample%s.jpeg\\\" % i):\\r\\n i += 1\\r\\n with open(\\\"sample%s.jpeg\\\" % i, \\\"wb\\\") as f:\\r\\n f.write(image)\",\n \"def generate_images(self, count):\\n # Generate images from the currently loaded model\\n noise = np.random.normal(0, 1, (count, self.dimensions_noise))\\n return self.generator.predict(noise)\",\n \"def genImage(self, img_num=1, mode=\\\"stabilization\\\"):\\n self.Gmodel.eval()\\n with torch.no_grad():\\n for i in range(img_num):\\n latent_z = torch.randn(1, 512, 1, 1).normal_().to(self.device)\\n output = self.Gmodel(latent_z, mode)\\n print(\\\"output size: \\\", output.size())\\n output = torch.clamp(output, min=0, max=1)\\n output = output.cpu().squeeze().numpy()\\n fake_img = output.transpose(1, 2, 0)\\n print(\\\"fake image size: \\\", fake_img.shape)\\n plt.imshow(fake_img)\\n plt.show()\\n save_file = os.path.join(self.save_dir, str(self.load_resl), \\\"%05d.jpg\\\" % i)\\n os.makedirs(os.path.dirname(save_file), exist_ok=True)\\n plt.imsave(save_file, fake_img)\",\n \"def setUp(self):\\n self.image = np.random.randint(\\n 0, 256, size=(10, 10, 3)).astype('uint8')\",\n \"def get_test_image(storage):\\n # Generate unique name.\\n storage_name = 'test-{}.png'.format(uuid.uuid4())\\n\\n # Create image.\\n image_file = Image.new('RGBA', size=(50, 50), color=(255, 0, 0))\\n ImageDraw.Draw(image_file)\\n storage_file = storage.open(storage_name, 'wb')\\n image_file.save(storage_file, 'png')\\n\\n # Yield storage name.\\n yield storage_name\\n\\n # Delete thumbnails, if they exist.\\n if hasattr(settings, 'THUMBNAIL_BASEDIR'):\\n THUMBNAIL_ROOT = os.path.join(\\n settings.MEDIA_ROOT,\\n settings.THUMBNAIL_BASEDIR,\\n )\\n thumbs = glob.glob(os.path.join(THUMBNAIL_ROOT, storage_name + '*'))\\n for filename in thumbs:\\n os.unlink(filename)\\n # Delete empty thumbnail directories.\\n try:\\n os.removedirs(THUMBNAIL_ROOT)\\n except OSError:\\n pass\\n\\n # Delete image.\\n storage.delete(storage_name)\",\n \"def save_samples(data_loader, generator_1, epoch, path):\\n A2B = np.zeros((config.crop_size * 3, 0, 3))\\n\\n with torch.no_grad():\\n for i in range(config.val_batch_size):\\n\\n # Prepare Data #\\n real_A = next(iter(data_loader))\\n real_A = real_A.to(device)\\n\\n # Generate Fake Images #\\n fake_B, _, fake_B_heatmap = generator_1(real_A)\\n\\n A2B = np.concatenate((A2B, np.concatenate((RGB2BGR(tensor2npy(denorm(real_A[0]))),\\n cam(tensor2npy(fake_B_heatmap[0]), config.crop_size),\\n RGB2BGR(tensor2npy(denorm(fake_B[0])))), 0)), 1)\\n\\n cv2.imwrite(os.path.join(path, 'U-GAT-IT_Samples_Epoch_%03d.png' % (epoch + 1)), A2B * 255.0)\",\n \"def create_test_set(self):\\n test_files = os.listdir(self.image_folder_path)\\n test_files = sorted_alphanumeric(test_files)\\n delete_files(self.root_name, \\\"/VOC2021/ImageSets/Main\\\")\\n write_txt(\\\"test.txt\\\", self.txt_path, test_files)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7916328","0.73138684","0.7276964","0.72279763","0.6833925","0.67390573","0.6636539","0.6577365","0.6552666","0.654833","0.6493901","0.64547956","0.6446572","0.6445794","0.6444757","0.6440958","0.6415097","0.6344109","0.63346565","0.6326465","0.6290015","0.6278635","0.6267804","0.6240479","0.6235593","0.6222436","0.6220511","0.61738044","0.6167884","0.6161419","0.6159171","0.6157093","0.6156299","0.6149048","0.6103624","0.6097065","0.6046408","0.6022792","0.6016005","0.6001976","0.5990448","0.5963058","0.5957612","0.5943266","0.594238","0.5938127","0.5930167","0.59244144","0.5918954","0.5913499","0.5895454","0.5890579","0.5886731","0.5885948","0.58747905","0.5863215","0.58613765","0.5855789","0.584744","0.5846822","0.58365864","0.5835732","0.5832484","0.58148026","0.5810969","0.5803655","0.5801578","0.579261","0.5792525","0.5791954","0.5790601","0.57866234","0.57788676","0.57738566","0.5767609","0.57447785","0.57445955","0.57226074","0.5716848","0.571678","0.5710271","0.5707322","0.57021594","0.57001173","0.56923103","0.5689523","0.56829715","0.56822044","0.5658535","0.56546605","0.5654049","0.56531787","0.56418645","0.5640286","0.563805","0.56317425","0.56288743","0.56263"],"string":"[\n \"0.7916328\",\n \"0.73138684\",\n \"0.7276964\",\n \"0.72279763\",\n \"0.6833925\",\n \"0.67390573\",\n \"0.6636539\",\n \"0.6577365\",\n \"0.6552666\",\n \"0.654833\",\n \"0.6493901\",\n \"0.64547956\",\n \"0.6446572\",\n \"0.6445794\",\n \"0.6444757\",\n \"0.6440958\",\n \"0.6415097\",\n \"0.6344109\",\n \"0.63346565\",\n \"0.6326465\",\n \"0.6290015\",\n \"0.6278635\",\n \"0.6267804\",\n \"0.6240479\",\n \"0.6235593\",\n \"0.6222436\",\n \"0.6220511\",\n \"0.61738044\",\n \"0.6167884\",\n \"0.6161419\",\n \"0.6159171\",\n \"0.6157093\",\n \"0.6156299\",\n \"0.6149048\",\n \"0.6103624\",\n \"0.6097065\",\n \"0.6046408\",\n \"0.6022792\",\n \"0.6016005\",\n \"0.6001976\",\n \"0.5990448\",\n \"0.5963058\",\n \"0.5957612\",\n \"0.5943266\",\n \"0.594238\",\n \"0.5938127\",\n \"0.5930167\",\n \"0.59244144\",\n \"0.5918954\",\n \"0.5913499\",\n \"0.5895454\",\n \"0.5890579\",\n \"0.5886731\",\n \"0.5885948\",\n \"0.58747905\",\n \"0.5863215\",\n \"0.58613765\",\n \"0.5855789\",\n \"0.584744\",\n \"0.5846822\",\n \"0.58365864\",\n \"0.5835732\",\n \"0.5832484\",\n \"0.58148026\",\n \"0.5810969\",\n \"0.5803655\",\n \"0.5801578\",\n \"0.579261\",\n \"0.5792525\",\n \"0.5791954\",\n \"0.5790601\",\n \"0.57866234\",\n \"0.57788676\",\n \"0.57738566\",\n \"0.5767609\",\n \"0.57447785\",\n \"0.57445955\",\n \"0.57226074\",\n \"0.5716848\",\n \"0.571678\",\n \"0.5710271\",\n \"0.5707322\",\n \"0.57021594\",\n \"0.57001173\",\n \"0.56923103\",\n \"0.5689523\",\n \"0.56829715\",\n \"0.56822044\",\n \"0.5658535\",\n \"0.56546605\",\n \"0.5654049\",\n \"0.56531787\",\n \"0.56418645\",\n \"0.5640286\",\n \"0.563805\",\n \"0.56317425\",\n \"0.56288743\",\n \"0.56263\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7180069"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":93699,"cells":{"query":{"kind":"string","value":"Generate computational art and save as an image file."},"document":{"kind":"string","value":"def generate_art(filename, x_size=1920, y_size=1080):\n # Functions for red, green, and blue channels - where the magic happens!\n red_function = build_random_function(7,8)\n green_function = build_random_function(4,6)\n blue_function = build_random_function(3,5)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n\n im.save(filename)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def generate_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(6, 10)\n g_lb = random.randint(6, 10)\n b_lb = random.randint(6, 10)\n red_function = build_random_function(r_lb, r_lb+1)\n green_function = build_random_function(g_lb, g_lb+1)\n blue_function = build_random_function(b_lb, b_lb+1)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n im.save(filename+'.png')\n return 'saved'","def create_artificial_image(self):\n background = self.BGI.create_background_image()\n star_PSF = self.PSF.create_star_PSF()\n header = self.HDR.create_header()\n\n fits.writeto(self.image_dir + self.image_name + '.fits',\n background + star_PSF, overwrite=True, header=header)","def generate_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n \n red_function = build_random_function(7,15)\n green_function = build_random_function(7,15)\n blue_function = build_random_function(7,15)\n \n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(evaluate_random_function(red_function, x, y)),\n color_map(evaluate_random_function(green_function, x, y)),\n color_map(evaluate_random_function(blue_function, x, y))\n )\n\n im.save(filename)","def save(self):\n\n self.image.save(\"./output/\" + self.name + \" pg\" + str(self._page) + \".png\")","def save(self):\n img = Image.new(\"1\", (self.container.width, self.container.height))\n draw = ImageDraw.Draw(img)\n for item in self.items:\n draw.ellipse(item.box_coordinates(), fill=1)\n del draw\n img.save(\"plot.bmp\", \"bmp\")","def generate_image(self):\n pass","def save_plot_as_image(self):\r\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\r\n bbox_inches='tight')","def write_file(self):\n if self.it_num % 5 == 0:\n #plt.imshow(self.grid)\n #plt.savefig(\"output%.4d.png\" % self.it_num, bbox_inches='tight')\n io.savemat(\"MLOutput%.4d\" % self.it_num, { \"Grid\":self.grid})","def generate_art_3(filename, x_size=350, y_size=350, t_size=30):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(1, 5)\n g_lb = random.randint(1, 10)\n b_lb = random.randint(1, 5)\n red_function = build_random_function_3(r_lb, r_lb+1)\n green_function = build_random_function_3(g_lb, g_lb+1)\n blue_function = build_random_function_3(b_lb, b_lb+1)\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for time in range(t_size):\n for i in range(x_size):\n for j in range(y_size):\n t = remap_interval(time, 0, t_size, -1, 1)\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(eval_r_func_3(red_function, x, y, t)),\n color_map(eval_r_func_3(green_function, x, y, t)),\n color_map(eval_r_func_3(blue_function, x, y, t))\n )\n str_num = '0' * (5 - len(str(time))) + str(time)\n print(str_num)\n im.save(filename + str_num + '.png')\n return 'saved'","def save_images(self):\n for q in range(self.N_itr):\n plt.clf()\n self.plot_EM_estimate(q)\n plt.savefig('img%d.png' % (100 + q))","def run(self):\n generated_gif = self.generate()\n with open(self.out_filename, 'wb') as out_fd:\n out_fd.write(generated_gif)","def save_augmentation_visual(lines, output_dir):\n\n # Ensure output directory exists\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n save_name = 'data_augmentation.png'\n idx = np.random.randint(0, len(lines))\n image = ndimage.imread(lines[idx][0])\n angle = lines[idx][1]\n fig = visualize_augmentation(image, angle)\n fig.savefig(output_dir + save_name, bbox_inches='tight')","def graphical_output(self, block=False, save=False, display=True, folder_name='output', image_suffix=None):\n masks = [np.where(self.board == i, True, False) for i in range(self.number_of_colors)]\n output = np.zeros((self.height, self.width, 3), dtype=np.int)\n for mask, color in zip(masks, list(COLORS.values())[:self.number_of_colors]):\n output[mask] = color\n\n image = np.repeat(np.repeat(output, 10, axis=0), 10, axis=1)/255.0\n if save:\n plt.imsave(f'{folder_name}/image{image_suffix}.png', image)\n\n if display:\n plt.imshow(image)\n plt.show(block=block)\n\n return image","def save_reconstructed_images(self, filename, rows, cols):\n # print(filename)\n num_images = self.reconstructed.shape[0]\n images = np.zeros((rows, cols*num_images))\n for i in range(num_images):\n start = int(i * cols)\n end = int((i+1) * cols)\n images[0:rows, start:end] = self.reconstructed[i].reshape((rows, cols))\n\n plt.imshow(images, cmap='gray', aspect='equal', interpolation='none')\n #plt.show()\n plt.savefig(filename)\n return","def make_image(self, frame, filename, **kwds):\n p = plot.plot(frame, **kwds)\n p.save_image(filename)","def gen_art(complexity=7, num_frames=1, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n\n red_function = bld_func(complexity, complexity+2)\n green_function = bld_func(complexity, complexity+2)\n blue_function = bld_func(complexity, complexity+2)\n\n\n # Create image and loop over all pixels\n for t in range(0, num_frames+1):\n print \"Generating frame %d ... Please be patient.\" % t\n t_val = (t-(num_frames/2.0))/(num_frames/2.0)\n\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap(i, 0, x_size, -1, 1)\n y = remap(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n c_map(eval_func(red_function, x, y, t_val)),\n c_map(eval_func(green_function, x, y, t_val)),\n c_map(eval_func(blue_function, x, y, t_val))\n )\n \n im.save('frame%d.png' % t)","def setup():\n img = Image.new('RGB', (10, 20))\n img.putpixel((5, 10), (0, 255, 0))\n img.save('green-dot.tif')\n img.save('green-dot.jpg')\n img.save('green-dot.png')","def generate_and_save_images(model, seed, output_path, title):\n\n predictions = model(tf.Variable(seed, trainable=False))\n\n fig = plt.figure(figsize=(4,4))\n\n for i in range(predictions.shape[0]):\n plt.subplot(4, 4, i+1)\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\n plt.axis('off')\n if not os.path.exists(output_path):\n os.mkdir(output_path)\n\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\n plt.close()","def save(self, assignment, filename):\n from PIL import Image, ImageDraw, ImageFont\n cell_size = 100\n cell_border = 2\n interior_size = cell_size - 2 * cell_border\n letters = self.letter_grid(assignment)\n\n # Create a blank canvas\n img = Image.new(\n \"RGBA\",\n (self.crossword.width * cell_size,\n self.crossword.height * cell_size),\n \"black\"\n )\n font = ImageFont.truetype(\"assets/fonts/OpenSans-Regular.ttf\", 80)\n draw = ImageDraw.Draw(img)\n\n for i in range(self.crossword.height):\n for j in range(self.crossword.width):\n\n rect = [\n (j * cell_size + cell_border,\n i * cell_size + cell_border),\n ((j + 1) * cell_size - cell_border,\n (i + 1) * cell_size - cell_border)\n ]\n if self.crossword.structure[i][j]:\n draw.rectangle(rect, fill=\"white\")\n if letters[i][j]:\n w, h = draw.textsize(letters[i][j], font=font)\n draw.text(\n (rect[0][0] + ((interior_size - w) / 2),\n rect[0][1] + ((interior_size - h) / 2) - 10),\n letters[i][j], fill=\"black\", font=font\n )\n\n img.save(filename)","def save(self, assignment, filename):\n from PIL import Image, ImageDraw, ImageFont\n cell_size = 100\n cell_border = 2\n interior_size = cell_size - 2 * cell_border\n letters = self.letter_grid(assignment)\n\n # Create a blank canvas\n img = Image.new(\n \"RGBA\",\n (self.crossword.width * cell_size,\n self.crossword.height * cell_size),\n \"black\"\n )\n font = ImageFont.truetype(\"assets/fonts/OpenSans-Regular.ttf\", 80)\n draw = ImageDraw.Draw(img)\n\n for i in range(self.crossword.height):\n for j in range(self.crossword.width):\n\n rect = [\n (j * cell_size + cell_border,\n i * cell_size + cell_border),\n ((j + 1) * cell_size - cell_border,\n (i + 1) * cell_size - cell_border)\n ]\n if self.crossword.structure[i][j]:\n draw.rectangle(rect, fill=\"white\")\n if letters[i][j]:\n w, h = draw.textsize(letters[i][j], font=font)\n draw.text(\n (rect[0][0] + ((interior_size - w) / 2),\n rect[0][1] + ((interior_size - h) / 2) - 10),\n letters[i][j], fill=\"black\", font=font\n )\n\n img.save(filename)","def save(self, assignment, filename):\n from PIL import Image, ImageDraw, ImageFont\n cell_size = 100\n cell_border = 2\n interior_size = cell_size - 2 * cell_border\n letters = self.letter_grid(assignment)\n\n # Create a blank canvas\n img = Image.new(\n \"RGBA\",\n (self.crossword.width * cell_size,\n self.crossword.height * cell_size),\n \"black\"\n )\n font = ImageFont.truetype(\"assets/fonts/OpenSans-Regular.ttf\", 80)\n draw = ImageDraw.Draw(img)\n\n for i in range(self.crossword.height):\n for j in range(self.crossword.width):\n\n rect = [\n (j * cell_size + cell_border,\n i * cell_size + cell_border),\n ((j + 1) * cell_size - cell_border,\n (i + 1) * cell_size - cell_border)\n ]\n if self.crossword.structure[i][j]:\n draw.rectangle(rect, fill=\"white\")\n if letters[i][j]:\n w, h = draw.textsize(letters[i][j], font=font)\n draw.text(\n (rect[0][0] + ((interior_size - w) / 2),\n rect[0][1] + ((interior_size - h) / 2) - 10),\n letters[i][j], fill=\"black\", font=font\n )\n\n img.save(filename)","def writeImage(image, filename):\n Sky = [128,128,128]\n Building = [128,0,0]\n Pole = [192,192,128]\n Road_marking = [255,69,0]\n Road = [128,64,128]\n Pavement = [60,40,222]\n Tree = [128,128,0]\n SignSymbol = [192,128,128]\n Fence = [64,64,128]\n Car = [64,0,128]\n Pedestrian = [64,64,0]\n Bicyclist = [0,128,192]\n Unlabelled = [0,0,0]\n r = image.copy()\n g = image.copy()\n b = image.copy()\n label_colours = np.array([Sky, Building, Pole, Road_marking, Road, Pavement, Tree, SignSymbol, Fence, Car, Pedestrian, Bicyclist, Unlabelled])\n for l in range(0,12):\n r[image==l] = label_colours[l,0]\n g[image==l] = label_colours[l,1]\n b[image==l] = label_colours[l,2]\n rgb = np.zeros((image.shape[0], image.shape[1], 3))\n rgb[:,:,0] = r/1.0\n rgb[:,:,1] = g/1.0\n rgb[:,:,2] = b/1.0\n im = Image.fromarray(np.uint8(rgb))\n # im.save('/Users/koheiyamamoto/Desktop/SegNet/out/' + filename)\n im.save('./out/' + filename)","def save():\n pl.savefig('/home/filippini/Documents/plot/RUN55/compa'+INFO_RUN+'.png')","def make_image(self, save=False):\n\n # image_grid = np.full((self.size_x, self.size_y), '#888888', dtype=str)\n image_grid = np.full((self.size_x, self.size_y, 3), 0, dtype=np.uint8)\n\n # self.grid = np.flip(self.grid, 1)\n\n # self.grid = np.swapaxes(self.grid, 0, 0)\n \"\"\"\n image_grid[self.grid == 0] = 'FFFFFF'\n image_grid[self.grid == 1] = '000000'\n image_grid[self.grid == 2] = '00FF00'\n image_grid[self.grid == 3] = '0000FF'\n image_grid[self.grid == 4] = 'FFFF00'\n image_grid[self.grid == 5] = '00FFFF'\n image_grid[self.grid == 6] = 'FF00FF'\n \"\"\"\n image_grid[self.grid == 0] = (1, 1, 1)\n image_grid[self.grid == 1] = (0, 0, 0)\n image_grid[self.grid == 2] = (1, 0, 1)\n image_grid[self.grid == 3] = (0, 1, 0)\n image_grid[self.grid == 4] = (0, 0, 1)\n image_grid[self.grid == 5] = (0, 1, 1)\n image_grid[self.grid == 6] = (1, 1, 0)\n\n #for ant in self.ants:\n # image_grid[ant.x, ant.y] = (1, 0, 0)\n\n # image_grid = image_grid.swapaxes(0, 1)\n # self.grid = self.grid.swapaxes(0, 1)\n\n\n\n DPI = 100\n width, height = 1000, 1000\n fig = plt.figure(figsize=(width / DPI, height / DPI), dpi=DPI, facecolor='k')\n ax = fig.add_subplot()\n\n plt.axis('equal')\n plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)\n\n for y in range(self.size_x):\n for x in range(self.size_y):\n if self.grid[x, y] != 0:\n # Only plot a hexagon if its state is not zero.\n plot_hex(ax, x, y, image_grid[x, y])\n\n ax.set_xlim(0, self.size_x)\n ax.set_ylim(0, self.size_y)\n\n plt.show()\n\n logging.info(\"Finished Image Processing\")","def save_image(self):\r\n filename = filedialog.asksaveasfilename(title='Save Image As...',\r\n filetypes=((\"Portable Network Graphics (.png)\", \"*.png\"), (\"Portable Document Format(.pdf)\", \"*.pdf\")))\r\n self.graph.savefig(filename, dpi=self.graph.dpi)","def render(filename,i):\n print('running render')\n A = np.genfromtxt(filename,skip_header=1,dtype=float,delimiter=',')\n img = np.array(A[i,:],copy=True)\n print(img.shape)\n img = img.reshape(28,28)\n img = 255 - img\n print(img.shape)\n plt.imshow(img, cmap=\"gray\", vmin=0, vmax=255)\n plt.savefig(\"img\" + str(i)+\"render\"+ \".png\")","def _repr_png_(self):\n mol = self.owner.mol\n keku = IPythonConsole.kekulizeStructures\n size = IPythonConsole.molSize\n opts = IPythonConsole.drawOptions\n return Draw._moltoimg(\n mol, size, self.aix, \"\", returnPNG=True, drawOptions=opts,\n kekulize=keku, highlightBonds=self.bix\n )","def _repr_png_(self):\n mol = self.owner.mol\n keku = IPythonConsole.kekulizeStructures\n size = IPythonConsole.molSize\n opts = IPythonConsole.drawOptions\n return Draw._moltoimg(\n mol, size, self.aix, \"\", returnPNG=True, drawOptions=opts,\n kekulize=keku, highlightBonds=self.bix\n )","def write_image(path, tokens, weights):\n\n f = render_attn_inner(tokens, weights)\n f.savefig(path, bbox_inches=\"tight\", frameon=False)\n plt.close(f)","def save_plot(self):\r\n\t\t# Generate the plot\r\n\t\tself.generate_plot()\r\n\t\t# Create save directory\r\n\t\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\r\n\t\tif not path_exists(directory):\r\n\t\t\tmakedirs(directory)\r\n\t\t# Save image file\r\n\t\tself.fig.savefig(directory+str(self.universe.time))","def main(image_path):\n temp_dir = tempfile.mkdtemp()\n print('Saving output to {}'.format(temp_dir))\n estimator = run_image(image_path)\n visualize(estimator, image_path, temp_dir)","def saveImage(self, fileName=\"mandelbrot.frac\"):\n # Save the image as a PNG\n if fileName == \"\":\n fileName = \"mandelbrot.frac\"\n directories = fileName.split(\"/\")\n for n in directories:\n if \".frac\" in n:\n name = n.rsplit(\".\", 1)[0]\n self.img.write(f\"{name}.png\")\n print(f\"Wrote image {name}.png\")","def saveImage(turtle, filename):\n ts = turtle.getscreen()\n tc = ts.getcanvas()\n tc.postscript(file=filename)","def drawOutput():\n global lastPlayedCoordinates\n notes = notes_text.get(\"1.0\", \"end-1c\")\n\n tempDir = \".bt_temp\"\n\n # Create the directory only if it does not exist\n try:\n os.makedirs(tempDir)\n except FileExistsError:\n pass\n\n tempNotesFile = tempDir + \"/currentNotes.btu\"\n tempNewBTI = tempDir + \"/generatedNotes.bti\"\n\n with open(tempNotesFile, 'w') as f:\n f.write(str(notes))\n\n BitTuneDrawingLanguage.generateBitTuneImageFromFile(tempNotesFile,tempNewBTI)\n clearCanvas()\n\n loadFromFile(tempNewBTI)\n os.remove(tempNewBTI)\n os.remove(tempNotesFile)\n lastPlayedCoordinates = []","def cb_save(event):\n fig.savefig('sample.univariate_discrete.py.png', dpi=300, format='png', transparent=True)","def save(file_name):\n setup()\n plt.savefig(file_name)","def print_image(indiv,name):\n routine = gp.compile(indiv,pset)\n output = gen_beat_output(routine)\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\n plt.style.use('classic')\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\n plt.savefig(name+\".png\",dpi=150)","def generateImage(self):\n self.image = self.font.render(self.text, True, self.color)\n self.rect = self.image.get_rect()\n self.rect.center = self.xy","def save_particles_image(self):\n base_filename = self.config['info']['filename_microscope']\n self.save_image_microscope_camera(base_filename)","def make_art(functions, filename, lambdas, x_size=def_x_size, y_size=def_y_size):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (color_map(evaluate_random_function(functions[0], x, y, lambdas)),\n color_map(evaluate_random_function(functions[1], x, y, lambdas)),\n color_map(evaluate_random_function(functions[2], x, y, lambdas)))\n im.save(filename+\".png\")","def save_image(self, image_file):\r\n self.ensure_pyplot()\r\n command = 'plt.gcf().savefig(\"%s\")'%image_file\r\n #print 'SAVEFIG', command # dbg\r\n self.process_input_line('bookmark ipy_thisdir', store_history=False)\r\n self.process_input_line('cd -b ipy_savedir', store_history=False)\r\n self.process_input_line(command, store_history=False)\r\n self.process_input_line('cd -b ipy_thisdir', store_history=False)\r\n self.process_input_line('bookmark -d ipy_thisdir', store_history=False)\r\n self.clear_cout()","def draw_image(self):\n \n pixel_array = self.imageprepare(self.image_path)\n newArr = self.reshape_pixel_array(pixel_array)\n plt.imshow(newArr, interpolation='nearest')\n plt.savefig('MNIST_IMAGE.png')#save MNIST image\n plt.show()#Show / plot that image","def generate_art(filename=def_art_name, min_depth=def_min_depth, max_depth=def_max_depth,\n x_size=def_x_size, y_size=def_y_size, write_funcs=def_save, func_filename=def_func_name):\n # Functions for red, green, and blue channels - where the magic happens!\n name_funcs = []\n lam_funcs = []\n for i in range(3):\n functions = build_random_function(min_depth, max_depth)\n name_funcs.append(functions[0])\n lam_funcs.append(functions[1])\n\n # generate art always uses lambdas because they are faster, while regenerate\n # art requrires use of nested lists, leading to this fixed 'True' value to specify\n make_art(lam_funcs, filename, True, x_size, y_size)\n write_func(name_funcs, func_filename)","def __generate_image(self):\n\t\tself.img = np.ones((self.size*self.width+self.border,self.size*self.width+self.border,1), np.uint8)*255\n\t\tfor i in range(len(self.matrix)):\n\t\t\tfor j in range(len(self.matrix)):\n\t\t\t\tif self.matrix[j][i] == 1:\n\t\t\t\t\tself.img = cv2.rectangle(self.img,(i*self.width+int(self.border/2),j*self.width+int(self.border/2))\n\t\t\t\t\t\t,(i*self.width+self.width+int(self.border/2),j*self.width+self.width+int(self.border/2)),(0,0,0),-1)\n\t\tif '.' in self.name:\n\t\t\tcv2.imwrite(self.name,self.img)\n\t\telse:\n\t\t\tcv2.imwrite(self.name+'.jpg',self.img)\n\t\tcv2.imshow(\"Image\",self.img)\n\t\tcv2.waitKey(0)\n\t\tcv2.destroyAllWindows()","def draw(self):\n self.write_image()\n self.update()","def OnBuildPNGs(self, e):\n if (not defaults.use_tex):\n msg = \"LaTeX is disabled in the defaults.py file. To use this functionality, change the\"\n msg += \" use_tex option to True and restart the GUI.\"\n ShowMessage(msg, kind='warn')\n return\n question = \"Quantity code formulas are displayed using PNG images, which need to be generated.\"\n question += \"\\n\\n\\nImages should only be generated if they do not already exist or\"\n question += \" the quantity codes have changed, e.g., more custom outputs have been added.\"\n question += \"\\n\\n\\nThis can take ~60 sec, do you want to proceed?\"\n proceed = AskYesNo(question, title='Generate LaTeX Formula Images?')\n if (not proceed): return\n\n question = \"Choose a path where the images will be saved. The default value from defaults.py is shown.\"\n path = AskText(question, default=defaults.quantity_code_image_path, title=\"Where to store images?\")\n if (path is None): return\n defaults.quantity_code_image_path = path # user overrode this quantity, remember for later\n\n question = \"If image files already exist, do you want to overwrite them?\"\n overwrite = AskYesNo(question, title='Overwrite Existing Files?')\n\n # call render routine and display a progress bar\n Nq = len(self.mainparent.nmlpanel.output_quantities.quantities)\n offsets = list(self.mainparent.nmlpanel.output_quantities.offsets.keys())\n\n P = ProgressBar(Nq)\n P(0)\n for i,Q in enumerate(self.mainparent.nmlpanel.output_quantities.quantities):\n if (Q.name in offsets): continue\n render_tex(Q.code, Q.tex, defaults.quantity_code_image_path, overwrite=overwrite)\n\n P(i+1) # update progress bar","def save_PPM(self, fileName, imageComment = \"\"):\n file = open(add_ext_if_needed(fileName, \"ppm\"), \"w\")\n file.write(\"P3\\n\"); \n file.write(\"# \" + imageComment + \"\\n\")\n file.write(str(self._image.width()) + \" \" + str(self._image.height()) + \"\\n\")\n file.write(\"255\\n\")\n for y in range(self._image.height()):\n for x in range(self._image.width()):\n r,g,b = self.getPixel(x,y);\n file.write(str(r) + \" \" + str(g) + \" \" + str(b) + \"\\n\")\n file.close()","def test_plot_images(self):\n save_file(self.quart.plot_images)","def make_image(self, imagename, fitsname, niter=500, antenna='', phasecenter='', start=200, stop=900, del_img=True, overwrite=False): \n self.generate_image(imagename, antenna=antenna, niter=niter, phasecenter=phasecenter, start=start, stop=stop)\n self.to_fits(imagename + '.image', fitsname, overwrite=overwrite)\n if del_img:\n self.remove_image(imagename, del_img=True)","def save(self, filename):\n print(\"Saving...\", end=\"\\r\")\n canvas = self.canvas[self.N:self.S,self.W:self.E]\n cv2.imwrite(\"./Output/\"+filename, canvas)\n print(\"Saved:\",filename)","def main():\n me = SimpleImage(\"images/me.JPG\")\n dinosaur = SimpleImage(\"images/dinosaur.jpg\")\n\n dinosaur.make_as_big_as(me)\n combine = magic(me, dinosaur)\n combine.show()","def make_image():\n click.echo(\"make_image\")","def create_png(image, label):\n sv = \"/home/avojtekova/Desktop/final_results/star_det/generated_images/\" \n \n for i in range(len(image)):\n data = fits.getdata(image[i][0], ext = 0)\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\n \n print(image[i][0])\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \n plt.title(label[i])\n plt.axis('off')\n plt.tight_layout()\n plt.legend\n if i<2:\n if not os.path.isdir(sv + image[i][0][-33:-25] + \"/\") :\n os.makedirs(sv + image[i][0][-33:-25] + \"/\")\n plt.savefig(sv + image[i][0][-33:-25] + \"/\" + label[i]+ \"_\" + image[i][0][-33:-25] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \n else:\n if not os.path.isdir(sv + image[i][0][-40:-32] + \"/\") :\n os.makedirs(sv + image[i][0][-40:-32] + \"/\")\n plt.savefig(sv + image[i][0][-40:-32] + \"/\" + label[i]+image[i][0][-40:-32] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\n plt.close()","def create_images(self):\n font = ImageFont.truetype(str(self.font_file), 45, encoding=\"utf-8\")\n for letter in self.hebrew.letter_li:\n (self.training_folder / letter).mkdir(parents=True, exist_ok=True)\n\n for i in range(len(self.hebrew.font_li)):\n letter_path = self.training_folder / Path(self.hebrew.letter_li[i])\n text = self.hebrew.font_li[i]\n text_width, text_height = font.getsize(text)\n canvas = Image.new(\"RGB\", (text_width + 15, text_height + 20), \"white\")\n draw = ImageDraw.Draw(canvas)\n draw.text((10, 10), text, \"black\", font)\n canvas.save(\n Path(letter_path / Path(f\"{self.hebrew.letter_li[i]}_original.jpeg\")),\n \"JPEG\",\n )","def createNew(string):\n image=Image.open('imageGenerator/images/images.jpg').convert('RGBA')\n\n fnt = ImageFont.truetype(\"fonts/arial.ttf\", 25)\n d = ImageDraw.Draw(image)\n\n d.text((10,10), string, font=fnt, fill=(255,255,255,128))\n\n d.text((10,60), \"World\", fill=(255,255,255,255))\n file=byt()\n image.save(file,'jpeg')\n return file.getvalue()","def create_output_image(building_footprint, parcel_footprint, file_path):\n fig, ax = plt.subplots(figsize=(10, 10))\n gpd.overlay(building_footprint, parcel_footprint, how=\"symmetric_difference\").plot(\n ax=ax, color=\"lightgray\"\n )\n parcel_footprint.geometry.exterior.buffer(0.25).plot(ax=ax, color=\"black\")\n building_footprint.plot(ax=ax, color=\"black\")\n\n ax.patch.set_facecolor(\"white\")\n ax.patch.set_edgecolor(\"white\")\n fig.patch.set_visible(False)\n ax.axis(\"off\")\n fig.savefig(\n file_path,\n bbox_inches=\"tight\",\n pad_inches=0,\n facecolor=\"white\",\n edgecolor=\"white\",\n quality=IMG_QUALITY,\n )\n plt.close()","def create_png_images(self):\n if self.subject is None:\n print Console.WARNING + 'You need to specify a subject first' + Console.ENDC\n return\n\n check_dir_of = self.locations.check_dir_of\n check_dir_of(self.locations.HISTO_PNG_U)\n check_dir_of(self.locations.HISTO_PNG)\n check_dir_of(self.locations.SOURCE_PNG)\n\n\n\n fmap_img = ImageUtils.load_nifti_image(self.locations.HIST_FMAP) #loading subject nifti files\n volumes = []\n try:\n for s in self.locations.SOURCES:\n volumes.append(ImageUtils.load_nifti_image(s))\n except IOError as e:\n print Console.FAIL + 'There are errors loading nifi files for subject %s'%self.subject + Console.ENDC\n return False\n \n\n num_slices = volumes[0].shape[2] #use first volume to check expected number of slices\n\n self.locations.create_empty_dir(self.locations.IMAGES_DIR)\n\n print 'Creating input PNGs for %s'%self.subject\n for k, vol in enumerate(volumes):\n for i in range(num_slices):\n imslice = ImageUtils.data_to_bytescale_rgb(vol[:, :, i])\n im = Image.fromarray(imslice)\n im.save(self.locations.SOURCE_PNG % (self.locations.LABELS[k],i))\n\n \n print 'Creating histology PNGs for %s'%self.subject\n for i in range(num_slices):\n\n im_unscaled = ImageUtils.data_to_unscaled_rgb(fmap_img[:, :, i]); #keeps the original values\n im_unscaled = Image.fromarray(im_unscaled)\n im_unscaled = im_unscaled.filter(ImageFilter.GaussianBlur(radius=2)) #Filter requested by Ali Khan\n im_unscaled.save(self.locations.HISTO_PNG_U % i)\n\n im_scaled = ImageUtils.data_to_bytescale_rgb(fmap_img[:,:,i]); # bytescaled histology\n im_scaled = Image.fromarray(im_scaled)\n im_scaled = im_scaled.filter(ImageFilter.GaussianBlur(radius=2)) #Filter requested by Ali Khan\n im_scaled.save(self.locations.HISTO_PNG % i)\n\n print\n return True","def save(self, x, y, names, path=\"\", zoom=False):\n for i in range(len(x)):\n image = self.generate(x[i], label=np.argmax(y[i]), zoom=zoom)\n image = Image.fromarray((image*255).astype(\"uint8\"))\n image.save(path + names[i] + \".png\", \"PNG\")","def render_and_save():\n\n rendering_config = configuration.get_config()\n rendering_config = ml_collections.FrozenConfigDict(rendering_config)\n aspect_ratio = rendering_config.aspect_ratio\n height = rendering_config.height\n width = int(aspect_ratio * height)\n\n scene_camera = build_camera(rendering_config, aspect_ratio)\n world = build_world(rendering_config)\n\n # Render.\n logging.info(\"Tracing rays...\")\n render_image_fn = jax.jit(\n render.generate_image,\n static_argnames=[\"height\", \"width\", \"config\"])\n image = render_image_fn(height, width, scene_camera, world, rendering_config)\n\n image = render.correct_gamma(image, gamma=rendering_config.gamma_correction)\n\n logging.info(\"Saving to file...\")\n output.export_as_ppm(image, rendering_config.output_file)\n\n return image","def drawImage(self):\n\n image = Image.new(\"RGB\",self.size,(255,255,255)) #new() passes parameters mode,size,color\n #255,255,255 is white\n\n canvas = ImageDraw.Draw(image)\n for g in self.genes:\n color = (g.color.r,g.color.g,g.color.b)\n\n canvas.ellipse((g.pos.x-int(g.diameter/2),g.pos.y-int(g.diameter/2), g.pos.x+int(g.diameter/2), g.pos.y+int(g.diameter/2)), fill = color)\n return image","def draw_image(res, train, label, output_dir, fig, write_file=False):\n size = len(label)\n infer_res, infer_conf, gt_conf = compare_result(res, label)\n if not os.path.exists(output_dir+\"/correct\"):\n os.makedirs(output_dir+\"/correct\")\n if not os.path.exists(output_dir + \"/incorrect\"):\n os.makedirs(output_dir + \"/incorrect\")\n\n if write_file:\n cor = open(output_dir+\"/res_correct.txt\", 'a')\n err = open(output_dir+\"/res_incorrect.txt\", 'a')\n # right inferences\n r = 0\n # error inferences\n e = 0\n # error details\n count = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n for i in range(size):\n img = Image.fromarray(train[i].reshape(fig, fig).astype(np.uint8))\n if infer_res[i] == label[i]:\n r += 1\n img.save(output_dir+\"/correct/\"+str(i)+\"_\"+str(infer_res[i])+\"_\"+str(infer_conf[i])+\".png\")\n if write_file:\n cor.write(str(i)+\"_\"+str(infer_res[i])+\"_\"+str(infer_conf[i])+str(res[i][0][0][0])+'\\n')\n\n else:\n\n e += 1\n img.save(output_dir + \"/incorrect/\" + str(i) + \"_gt:\" + str(label[i]) + \"_\" + str(\n gt_conf[i]) + \"_inf:\" + str(infer_res[i]) + \"_\" + str(infer_conf[i]) + \".png\")\n count[label[i]] += 1\n if write_file:\n err.write(str(i) + \"_gt:\"+str(label[i]) + \"_\"+str(gt_conf[i]) + \"_inf:\"+str(infer_res[i])+\"_\" +\n str(infer_conf[i]) + str(res[i][0][0][0]) + '\\n')\n if write_file:\n cor.close()\n err.close()\n print(\"correct inference results:\"+str(r))\n print(\"incorrect inference results:\" + str(e))\n print(\"incorrect inference results details:\" + str(count))","def main(folder, outputfile):\n parser = argument_parser()\n args = parser.parse_args()\n\n show_all = args.show_all\n verbose = args.verbose\n\n random.seed(args.rng_seed)\n\n args.files = folder\n print args.files\n\n try:\n image = Image.open(args.files[0])\n except IOError, msg:\n print >> sys.stderr, msg\n return 1\n if image.mode == 'P':\n image = image.convert('RGB')\n \n if image.size[0] > args.w:\n image = image.resize((args.w, int((float(args.w)/image.size[0]) *\n image.size[1])), Image.ANTIALIAS)\n\n if not show_all:\n def nothing(a, b):\n pass\n do_something = nothing\n elif args.saving:\n do_something = Imsave(\"saved/\" + args.files[0][:-4] + \"_\" +\n str(image.size[0]) + \"/\").save\n else:\n import im_debug\n do_something = im_debug.show\n\n if verbose:\n import time\n class Logger:\n def __init__(self):\n self.t = 0\n\n def __call__(self, m):\n t_n = time.time()\n if self.t > 0:\n print >> sys.stderr, \"\\t\" + str(t_n - self.t)\n print >> sys.stderr, m\n self.t = t_n\n logger = Logger()\n\n else:\n def logger(m):\n pass\n \n if args.manual_mode:\n import manual\n try:\n lines = manual.find_lines(image)\n except manual.UserQuitError:\n #TODO ask user to try again\n return 1\n else:\n if args.l_cache:\n filename = (\"saved/cache/\" + args.files[0][:-4] + \"_\" +\n str(image.size[0]))\n cache_dir = \"/\".join(filename.split('/')[:-1])\n if os.path.exists(filename):\n lines, l1, l2, bounds, hough = pickle.load(open(filename))\n print >> sys.stderr, \"using cached results\"\n else:\n lines, l1, l2, bounds, hough = linef.find_lines(image, do_something, logger)\n if not os.path.isdir(cache_dir):\n os.makedirs(cache_dir)\n d_file = open(filename, 'wb')\n pickle.dump((lines, l1, l2, bounds, hough), d_file)\n d_file.close()\n else:\n lines, l1, l2, bounds, hough = linef.find_lines(image, do_something, logger)\n\n grid, lines = gridf.find(lines, image.size, l1, l2, bounds, hough,\n show_all, do_something, logger)\n if show_all:\n im_g = image.copy()\n draw = ImageDraw.Draw(im_g)\n for l in grid[0] + grid[1]:\n draw.line(l, fill=(64, 255, 64), width=1)\n do_something(im_g, \"grid\", name=\"grid\")\n\n intersections = intrsc.b_intersects(image, lines, show_all, do_something, logger)\n board = intrsc.board(image, intersections, show_all, do_something, logger)\n\n logger(\"finished\")\n\n # TODO! refactor this mess:\n if len(args.files) == 1:\n\n if args.sgf_output:\n print board.asSGFsetPos()\n else:\n print board\n \n else:\n game = output.Game(19, board) #TODO size parameter\n #for f in args.files[1:]:\n for i, f in enumerate(args.files):\n try:\n image = Image.open(f)\n except IOError, msg:\n print >> sys.stderr, msg\n continue\n if verbose:\n print >> sys.stderr, \"Opening\", f\n if image.mode == 'P':\n image = image.convert('RGB')\n if image.size[0] > args.w:\n image = image.resize((args.w, int((float(args.w)/image.size[0]) *\n image.size[1])), Image.ANTIALIAS)\n board = intrsc.board(image, intersections, show_all, do_something, logger)\n if args.sgf_output:\n game.addMove(board)\n else:\n with open(outputfile + str(i) + \".txt\", \"w\") as f:\n f.write(str(board))\n\n if args.sgf_output:\n print game.asSGF()\n\n return 0","def save_png(self, filename):\n post_script = self.canvas.postscript().encode()\n img = Image.open(io.BytesIO(post_script))\n img.save(filename, format=\"PNG\")","def AA2Image(readpath, savepath, header, font_data):\n if not os.path.isdir(savepath):\n os.makedirs(savepath)\n print('convert txt to png. save path: ', savepath)\n\n files = glob.glob(readpath+'*.txt')\n\n for file in files:\n ascii_art = AsciiArt(file)\n ascii_art_image = ascii_art.image(font_data)\n filename = header + os.path.basename(file)[:-4] + '.png'\n ascii_art_image = Image.fromarray(ascii_art_image)\n ascii_art_image = ascii_art_image.convert('L')\n ascii_art_image.save(savepath + filename)\n print('saved ', filename)","def plotSate(s,i,seed):\r\n fig, ax = plt.subplots()\r\n\r\n im = ax.imshow(s)\r\n\r\n plt.xticks([i for i in range(dim)], \"\")\r\n plt.yticks([i for i in range(dim)], \"\")\r\n\r\n fig.tight_layout()\r\n plt.savefig(\"Systems/\" + str(dim) + \"_\" + str(seed) + \"/Images/\" + str(i) +\r\n \".jpeg\",quality=80,optimize=True,\r\n dpi=80,progressive=True,transparent=True)\r\n fig.clear()\r\n plt.close(fig)","def save(self, fn):\n plt.imsave(fn, self.image)","def paint_a_picture():\n # Make a training set (many random i,j coord and an x by y box around that coord to start with)\n # Throw it into the net\n # Test how it does for some random coordinate inputs\n pass","def export_image(self, name):\n\t\tred = Color(\"red\")\n\t\tblue = Color(\"blue\")\n\t\twhite = Color(\"white\")\n\t\tblack = Color(\"black\")\n\t\tgold = Color(\"gold\")\n\t\trgb_gold = []\n\t\tfor part in gold.rgb:\n\t\t\tpart = part * 255\n\t\t\trgb_gold.append(part)\n\t\trgb_black = []\n\t\tfor part in black.rgb:\n\t\t\tpart = part * 255\n\t\t\trgb_black.append(part)\n\t\trgb_white = []\n\t\tfor part in white.rgb:\n\t\t\tpart = part * 255\n\t\t\trgb_white.append(part)\n\t\tcolours = list(red.range_to(blue, int(self.grains)))\n\t\timage = np.zeros([self.space.shape[1],self.space.shape[0], 3], dtype=np.uint(8))\n\t\tfor grain in range(self.grains+1):\n\t\t\trgb = []\n\t\t\tfor part in colours[grain-1].rgb:\n\t\t\t\tpart = part * 255\n\t\t\t\trgb.append(part)\n\t\t\tfor cell in self.space.flat:\n\t\t\t\tif cell.state == grain:\n\t\t\t\t\tx,y = cell.find_id()\n\t\t\t\t\timage[x,y] = rgb\n\t\t\t\tif cell.state == 999:\n\t\t\t\t\tx,y = cell.find_id()\n\t\t\t\t\timage[x,y] = rgb_black\n\t\t\t\tif cell.state == 500:\n\t\t\t\t\tx,y = cell.find_id()\n\t\t\t\t\timage[x,y] = rgb_gold\n\t\timg = Image.fromarray(image.astype('uint8'))\n\t\timg = img.resize((self.space.shape[1]*3,self.space.shape[0]*3))\n\t\timg.save('./static/temp/'+str(name)+'.png')","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def save(self, filename):\n try:\n import PIL\n except ImportError:\n raise RuntimeError('Could not import PIL. PIL (pillow) is required to save fresnel images.')\n else:\n if self._output is None:\n self.render()\n image = PIL.Image.fromarray(self._output[:], mode='RGBA')\n image.save(filename)","def testImage():\n width = 200\n height = 200\n image = BitMap( width, height )\n \n # create a loop in order to draw some pixels\n \n for col in range(width):\n if col % 10 == 0: print 'col is', col\n for row in range(height):\n if col % 10 == 0 or row % 10 == 0:\n image.plotPoint( col, row ) \n \n # we have now looped through every image pixel\n # next, we write it out to a file\n \n image.saveFile( \"test.bmp\" )\n #changing the col and row number determines how big the grid is for the picture or how zoomed in it is. Changing the and to or just makes the grid go from dotted grid to lines.","def save(\n self,\n output_path: str,\n show_confidence: bool = True,\n ) -> None:\n image = self.draw(show_confidence=show_confidence)\n save_image(image=image, path=output_path)","def render(self, save_name: str = 'my_image.png') -> None:\n out = self.render_mat()\n skimage.io.imsave(save_name, out.transpose((1, 2, 0)))\n return None","def generate_image_file(color):\n img = generate_image(color)\n img.save(IMAGE_FILE)\n return IMAGE_FILE","def save(image, name):\n from matplotlib import pyplot\n import matplotlib as mpl\n fig = pyplot.figure()\n ax = fig.add_subplot(1,1,1)\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\n imgplot.set_interpolation('nearest')\n ax.xaxis.set_ticks_position('top')\n ax.yaxis.set_ticks_position('left')\n pyplot.savefig(name)","def generate_lambda_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(1, 2)\n g_lb = random.randint(1, 2)\n b_lb = random.randint(1, 2)\n red_function = r_lambda_func(1)\n green_function = r_lambda_func(1)\n blue_function = r_lambda_func(1)\n print(red_function)\n print(red_function)\n print(red_function(0.0, 1.0))\n print(red_function(1.0, 0.05))\n print(red_function(1.0, 0.0))\n\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n x = remap_interval(i, 0, x_size, -1, 1)\n y = remap_interval(j, 0, y_size, -1, 1)\n pixels[i, j] = (\n color_map(red_function(x, y)),\n color_map(green_function(x, y)),\n color_map(blue_function(x, y))\n )\n im.save(filename)\n return 'saved'","def __save_display_image(self):\n\n try:\n self.photomosaic_generator.can_save_image()\n if self.generating:\n raise MissingComponentError('Cannot save. Image is currently being generated.')\n except MissingComponentError as error_msg:\n error_msg_box = QtWidgets.QMessageBox.critical(self, 'Error', str(error_msg))\n else:\n options = QtWidgets.QFileDialog.Options()\n options |= QtWidgets.QFileDialog.DontUseNativeDialog\n file_name, file_type = QtWidgets.QFileDialog.getSaveFileName(self, 'Save photomosaic', '..',\n 'jpg (*.jpg);;png (*.png)', options=options)\n file_type = file_type[-5:-1]\n if file_name != '':\n self.photomosaic_generator.save_image(file_name + file_type if file_name[-4:] != file_type else\n file_name)","def save_figure(self, data):\n\n\t\tsizes = np.shape(data)\n\t\tfig = plt.figure()\n\t\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\n\t\tax = plt.Axes(fig, [0., 0., 1., 1.])\n\t\tax.set_axis_off()\n\t\tfig.add_axes(ax)\n\t\tax.imshow(data, \"gray\")\n\n\t\t#plt.show()\n\t\tself.plotfile = os.path.join('static', 'Figure' + '.png')\n\t\tplt.savefig(self.plotfile, dpi = sizes[1])","def test_save_png():\n img = Image.new('RGB', (10, 20))\n\n parameters = {'path': 'green-dot.png', 'data': [img]}\n\n assert images.save(parameters)","def save_image(start, stop, imgcount, label):\n text = \"\"\n imgfile = select_file(label)\n for p in range(imgcount):\n pxcnt = randint(start, stop)\n imgcurrent = create_image(imgfile, pxcnt)\n filename = \"img_train_\" + str(label) + \"_\" + str(p) + \"_\" + str(pxcnt) + \".png\"\n text += \"ctq/dataset/train/\" + filename + \" \" + str(label) + \"\\n\"\n imgcurrent.save(filename)\n text_file = open(imgfile + \"_train_label.txt\", \"w\")\n text_file.write(text)\n text_file.close()","def DrawCostMatrixAndPath( self, fname ):\n f = open(fname, 'w')\n w = len(self.D[0])\n h = len(self.D)\n f.write(\"img=None\\n\\ndef setup():\\n\\tglobal img\\n\")\n f.write(\"\\tsize(%d,%d)\\n\"%( 5*w,5*h ))\n f.write(\"\\timg = createImage( %d, %d, RGB )\\n\"%(w,h))\n f.write(\"\\timg.loadPixels()\\n\")\n mx = max([ max([ x for x in row]) for row in self.D])\n pixels = []\n i=0\n for r,row in enumerate(self.D):\n for c,cell in enumerate(row):\n pixels.append( int( 255.0*cell/mx ) )\n if( (r,c) in self.P ):\n pixels[-1] = 255\n i += 1\n for i,p in enumerate(pixels):\n f.write(\"\\timg.pixels[%d] = color(%d)\\n\"%(i,p))\n f.write(\"\\timg.updatePixels()\\n\\ndef draw():\\n\\tglobal img\\n\\timage(img,0,0,%d,%d)\\n\"%(5*w,5*h))\n f.close()","def makePNG(self,outDir=os.getcwd(),tmpFname='temp.R'):\n rscript = \"\"\"\nname<-'%s'\ncontig<-'%s'\nstart<-%d\nend<-%d\nstrand<-'%s'\nexonLengths<-c(%s)\nexonOffsets<-c(%s)\nmyLen<-end-start+1\n\npng(filename=paste('%s/',name,'.png',sep=''),width=900,height=300)\nplot.new()\nplot.window(xlim=c(start,end),ylim=c(0,3))\naxis(1)\ntitle(xlab=contig)\ntitle(main=name)\nlines(seq(start,end+1),rep(1,myLen+1),col='blue',lwd=2,lend='butt')\n\nsegments(start+exonOffsets,rep(1,length(exonOffsets)),start+exonOffsets+exonLengths,rep(1,length(exonOffsets)),col='blue',lwd=20,lend='butt')\nif (strand=='+'){\n arrows(start,1.5,(start+(myLen*0.05)),1.5,length=0.125,lwd=1.5,angle=30,col='black')\n} else if (strand=='-') {\n arrows(end,0.5,(end-(myLen*0.05)),0.5,length=0.125,lwd=1.5,angle=30,col='black')\n}\n\n\ndev.off()\"\"\" % (self.name,self.chr,self.start,self.end,self.strand,\",\".join([str(x) for x in self.exonLengths]),\",\".join([str(x) for x in self.exonOffsets]),outDir)\n tmpHandle = open(tmpFname,'w')\n print >>tmpHandle, rscript\n tmpHandle.close()\n commands.getoutput('R CMD BATCH --vanilla %s' % tmpFname)\n os.remove(tmpFname)\n return","def draw_im(self, fname):\n im = self.get_im()\n im_agraph = nx.nx_agraph.to_agraph(im)\n im_agraph.draw(fname, prog='dot')","def run_turtle_program(source):\n ast = parser.parse(source)\n\n t = turtle.Turtle()\n for stmt in ast.statement:\n do_statement(stmt, t)\n canvas = turtle.Screen().getcanvas()\n canvas.postscript(file='image.eps')\n img = Image.open('image.eps')\n img.save('image.png', 'png')\n turtle.Screen().bye()\n return 'image.png'","def save_images(self, samples, label=None, dir=\"\"):\n if label is None:\n label = self.global_step_\n fig = plt.figure()\n self.net_.eval()\n self.dist.visualize(fig, samples, self.energy)\n plot_fn = os.path.join(dir, f\"samples_{label}.png\")\n fig.savefig(plot_fn)\n plt.close(fig)","def clumpy_graph(self,img):\n \n id = self._getGraphId()\n root = 'S_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n doStamp(img.copy(),pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n try : Painted.load()\n except IOError : stop()\n text = 'S=%5.2f' % (self['M_S'])\n # Painted.Graffiti(text,commtextpos)\n Painted.save(jpgname) \n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n self['figures']['S'] = epsname\n self['figcomms']['S'] = text","def displayImage():\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"r\")\n epochNum = int(f.readline())\n f.close()\n return Image.open(\"outputPhotosColor/image_at_epoch_{:04d}.png\".format(epochNum))","def generate(self, chars, format='png'):\n im = self.generate_image(chars)\n out = BytesIO()\n im.save(out, format=format)\n out.seek(0)\n return out","def _saveFig(self):\r\n # Save plot\r\n filenameG = self._vna.getDateFormatted() + \".png\"\r\n filenameG = \"Graphs/\" + filenameG \r\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\r\n plt.clf()","def to_figure(self, structure):\n if not self.bypass:\n if self.format is \"show\":\n plt.show()\n elif self.format is \"png\":\n plt.savefig(self.path + self.filename + \".png\", bbox_inches=\"tight\")\n elif self.format is \"fits\":\n if structure is not None:\n structure.output_to_fits(\n file_path=self.path + self.filename + \".fits\", overwrite=True\n )","def save_dataset_visual(lines, output_dir):\n\n # Ensure output directory exists\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n cols = 3\n rows = 3\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\n # Random sample of images\n save_name = \"training_data_sample.png\"\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\n for row in range(rows):\n for col in range(cols):\n idx = np.random.randint(0, len(lines))\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\n ax[row, col].set_title(\"Angle = \" + str(round(lines[idx][1], 3)))\n plt.savefig(output_dir + save_name, bbox_inches='tight')\n # Distribution of steering angles\n save_name = \"data_histogram.png\"\n fig_size = (5, 3) # Figure width and height, in inches\n num_bins = 100\n angles = np.array([line[1] for line in lines])\n hist, bins = np.histogram(angles, bins=num_bins)\n fig = plt.figure(figsize=fig_size)\n plt.bar(bins[:-1], hist)\n plt.xlabel(\"Steering Angle\")\n plt.ylabel(\"Frequency\")\n plt.title(\"Distribution of Steering Angles in Training Data\")\n plt.savefig(output_dir + save_name, bbox_inches='tight')","def generatePreview(self):\n self.saveParameters()\n image=self.simulation.generatePreview()\n # convert pil image to a tkinter image\n self.photo = ImageTk.PhotoImage(image)\n\n # display image\n self.preview.create_image(0, 0, anchor='nw', image=self.photo)","def draw(canvas_result,automatic_save,manual_save):\r\n if canvas_result is not None and canvas_result.image_data is not None and (automatic_save or manual_save):\r\n # Receive the user's drawing with the dimensions: 512X512X4\r\n img_data = canvas_result.image_data\r\n # the user's drawing is in RGBA mode with floats instead of integers - convert to uint8 type and to RGB format\r\n im = Image.fromarray(img_data.astype(np.uint8)[:,:,:3]).convert('RGB') # convert to dimensions 512X512X3\r\n # initialize a copy of the user's drawing.\r\n add_bg = np.array(im, dtype='uint8') # initalize a copy\r\n # allow the user to know that the saving is in progress.\r\n with st.spinner(\"Saving image...\"):\r\n # the drawing is lack of the GauGAN background because streamlit_drawable_canvas library doesn't allow it yet.\r\n # Because of that the background will be added manually - o(n^3) at the moment.\r\n for i in range(add_bg.shape[0]):\r\n for j in range(add_bg.shape[1]):\r\n if list(add_bg[i,j]) != [0,0,0]: # if the current RGB value is not (0,0,0) (black) -\r\n for k in range(add_bg.shape[2]): # then make sure we don't have white values (255)\r\n if add_bg[i,j][k] == 255: # we will fill them with the relevant background color position\r\n add_bg[i,j][k] = colors['Sky'][k] if i<300 else colors['Sea'][k]\r\n else: # else, we do indeed have RGB value of (0,0,0), then replace it by its entirety to the relevant\r\n # background color.\r\n add_bg[i,j] = colors['Sky'] if i<300 else colors['Sea']\r\n\r\n # Create PIL object of the manually added background with drawing on the canvas\r\n add_bg = Image.fromarray(add_bg)\r\n # Assign the path where the file will be saved\r\n if not os.path.exists(\"tmp/\"):\r\n os.makedirs(\"tmp/\")\r\n file_path = f\"tmp/pic%s.png\"%(len(counter))\r\n # Increase the counter by adding dummy element into the counter list\r\n counter.append(0)\r\n # Save the drawing in PNG format\r\n\r\n add_bg.save(file_path, \"PNG\")\r\n st.success(\"Image saved successfully. Keep drawing!!\")","def add_art(self,path,size=\"500\"):\n error=False\n if path:\n print(\"processing %s to %s\" % (path,self.uid))\n f=open(path,'rb') \n filedata=f.read()\n extension=(imghdr.what('',filedata) or path.rsplit(\".\")[-1].lower()).replace('jpeg','jpg')\n if not filedata:\n error= \"NO IMAGE FOUND AT '%s'\" % path\n print(error)\n elif extension in ('bmp','png'):\n filedata=self.Image.convert(filedata)\n extension='jpg' \n elif extension not in ('gif','png','jpg','jpeg'):\n error=\"only JPEG, GIF, PNG, and BMP are supported\"\n print(error)\n if not error:\n # create a new image page\n image=self.Image.new()\n image.parent=self.uid\n image.kind='image'\n image.seq=0xFFFFFF#place at end of siblings\n # set default size \n image.stage='right full %sx%s' % (size,size) #rest of stage data will be added on the fly later by get_stage_data() \n image.set_lineage()\n image.code=\"%s.%s\" % (image.uid,extension)\n image.when=DATE()\n image.flush() #store the image page\n image.renumber_siblings_by_kind()#keep them in order\n # save the image file\n image.save_file(filedata)\n # return\n print('image \"%s\" added' % image.code)\n return image\n return None","def make_montage(infile):\n\n #create a blank image\n blank = Image.new(\"RGB\", OUTPIC_SIZE ,(25,23,24,255))\n\n #paste the background\n bg = Image.open(BACKGROUND_FILENAME)\n blank.paste(bg,(0,0))\n \n #paste the raw picture\n im = Image.open(infile)\n \n # past on background\n blank.paste(im,OUTPIC_PHOTO_OFFSET)\n\n #paste the stickers layer on the pic (a transparent png)\n stickers = Image.open(STICKERS_FILENAME)\n blank.paste(stickers,(0,0),stickers)\n\n return blank","def make_mosaic(target_im, saved_file_name):\n BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n color_data_file = os.path.join(BASE_DIR, 'static/images/data/average_color.csv')\n color_data = materials_list_from_file(color_data_file)\n\n target_file = os.path.join(BASE_DIR, 'static/images/target/{}'.format(target_im))\n icon_im = image_process.open_image_RGB(target_file)\n icon_im_width, icon_im_height = icon_im.size\n mosaic_icon_im = Image.new('RGBA', (1600, 1600))\n\n for left in range(0, icon_im_width, DOT_AREA_ONE_SIDE):\n for top in range(0, icon_im_height, DOT_AREA_ONE_SIDE):\n average_color = calc.average_color_in_range(icon_im, left, top,\n left+DOT_AREA_ONE_SIDE, top+DOT_AREA_ONE_SIDE)\n if len(average_color) != 3:\n continue\n\n filename = similar_color_filename(average_color, color_data)\n # 距離最小のファイルを1600×1600の画像に貼り付け\n open_file = os.path.join(BASE_DIR, 'static/images/material/euph_part_icon/'+filename)\n area_im = Image.open(open_file)\n mosaic_icon_im.paste(area_im, (left//DOT_AREA_ONE_SIDE * THUMBNAIL_ONE_SIDE,\n top//DOT_AREA_ONE_SIDE * THUMBNAIL_ONE_SIDE))\n\n saved_file_path = 'static/images/ftnext/{}'.format(saved_file_name)\n saved_file = os.path.join(BASE_DIR, saved_file_path)\n mosaic_icon_im.save(saved_file)","def write_png(self, output_name):\n self.fig.savefig(output_name)\n return","def write(self, chars, output, format='png'):\n im = self.generate_image(chars)\n return im.save(output, format=format)","def fc_visual_save(fc, lowweight, savenamefile_prefix):\r\n\r\n\r\n ### text setup for brain areas ###\r\n pos_text_lefttop1 = [-80, 50, 30]\r\n pos_text_middletop1 = [120, 50, 30]\r\n pos_text_lefttop2 = [-80, 70, 10]\r\n pos_text_leftDown1 = [-80, 550, 30]\r\n pos_text_leftDown2 = [-80, 570, 10]\r\n pos_text_leftDown3 = [-80, 580, 10]\r\n \r\n texts_org = dict()\r\n\r\n lowweight = np.round(lowweight, decimals = 2) \r\n\r\n # plot\r\n df_chninf = assign_coord2chnArea(area_coord_file, fc['chnAreas'])\r\n for ci, cond in enumerate(fc['ciCOH'].keys()):\r\n ciCOH = fc['ciCOH'][cond]\r\n ntrials, ntemp = fc['setup']['ntrials_' + cond], fc['setup']['ntemp_' + cond]\r\n\r\n\r\n texts = texts_org.copy()\r\n \r\n text_thred = 'thred = ' + str(np.round(lowweight, decimals = 2))\r\n text_ntrials = 'ntrials = ' + str(ntrials)\r\n\r\n texts[cond] = pos_text_middletop1\r\n texts[text_task] = pos_text_leftDown1\r\n texts[text_ntrials] = pos_text_leftDown2\r\n texts[text_thred] = pos_text_leftDown3\r\n \r\n\r\n saveFCGraph = os.path.join(savefolder, savenamefile_prefix + '_lw' + str(np.round(lowweight, decimals = 2)) + '_' + cond + '.png')\r\n\r\n igplot = ciCOH_visual_save(ciCOH = ciCOH, chnInf = df_chninf, lowweight = lowweight, \r\n savefile = saveFCGraph, texts = texts, threds_edge = None)\r\n\r\n del texts[cond], texts[text_ntrials]\r\n\r\n img = cv2.imread(saveFCGraph)\r\n if ci == 0:\r\n imgs = img\r\n else:\r\n imgs = np.concatenate((imgs, np.zeros((img.shape[0], 5, 3)),img), axis = 1)\r\n\r\n os.remove(saveFCGraph)\r\n\r\n # combine all conditions\r\n print(imgs.shape)\r\n saveFCGraph_comb = os.path.join(savefolder, 'comb_' + savenamefile_prefix + '_lw' + str(np.round(lowweight, decimals = 2)) + '.png')\r\n cv2.imwrite(saveFCGraph_comb, imgs)","def main():\n fg = SimpleImage('image_contest/me.jpg')\n bg = SimpleImage('image_contest/house.png')\n bg.make_as_big_as(fg)\n combined_img = combine(bg, fg)\n combined_img.show()"],"string":"[\n \"def generate_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(6, 10)\\n g_lb = random.randint(6, 10)\\n b_lb = random.randint(6, 10)\\n red_function = build_random_function(r_lb, r_lb+1)\\n green_function = build_random_function(g_lb, g_lb+1)\\n blue_function = build_random_function(b_lb, b_lb+1)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n im.save(filename+'.png')\\n return 'saved'\",\n \"def create_artificial_image(self):\\n background = self.BGI.create_background_image()\\n star_PSF = self.PSF.create_star_PSF()\\n header = self.HDR.create_header()\\n\\n fits.writeto(self.image_dir + self.image_name + '.fits',\\n background + star_PSF, overwrite=True, header=header)\",\n \"def generate_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n \\n red_function = build_random_function(7,15)\\n green_function = build_random_function(7,15)\\n blue_function = build_random_function(7,15)\\n \\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(evaluate_random_function(red_function, x, y)),\\n color_map(evaluate_random_function(green_function, x, y)),\\n color_map(evaluate_random_function(blue_function, x, y))\\n )\\n\\n im.save(filename)\",\n \"def save(self):\\n\\n self.image.save(\\\"./output/\\\" + self.name + \\\" pg\\\" + str(self._page) + \\\".png\\\")\",\n \"def save(self):\\n img = Image.new(\\\"1\\\", (self.container.width, self.container.height))\\n draw = ImageDraw.Draw(img)\\n for item in self.items:\\n draw.ellipse(item.box_coordinates(), fill=1)\\n del draw\\n img.save(\\\"plot.bmp\\\", \\\"bmp\\\")\",\n \"def generate_image(self):\\n pass\",\n \"def save_plot_as_image(self):\\r\\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\\r\\n bbox_inches='tight')\",\n \"def write_file(self):\\n if self.it_num % 5 == 0:\\n #plt.imshow(self.grid)\\n #plt.savefig(\\\"output%.4d.png\\\" % self.it_num, bbox_inches='tight')\\n io.savemat(\\\"MLOutput%.4d\\\" % self.it_num, { \\\"Grid\\\":self.grid})\",\n \"def generate_art_3(filename, x_size=350, y_size=350, t_size=30):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(1, 5)\\n g_lb = random.randint(1, 10)\\n b_lb = random.randint(1, 5)\\n red_function = build_random_function_3(r_lb, r_lb+1)\\n green_function = build_random_function_3(g_lb, g_lb+1)\\n blue_function = build_random_function_3(b_lb, b_lb+1)\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for time in range(t_size):\\n for i in range(x_size):\\n for j in range(y_size):\\n t = remap_interval(time, 0, t_size, -1, 1)\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(eval_r_func_3(red_function, x, y, t)),\\n color_map(eval_r_func_3(green_function, x, y, t)),\\n color_map(eval_r_func_3(blue_function, x, y, t))\\n )\\n str_num = '0' * (5 - len(str(time))) + str(time)\\n print(str_num)\\n im.save(filename + str_num + '.png')\\n return 'saved'\",\n \"def save_images(self):\\n for q in range(self.N_itr):\\n plt.clf()\\n self.plot_EM_estimate(q)\\n plt.savefig('img%d.png' % (100 + q))\",\n \"def run(self):\\n generated_gif = self.generate()\\n with open(self.out_filename, 'wb') as out_fd:\\n out_fd.write(generated_gif)\",\n \"def save_augmentation_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n save_name = 'data_augmentation.png'\\n idx = np.random.randint(0, len(lines))\\n image = ndimage.imread(lines[idx][0])\\n angle = lines[idx][1]\\n fig = visualize_augmentation(image, angle)\\n fig.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def graphical_output(self, block=False, save=False, display=True, folder_name='output', image_suffix=None):\\n masks = [np.where(self.board == i, True, False) for i in range(self.number_of_colors)]\\n output = np.zeros((self.height, self.width, 3), dtype=np.int)\\n for mask, color in zip(masks, list(COLORS.values())[:self.number_of_colors]):\\n output[mask] = color\\n\\n image = np.repeat(np.repeat(output, 10, axis=0), 10, axis=1)/255.0\\n if save:\\n plt.imsave(f'{folder_name}/image{image_suffix}.png', image)\\n\\n if display:\\n plt.imshow(image)\\n plt.show(block=block)\\n\\n return image\",\n \"def save_reconstructed_images(self, filename, rows, cols):\\n # print(filename)\\n num_images = self.reconstructed.shape[0]\\n images = np.zeros((rows, cols*num_images))\\n for i in range(num_images):\\n start = int(i * cols)\\n end = int((i+1) * cols)\\n images[0:rows, start:end] = self.reconstructed[i].reshape((rows, cols))\\n\\n plt.imshow(images, cmap='gray', aspect='equal', interpolation='none')\\n #plt.show()\\n plt.savefig(filename)\\n return\",\n \"def make_image(self, frame, filename, **kwds):\\n p = plot.plot(frame, **kwds)\\n p.save_image(filename)\",\n \"def gen_art(complexity=7, num_frames=1, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n\\n red_function = bld_func(complexity, complexity+2)\\n green_function = bld_func(complexity, complexity+2)\\n blue_function = bld_func(complexity, complexity+2)\\n\\n\\n # Create image and loop over all pixels\\n for t in range(0, num_frames+1):\\n print \\\"Generating frame %d ... Please be patient.\\\" % t\\n t_val = (t-(num_frames/2.0))/(num_frames/2.0)\\n\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap(i, 0, x_size, -1, 1)\\n y = remap(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n c_map(eval_func(red_function, x, y, t_val)),\\n c_map(eval_func(green_function, x, y, t_val)),\\n c_map(eval_func(blue_function, x, y, t_val))\\n )\\n \\n im.save('frame%d.png' % t)\",\n \"def setup():\\n img = Image.new('RGB', (10, 20))\\n img.putpixel((5, 10), (0, 255, 0))\\n img.save('green-dot.tif')\\n img.save('green-dot.jpg')\\n img.save('green-dot.png')\",\n \"def generate_and_save_images(model, seed, output_path, title):\\n\\n predictions = model(tf.Variable(seed, trainable=False))\\n\\n fig = plt.figure(figsize=(4,4))\\n\\n for i in range(predictions.shape[0]):\\n plt.subplot(4, 4, i+1)\\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\\n plt.axis('off')\\n if not os.path.exists(output_path):\\n os.mkdir(output_path)\\n\\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\\n plt.close()\",\n \"def save(self, assignment, filename):\\n from PIL import Image, ImageDraw, ImageFont\\n cell_size = 100\\n cell_border = 2\\n interior_size = cell_size - 2 * cell_border\\n letters = self.letter_grid(assignment)\\n\\n # Create a blank canvas\\n img = Image.new(\\n \\\"RGBA\\\",\\n (self.crossword.width * cell_size,\\n self.crossword.height * cell_size),\\n \\\"black\\\"\\n )\\n font = ImageFont.truetype(\\\"assets/fonts/OpenSans-Regular.ttf\\\", 80)\\n draw = ImageDraw.Draw(img)\\n\\n for i in range(self.crossword.height):\\n for j in range(self.crossword.width):\\n\\n rect = [\\n (j * cell_size + cell_border,\\n i * cell_size + cell_border),\\n ((j + 1) * cell_size - cell_border,\\n (i + 1) * cell_size - cell_border)\\n ]\\n if self.crossword.structure[i][j]:\\n draw.rectangle(rect, fill=\\\"white\\\")\\n if letters[i][j]:\\n w, h = draw.textsize(letters[i][j], font=font)\\n draw.text(\\n (rect[0][0] + ((interior_size - w) / 2),\\n rect[0][1] + ((interior_size - h) / 2) - 10),\\n letters[i][j], fill=\\\"black\\\", font=font\\n )\\n\\n img.save(filename)\",\n \"def save(self, assignment, filename):\\n from PIL import Image, ImageDraw, ImageFont\\n cell_size = 100\\n cell_border = 2\\n interior_size = cell_size - 2 * cell_border\\n letters = self.letter_grid(assignment)\\n\\n # Create a blank canvas\\n img = Image.new(\\n \\\"RGBA\\\",\\n (self.crossword.width * cell_size,\\n self.crossword.height * cell_size),\\n \\\"black\\\"\\n )\\n font = ImageFont.truetype(\\\"assets/fonts/OpenSans-Regular.ttf\\\", 80)\\n draw = ImageDraw.Draw(img)\\n\\n for i in range(self.crossword.height):\\n for j in range(self.crossword.width):\\n\\n rect = [\\n (j * cell_size + cell_border,\\n i * cell_size + cell_border),\\n ((j + 1) * cell_size - cell_border,\\n (i + 1) * cell_size - cell_border)\\n ]\\n if self.crossword.structure[i][j]:\\n draw.rectangle(rect, fill=\\\"white\\\")\\n if letters[i][j]:\\n w, h = draw.textsize(letters[i][j], font=font)\\n draw.text(\\n (rect[0][0] + ((interior_size - w) / 2),\\n rect[0][1] + ((interior_size - h) / 2) - 10),\\n letters[i][j], fill=\\\"black\\\", font=font\\n )\\n\\n img.save(filename)\",\n \"def save(self, assignment, filename):\\n from PIL import Image, ImageDraw, ImageFont\\n cell_size = 100\\n cell_border = 2\\n interior_size = cell_size - 2 * cell_border\\n letters = self.letter_grid(assignment)\\n\\n # Create a blank canvas\\n img = Image.new(\\n \\\"RGBA\\\",\\n (self.crossword.width * cell_size,\\n self.crossword.height * cell_size),\\n \\\"black\\\"\\n )\\n font = ImageFont.truetype(\\\"assets/fonts/OpenSans-Regular.ttf\\\", 80)\\n draw = ImageDraw.Draw(img)\\n\\n for i in range(self.crossword.height):\\n for j in range(self.crossword.width):\\n\\n rect = [\\n (j * cell_size + cell_border,\\n i * cell_size + cell_border),\\n ((j + 1) * cell_size - cell_border,\\n (i + 1) * cell_size - cell_border)\\n ]\\n if self.crossword.structure[i][j]:\\n draw.rectangle(rect, fill=\\\"white\\\")\\n if letters[i][j]:\\n w, h = draw.textsize(letters[i][j], font=font)\\n draw.text(\\n (rect[0][0] + ((interior_size - w) / 2),\\n rect[0][1] + ((interior_size - h) / 2) - 10),\\n letters[i][j], fill=\\\"black\\\", font=font\\n )\\n\\n img.save(filename)\",\n \"def writeImage(image, filename):\\n Sky = [128,128,128]\\n Building = [128,0,0]\\n Pole = [192,192,128]\\n Road_marking = [255,69,0]\\n Road = [128,64,128]\\n Pavement = [60,40,222]\\n Tree = [128,128,0]\\n SignSymbol = [192,128,128]\\n Fence = [64,64,128]\\n Car = [64,0,128]\\n Pedestrian = [64,64,0]\\n Bicyclist = [0,128,192]\\n Unlabelled = [0,0,0]\\n r = image.copy()\\n g = image.copy()\\n b = image.copy()\\n label_colours = np.array([Sky, Building, Pole, Road_marking, Road, Pavement, Tree, SignSymbol, Fence, Car, Pedestrian, Bicyclist, Unlabelled])\\n for l in range(0,12):\\n r[image==l] = label_colours[l,0]\\n g[image==l] = label_colours[l,1]\\n b[image==l] = label_colours[l,2]\\n rgb = np.zeros((image.shape[0], image.shape[1], 3))\\n rgb[:,:,0] = r/1.0\\n rgb[:,:,1] = g/1.0\\n rgb[:,:,2] = b/1.0\\n im = Image.fromarray(np.uint8(rgb))\\n # im.save('/Users/koheiyamamoto/Desktop/SegNet/out/' + filename)\\n im.save('./out/' + filename)\",\n \"def save():\\n pl.savefig('/home/filippini/Documents/plot/RUN55/compa'+INFO_RUN+'.png')\",\n \"def make_image(self, save=False):\\n\\n # image_grid = np.full((self.size_x, self.size_y), '#888888', dtype=str)\\n image_grid = np.full((self.size_x, self.size_y, 3), 0, dtype=np.uint8)\\n\\n # self.grid = np.flip(self.grid, 1)\\n\\n # self.grid = np.swapaxes(self.grid, 0, 0)\\n \\\"\\\"\\\"\\n image_grid[self.grid == 0] = 'FFFFFF'\\n image_grid[self.grid == 1] = '000000'\\n image_grid[self.grid == 2] = '00FF00'\\n image_grid[self.grid == 3] = '0000FF'\\n image_grid[self.grid == 4] = 'FFFF00'\\n image_grid[self.grid == 5] = '00FFFF'\\n image_grid[self.grid == 6] = 'FF00FF'\\n \\\"\\\"\\\"\\n image_grid[self.grid == 0] = (1, 1, 1)\\n image_grid[self.grid == 1] = (0, 0, 0)\\n image_grid[self.grid == 2] = (1, 0, 1)\\n image_grid[self.grid == 3] = (0, 1, 0)\\n image_grid[self.grid == 4] = (0, 0, 1)\\n image_grid[self.grid == 5] = (0, 1, 1)\\n image_grid[self.grid == 6] = (1, 1, 0)\\n\\n #for ant in self.ants:\\n # image_grid[ant.x, ant.y] = (1, 0, 0)\\n\\n # image_grid = image_grid.swapaxes(0, 1)\\n # self.grid = self.grid.swapaxes(0, 1)\\n\\n\\n\\n DPI = 100\\n width, height = 1000, 1000\\n fig = plt.figure(figsize=(width / DPI, height / DPI), dpi=DPI, facecolor='k')\\n ax = fig.add_subplot()\\n\\n plt.axis('equal')\\n plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)\\n\\n for y in range(self.size_x):\\n for x in range(self.size_y):\\n if self.grid[x, y] != 0:\\n # Only plot a hexagon if its state is not zero.\\n plot_hex(ax, x, y, image_grid[x, y])\\n\\n ax.set_xlim(0, self.size_x)\\n ax.set_ylim(0, self.size_y)\\n\\n plt.show()\\n\\n logging.info(\\\"Finished Image Processing\\\")\",\n \"def save_image(self):\\r\\n filename = filedialog.asksaveasfilename(title='Save Image As...',\\r\\n filetypes=((\\\"Portable Network Graphics (.png)\\\", \\\"*.png\\\"), (\\\"Portable Document Format(.pdf)\\\", \\\"*.pdf\\\")))\\r\\n self.graph.savefig(filename, dpi=self.graph.dpi)\",\n \"def render(filename,i):\\n print('running render')\\n A = np.genfromtxt(filename,skip_header=1,dtype=float,delimiter=',')\\n img = np.array(A[i,:],copy=True)\\n print(img.shape)\\n img = img.reshape(28,28)\\n img = 255 - img\\n print(img.shape)\\n plt.imshow(img, cmap=\\\"gray\\\", vmin=0, vmax=255)\\n plt.savefig(\\\"img\\\" + str(i)+\\\"render\\\"+ \\\".png\\\")\",\n \"def _repr_png_(self):\\n mol = self.owner.mol\\n keku = IPythonConsole.kekulizeStructures\\n size = IPythonConsole.molSize\\n opts = IPythonConsole.drawOptions\\n return Draw._moltoimg(\\n mol, size, self.aix, \\\"\\\", returnPNG=True, drawOptions=opts,\\n kekulize=keku, highlightBonds=self.bix\\n )\",\n \"def _repr_png_(self):\\n mol = self.owner.mol\\n keku = IPythonConsole.kekulizeStructures\\n size = IPythonConsole.molSize\\n opts = IPythonConsole.drawOptions\\n return Draw._moltoimg(\\n mol, size, self.aix, \\\"\\\", returnPNG=True, drawOptions=opts,\\n kekulize=keku, highlightBonds=self.bix\\n )\",\n \"def write_image(path, tokens, weights):\\n\\n f = render_attn_inner(tokens, weights)\\n f.savefig(path, bbox_inches=\\\"tight\\\", frameon=False)\\n plt.close(f)\",\n \"def save_plot(self):\\r\\n\\t\\t# Generate the plot\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\t# Create save directory\\r\\n\\t\\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\\r\\n\\t\\tif not path_exists(directory):\\r\\n\\t\\t\\tmakedirs(directory)\\r\\n\\t\\t# Save image file\\r\\n\\t\\tself.fig.savefig(directory+str(self.universe.time))\",\n \"def main(image_path):\\n temp_dir = tempfile.mkdtemp()\\n print('Saving output to {}'.format(temp_dir))\\n estimator = run_image(image_path)\\n visualize(estimator, image_path, temp_dir)\",\n \"def saveImage(self, fileName=\\\"mandelbrot.frac\\\"):\\n # Save the image as a PNG\\n if fileName == \\\"\\\":\\n fileName = \\\"mandelbrot.frac\\\"\\n directories = fileName.split(\\\"/\\\")\\n for n in directories:\\n if \\\".frac\\\" in n:\\n name = n.rsplit(\\\".\\\", 1)[0]\\n self.img.write(f\\\"{name}.png\\\")\\n print(f\\\"Wrote image {name}.png\\\")\",\n \"def saveImage(turtle, filename):\\n ts = turtle.getscreen()\\n tc = ts.getcanvas()\\n tc.postscript(file=filename)\",\n \"def drawOutput():\\n global lastPlayedCoordinates\\n notes = notes_text.get(\\\"1.0\\\", \\\"end-1c\\\")\\n\\n tempDir = \\\".bt_temp\\\"\\n\\n # Create the directory only if it does not exist\\n try:\\n os.makedirs(tempDir)\\n except FileExistsError:\\n pass\\n\\n tempNotesFile = tempDir + \\\"/currentNotes.btu\\\"\\n tempNewBTI = tempDir + \\\"/generatedNotes.bti\\\"\\n\\n with open(tempNotesFile, 'w') as f:\\n f.write(str(notes))\\n\\n BitTuneDrawingLanguage.generateBitTuneImageFromFile(tempNotesFile,tempNewBTI)\\n clearCanvas()\\n\\n loadFromFile(tempNewBTI)\\n os.remove(tempNewBTI)\\n os.remove(tempNotesFile)\\n lastPlayedCoordinates = []\",\n \"def cb_save(event):\\n fig.savefig('sample.univariate_discrete.py.png', dpi=300, format='png', transparent=True)\",\n \"def save(file_name):\\n setup()\\n plt.savefig(file_name)\",\n \"def print_image(indiv,name):\\n routine = gp.compile(indiv,pset)\\n output = gen_beat_output(routine)\\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\\n plt.style.use('classic')\\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\\n plt.savefig(name+\\\".png\\\",dpi=150)\",\n \"def generateImage(self):\\n self.image = self.font.render(self.text, True, self.color)\\n self.rect = self.image.get_rect()\\n self.rect.center = self.xy\",\n \"def save_particles_image(self):\\n base_filename = self.config['info']['filename_microscope']\\n self.save_image_microscope_camera(base_filename)\",\n \"def make_art(functions, filename, lambdas, x_size=def_x_size, y_size=def_y_size):\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (color_map(evaluate_random_function(functions[0], x, y, lambdas)),\\n color_map(evaluate_random_function(functions[1], x, y, lambdas)),\\n color_map(evaluate_random_function(functions[2], x, y, lambdas)))\\n im.save(filename+\\\".png\\\")\",\n \"def save_image(self, image_file):\\r\\n self.ensure_pyplot()\\r\\n command = 'plt.gcf().savefig(\\\"%s\\\")'%image_file\\r\\n #print 'SAVEFIG', command # dbg\\r\\n self.process_input_line('bookmark ipy_thisdir', store_history=False)\\r\\n self.process_input_line('cd -b ipy_savedir', store_history=False)\\r\\n self.process_input_line(command, store_history=False)\\r\\n self.process_input_line('cd -b ipy_thisdir', store_history=False)\\r\\n self.process_input_line('bookmark -d ipy_thisdir', store_history=False)\\r\\n self.clear_cout()\",\n \"def draw_image(self):\\n \\n pixel_array = self.imageprepare(self.image_path)\\n newArr = self.reshape_pixel_array(pixel_array)\\n plt.imshow(newArr, interpolation='nearest')\\n plt.savefig('MNIST_IMAGE.png')#save MNIST image\\n plt.show()#Show / plot that image\",\n \"def generate_art(filename=def_art_name, min_depth=def_min_depth, max_depth=def_max_depth,\\n x_size=def_x_size, y_size=def_y_size, write_funcs=def_save, func_filename=def_func_name):\\n # Functions for red, green, and blue channels - where the magic happens!\\n name_funcs = []\\n lam_funcs = []\\n for i in range(3):\\n functions = build_random_function(min_depth, max_depth)\\n name_funcs.append(functions[0])\\n lam_funcs.append(functions[1])\\n\\n # generate art always uses lambdas because they are faster, while regenerate\\n # art requrires use of nested lists, leading to this fixed 'True' value to specify\\n make_art(lam_funcs, filename, True, x_size, y_size)\\n write_func(name_funcs, func_filename)\",\n \"def __generate_image(self):\\n\\t\\tself.img = np.ones((self.size*self.width+self.border,self.size*self.width+self.border,1), np.uint8)*255\\n\\t\\tfor i in range(len(self.matrix)):\\n\\t\\t\\tfor j in range(len(self.matrix)):\\n\\t\\t\\t\\tif self.matrix[j][i] == 1:\\n\\t\\t\\t\\t\\tself.img = cv2.rectangle(self.img,(i*self.width+int(self.border/2),j*self.width+int(self.border/2))\\n\\t\\t\\t\\t\\t\\t,(i*self.width+self.width+int(self.border/2),j*self.width+self.width+int(self.border/2)),(0,0,0),-1)\\n\\t\\tif '.' in self.name:\\n\\t\\t\\tcv2.imwrite(self.name,self.img)\\n\\t\\telse:\\n\\t\\t\\tcv2.imwrite(self.name+'.jpg',self.img)\\n\\t\\tcv2.imshow(\\\"Image\\\",self.img)\\n\\t\\tcv2.waitKey(0)\\n\\t\\tcv2.destroyAllWindows()\",\n \"def draw(self):\\n self.write_image()\\n self.update()\",\n \"def OnBuildPNGs(self, e):\\n if (not defaults.use_tex):\\n msg = \\\"LaTeX is disabled in the defaults.py file. To use this functionality, change the\\\"\\n msg += \\\" use_tex option to True and restart the GUI.\\\"\\n ShowMessage(msg, kind='warn')\\n return\\n question = \\\"Quantity code formulas are displayed using PNG images, which need to be generated.\\\"\\n question += \\\"\\\\n\\\\n\\\\nImages should only be generated if they do not already exist or\\\"\\n question += \\\" the quantity codes have changed, e.g., more custom outputs have been added.\\\"\\n question += \\\"\\\\n\\\\n\\\\nThis can take ~60 sec, do you want to proceed?\\\"\\n proceed = AskYesNo(question, title='Generate LaTeX Formula Images?')\\n if (not proceed): return\\n\\n question = \\\"Choose a path where the images will be saved. The default value from defaults.py is shown.\\\"\\n path = AskText(question, default=defaults.quantity_code_image_path, title=\\\"Where to store images?\\\")\\n if (path is None): return\\n defaults.quantity_code_image_path = path # user overrode this quantity, remember for later\\n\\n question = \\\"If image files already exist, do you want to overwrite them?\\\"\\n overwrite = AskYesNo(question, title='Overwrite Existing Files?')\\n\\n # call render routine and display a progress bar\\n Nq = len(self.mainparent.nmlpanel.output_quantities.quantities)\\n offsets = list(self.mainparent.nmlpanel.output_quantities.offsets.keys())\\n\\n P = ProgressBar(Nq)\\n P(0)\\n for i,Q in enumerate(self.mainparent.nmlpanel.output_quantities.quantities):\\n if (Q.name in offsets): continue\\n render_tex(Q.code, Q.tex, defaults.quantity_code_image_path, overwrite=overwrite)\\n\\n P(i+1) # update progress bar\",\n \"def save_PPM(self, fileName, imageComment = \\\"\\\"):\\n file = open(add_ext_if_needed(fileName, \\\"ppm\\\"), \\\"w\\\")\\n file.write(\\\"P3\\\\n\\\"); \\n file.write(\\\"# \\\" + imageComment + \\\"\\\\n\\\")\\n file.write(str(self._image.width()) + \\\" \\\" + str(self._image.height()) + \\\"\\\\n\\\")\\n file.write(\\\"255\\\\n\\\")\\n for y in range(self._image.height()):\\n for x in range(self._image.width()):\\n r,g,b = self.getPixel(x,y);\\n file.write(str(r) + \\\" \\\" + str(g) + \\\" \\\" + str(b) + \\\"\\\\n\\\")\\n file.close()\",\n \"def test_plot_images(self):\\n save_file(self.quart.plot_images)\",\n \"def make_image(self, imagename, fitsname, niter=500, antenna='', phasecenter='', start=200, stop=900, del_img=True, overwrite=False): \\n self.generate_image(imagename, antenna=antenna, niter=niter, phasecenter=phasecenter, start=start, stop=stop)\\n self.to_fits(imagename + '.image', fitsname, overwrite=overwrite)\\n if del_img:\\n self.remove_image(imagename, del_img=True)\",\n \"def save(self, filename):\\n print(\\\"Saving...\\\", end=\\\"\\\\r\\\")\\n canvas = self.canvas[self.N:self.S,self.W:self.E]\\n cv2.imwrite(\\\"./Output/\\\"+filename, canvas)\\n print(\\\"Saved:\\\",filename)\",\n \"def main():\\n me = SimpleImage(\\\"images/me.JPG\\\")\\n dinosaur = SimpleImage(\\\"images/dinosaur.jpg\\\")\\n\\n dinosaur.make_as_big_as(me)\\n combine = magic(me, dinosaur)\\n combine.show()\",\n \"def make_image():\\n click.echo(\\\"make_image\\\")\",\n \"def create_png(image, label):\\n sv = \\\"/home/avojtekova/Desktop/final_results/star_det/generated_images/\\\" \\n \\n for i in range(len(image)):\\n data = fits.getdata(image[i][0], ext = 0)\\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\\n \\n print(image[i][0])\\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \\n plt.title(label[i])\\n plt.axis('off')\\n plt.tight_layout()\\n plt.legend\\n if i<2:\\n if not os.path.isdir(sv + image[i][0][-33:-25] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-33:-25] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-33:-25] + \\\"/\\\" + label[i]+ \\\"_\\\" + image[i][0][-33:-25] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \\n else:\\n if not os.path.isdir(sv + image[i][0][-40:-32] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-40:-32] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-40:-32] + \\\"/\\\" + label[i]+image[i][0][-40:-32] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\\n plt.close()\",\n \"def create_images(self):\\n font = ImageFont.truetype(str(self.font_file), 45, encoding=\\\"utf-8\\\")\\n for letter in self.hebrew.letter_li:\\n (self.training_folder / letter).mkdir(parents=True, exist_ok=True)\\n\\n for i in range(len(self.hebrew.font_li)):\\n letter_path = self.training_folder / Path(self.hebrew.letter_li[i])\\n text = self.hebrew.font_li[i]\\n text_width, text_height = font.getsize(text)\\n canvas = Image.new(\\\"RGB\\\", (text_width + 15, text_height + 20), \\\"white\\\")\\n draw = ImageDraw.Draw(canvas)\\n draw.text((10, 10), text, \\\"black\\\", font)\\n canvas.save(\\n Path(letter_path / Path(f\\\"{self.hebrew.letter_li[i]}_original.jpeg\\\")),\\n \\\"JPEG\\\",\\n )\",\n \"def createNew(string):\\n image=Image.open('imageGenerator/images/images.jpg').convert('RGBA')\\n\\n fnt = ImageFont.truetype(\\\"fonts/arial.ttf\\\", 25)\\n d = ImageDraw.Draw(image)\\n\\n d.text((10,10), string, font=fnt, fill=(255,255,255,128))\\n\\n d.text((10,60), \\\"World\\\", fill=(255,255,255,255))\\n file=byt()\\n image.save(file,'jpeg')\\n return file.getvalue()\",\n \"def create_output_image(building_footprint, parcel_footprint, file_path):\\n fig, ax = plt.subplots(figsize=(10, 10))\\n gpd.overlay(building_footprint, parcel_footprint, how=\\\"symmetric_difference\\\").plot(\\n ax=ax, color=\\\"lightgray\\\"\\n )\\n parcel_footprint.geometry.exterior.buffer(0.25).plot(ax=ax, color=\\\"black\\\")\\n building_footprint.plot(ax=ax, color=\\\"black\\\")\\n\\n ax.patch.set_facecolor(\\\"white\\\")\\n ax.patch.set_edgecolor(\\\"white\\\")\\n fig.patch.set_visible(False)\\n ax.axis(\\\"off\\\")\\n fig.savefig(\\n file_path,\\n bbox_inches=\\\"tight\\\",\\n pad_inches=0,\\n facecolor=\\\"white\\\",\\n edgecolor=\\\"white\\\",\\n quality=IMG_QUALITY,\\n )\\n plt.close()\",\n \"def create_png_images(self):\\n if self.subject is None:\\n print Console.WARNING + 'You need to specify a subject first' + Console.ENDC\\n return\\n\\n check_dir_of = self.locations.check_dir_of\\n check_dir_of(self.locations.HISTO_PNG_U)\\n check_dir_of(self.locations.HISTO_PNG)\\n check_dir_of(self.locations.SOURCE_PNG)\\n\\n\\n\\n fmap_img = ImageUtils.load_nifti_image(self.locations.HIST_FMAP) #loading subject nifti files\\n volumes = []\\n try:\\n for s in self.locations.SOURCES:\\n volumes.append(ImageUtils.load_nifti_image(s))\\n except IOError as e:\\n print Console.FAIL + 'There are errors loading nifi files for subject %s'%self.subject + Console.ENDC\\n return False\\n \\n\\n num_slices = volumes[0].shape[2] #use first volume to check expected number of slices\\n\\n self.locations.create_empty_dir(self.locations.IMAGES_DIR)\\n\\n print 'Creating input PNGs for %s'%self.subject\\n for k, vol in enumerate(volumes):\\n for i in range(num_slices):\\n imslice = ImageUtils.data_to_bytescale_rgb(vol[:, :, i])\\n im = Image.fromarray(imslice)\\n im.save(self.locations.SOURCE_PNG % (self.locations.LABELS[k],i))\\n\\n \\n print 'Creating histology PNGs for %s'%self.subject\\n for i in range(num_slices):\\n\\n im_unscaled = ImageUtils.data_to_unscaled_rgb(fmap_img[:, :, i]); #keeps the original values\\n im_unscaled = Image.fromarray(im_unscaled)\\n im_unscaled = im_unscaled.filter(ImageFilter.GaussianBlur(radius=2)) #Filter requested by Ali Khan\\n im_unscaled.save(self.locations.HISTO_PNG_U % i)\\n\\n im_scaled = ImageUtils.data_to_bytescale_rgb(fmap_img[:,:,i]); # bytescaled histology\\n im_scaled = Image.fromarray(im_scaled)\\n im_scaled = im_scaled.filter(ImageFilter.GaussianBlur(radius=2)) #Filter requested by Ali Khan\\n im_scaled.save(self.locations.HISTO_PNG % i)\\n\\n print\\n return True\",\n \"def save(self, x, y, names, path=\\\"\\\", zoom=False):\\n for i in range(len(x)):\\n image = self.generate(x[i], label=np.argmax(y[i]), zoom=zoom)\\n image = Image.fromarray((image*255).astype(\\\"uint8\\\"))\\n image.save(path + names[i] + \\\".png\\\", \\\"PNG\\\")\",\n \"def render_and_save():\\n\\n rendering_config = configuration.get_config()\\n rendering_config = ml_collections.FrozenConfigDict(rendering_config)\\n aspect_ratio = rendering_config.aspect_ratio\\n height = rendering_config.height\\n width = int(aspect_ratio * height)\\n\\n scene_camera = build_camera(rendering_config, aspect_ratio)\\n world = build_world(rendering_config)\\n\\n # Render.\\n logging.info(\\\"Tracing rays...\\\")\\n render_image_fn = jax.jit(\\n render.generate_image,\\n static_argnames=[\\\"height\\\", \\\"width\\\", \\\"config\\\"])\\n image = render_image_fn(height, width, scene_camera, world, rendering_config)\\n\\n image = render.correct_gamma(image, gamma=rendering_config.gamma_correction)\\n\\n logging.info(\\\"Saving to file...\\\")\\n output.export_as_ppm(image, rendering_config.output_file)\\n\\n return image\",\n \"def drawImage(self):\\n\\n image = Image.new(\\\"RGB\\\",self.size,(255,255,255)) #new() passes parameters mode,size,color\\n #255,255,255 is white\\n\\n canvas = ImageDraw.Draw(image)\\n for g in self.genes:\\n color = (g.color.r,g.color.g,g.color.b)\\n\\n canvas.ellipse((g.pos.x-int(g.diameter/2),g.pos.y-int(g.diameter/2), g.pos.x+int(g.diameter/2), g.pos.y+int(g.diameter/2)), fill = color)\\n return image\",\n \"def draw_image(res, train, label, output_dir, fig, write_file=False):\\n size = len(label)\\n infer_res, infer_conf, gt_conf = compare_result(res, label)\\n if not os.path.exists(output_dir+\\\"/correct\\\"):\\n os.makedirs(output_dir+\\\"/correct\\\")\\n if not os.path.exists(output_dir + \\\"/incorrect\\\"):\\n os.makedirs(output_dir + \\\"/incorrect\\\")\\n\\n if write_file:\\n cor = open(output_dir+\\\"/res_correct.txt\\\", 'a')\\n err = open(output_dir+\\\"/res_incorrect.txt\\\", 'a')\\n # right inferences\\n r = 0\\n # error inferences\\n e = 0\\n # error details\\n count = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\\n for i in range(size):\\n img = Image.fromarray(train[i].reshape(fig, fig).astype(np.uint8))\\n if infer_res[i] == label[i]:\\n r += 1\\n img.save(output_dir+\\\"/correct/\\\"+str(i)+\\\"_\\\"+str(infer_res[i])+\\\"_\\\"+str(infer_conf[i])+\\\".png\\\")\\n if write_file:\\n cor.write(str(i)+\\\"_\\\"+str(infer_res[i])+\\\"_\\\"+str(infer_conf[i])+str(res[i][0][0][0])+'\\\\n')\\n\\n else:\\n\\n e += 1\\n img.save(output_dir + \\\"/incorrect/\\\" + str(i) + \\\"_gt:\\\" + str(label[i]) + \\\"_\\\" + str(\\n gt_conf[i]) + \\\"_inf:\\\" + str(infer_res[i]) + \\\"_\\\" + str(infer_conf[i]) + \\\".png\\\")\\n count[label[i]] += 1\\n if write_file:\\n err.write(str(i) + \\\"_gt:\\\"+str(label[i]) + \\\"_\\\"+str(gt_conf[i]) + \\\"_inf:\\\"+str(infer_res[i])+\\\"_\\\" +\\n str(infer_conf[i]) + str(res[i][0][0][0]) + '\\\\n')\\n if write_file:\\n cor.close()\\n err.close()\\n print(\\\"correct inference results:\\\"+str(r))\\n print(\\\"incorrect inference results:\\\" + str(e))\\n print(\\\"incorrect inference results details:\\\" + str(count))\",\n \"def main(folder, outputfile):\\n parser = argument_parser()\\n args = parser.parse_args()\\n\\n show_all = args.show_all\\n verbose = args.verbose\\n\\n random.seed(args.rng_seed)\\n\\n args.files = folder\\n print args.files\\n\\n try:\\n image = Image.open(args.files[0])\\n except IOError, msg:\\n print >> sys.stderr, msg\\n return 1\\n if image.mode == 'P':\\n image = image.convert('RGB')\\n \\n if image.size[0] > args.w:\\n image = image.resize((args.w, int((float(args.w)/image.size[0]) *\\n image.size[1])), Image.ANTIALIAS)\\n\\n if not show_all:\\n def nothing(a, b):\\n pass\\n do_something = nothing\\n elif args.saving:\\n do_something = Imsave(\\\"saved/\\\" + args.files[0][:-4] + \\\"_\\\" +\\n str(image.size[0]) + \\\"/\\\").save\\n else:\\n import im_debug\\n do_something = im_debug.show\\n\\n if verbose:\\n import time\\n class Logger:\\n def __init__(self):\\n self.t = 0\\n\\n def __call__(self, m):\\n t_n = time.time()\\n if self.t > 0:\\n print >> sys.stderr, \\\"\\\\t\\\" + str(t_n - self.t)\\n print >> sys.stderr, m\\n self.t = t_n\\n logger = Logger()\\n\\n else:\\n def logger(m):\\n pass\\n \\n if args.manual_mode:\\n import manual\\n try:\\n lines = manual.find_lines(image)\\n except manual.UserQuitError:\\n #TODO ask user to try again\\n return 1\\n else:\\n if args.l_cache:\\n filename = (\\\"saved/cache/\\\" + args.files[0][:-4] + \\\"_\\\" +\\n str(image.size[0]))\\n cache_dir = \\\"/\\\".join(filename.split('/')[:-1])\\n if os.path.exists(filename):\\n lines, l1, l2, bounds, hough = pickle.load(open(filename))\\n print >> sys.stderr, \\\"using cached results\\\"\\n else:\\n lines, l1, l2, bounds, hough = linef.find_lines(image, do_something, logger)\\n if not os.path.isdir(cache_dir):\\n os.makedirs(cache_dir)\\n d_file = open(filename, 'wb')\\n pickle.dump((lines, l1, l2, bounds, hough), d_file)\\n d_file.close()\\n else:\\n lines, l1, l2, bounds, hough = linef.find_lines(image, do_something, logger)\\n\\n grid, lines = gridf.find(lines, image.size, l1, l2, bounds, hough,\\n show_all, do_something, logger)\\n if show_all:\\n im_g = image.copy()\\n draw = ImageDraw.Draw(im_g)\\n for l in grid[0] + grid[1]:\\n draw.line(l, fill=(64, 255, 64), width=1)\\n do_something(im_g, \\\"grid\\\", name=\\\"grid\\\")\\n\\n intersections = intrsc.b_intersects(image, lines, show_all, do_something, logger)\\n board = intrsc.board(image, intersections, show_all, do_something, logger)\\n\\n logger(\\\"finished\\\")\\n\\n # TODO! refactor this mess:\\n if len(args.files) == 1:\\n\\n if args.sgf_output:\\n print board.asSGFsetPos()\\n else:\\n print board\\n \\n else:\\n game = output.Game(19, board) #TODO size parameter\\n #for f in args.files[1:]:\\n for i, f in enumerate(args.files):\\n try:\\n image = Image.open(f)\\n except IOError, msg:\\n print >> sys.stderr, msg\\n continue\\n if verbose:\\n print >> sys.stderr, \\\"Opening\\\", f\\n if image.mode == 'P':\\n image = image.convert('RGB')\\n if image.size[0] > args.w:\\n image = image.resize((args.w, int((float(args.w)/image.size[0]) *\\n image.size[1])), Image.ANTIALIAS)\\n board = intrsc.board(image, intersections, show_all, do_something, logger)\\n if args.sgf_output:\\n game.addMove(board)\\n else:\\n with open(outputfile + str(i) + \\\".txt\\\", \\\"w\\\") as f:\\n f.write(str(board))\\n\\n if args.sgf_output:\\n print game.asSGF()\\n\\n return 0\",\n \"def save_png(self, filename):\\n post_script = self.canvas.postscript().encode()\\n img = Image.open(io.BytesIO(post_script))\\n img.save(filename, format=\\\"PNG\\\")\",\n \"def AA2Image(readpath, savepath, header, font_data):\\n if not os.path.isdir(savepath):\\n os.makedirs(savepath)\\n print('convert txt to png. save path: ', savepath)\\n\\n files = glob.glob(readpath+'*.txt')\\n\\n for file in files:\\n ascii_art = AsciiArt(file)\\n ascii_art_image = ascii_art.image(font_data)\\n filename = header + os.path.basename(file)[:-4] + '.png'\\n ascii_art_image = Image.fromarray(ascii_art_image)\\n ascii_art_image = ascii_art_image.convert('L')\\n ascii_art_image.save(savepath + filename)\\n print('saved ', filename)\",\n \"def plotSate(s,i,seed):\\r\\n fig, ax = plt.subplots()\\r\\n\\r\\n im = ax.imshow(s)\\r\\n\\r\\n plt.xticks([i for i in range(dim)], \\\"\\\")\\r\\n plt.yticks([i for i in range(dim)], \\\"\\\")\\r\\n\\r\\n fig.tight_layout()\\r\\n plt.savefig(\\\"Systems/\\\" + str(dim) + \\\"_\\\" + str(seed) + \\\"/Images/\\\" + str(i) +\\r\\n \\\".jpeg\\\",quality=80,optimize=True,\\r\\n dpi=80,progressive=True,transparent=True)\\r\\n fig.clear()\\r\\n plt.close(fig)\",\n \"def save(self, fn):\\n plt.imsave(fn, self.image)\",\n \"def paint_a_picture():\\n # Make a training set (many random i,j coord and an x by y box around that coord to start with)\\n # Throw it into the net\\n # Test how it does for some random coordinate inputs\\n pass\",\n \"def export_image(self, name):\\n\\t\\tred = Color(\\\"red\\\")\\n\\t\\tblue = Color(\\\"blue\\\")\\n\\t\\twhite = Color(\\\"white\\\")\\n\\t\\tblack = Color(\\\"black\\\")\\n\\t\\tgold = Color(\\\"gold\\\")\\n\\t\\trgb_gold = []\\n\\t\\tfor part in gold.rgb:\\n\\t\\t\\tpart = part * 255\\n\\t\\t\\trgb_gold.append(part)\\n\\t\\trgb_black = []\\n\\t\\tfor part in black.rgb:\\n\\t\\t\\tpart = part * 255\\n\\t\\t\\trgb_black.append(part)\\n\\t\\trgb_white = []\\n\\t\\tfor part in white.rgb:\\n\\t\\t\\tpart = part * 255\\n\\t\\t\\trgb_white.append(part)\\n\\t\\tcolours = list(red.range_to(blue, int(self.grains)))\\n\\t\\timage = np.zeros([self.space.shape[1],self.space.shape[0], 3], dtype=np.uint(8))\\n\\t\\tfor grain in range(self.grains+1):\\n\\t\\t\\trgb = []\\n\\t\\t\\tfor part in colours[grain-1].rgb:\\n\\t\\t\\t\\tpart = part * 255\\n\\t\\t\\t\\trgb.append(part)\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state == grain:\\n\\t\\t\\t\\t\\tx,y = cell.find_id()\\n\\t\\t\\t\\t\\timage[x,y] = rgb\\n\\t\\t\\t\\tif cell.state == 999:\\n\\t\\t\\t\\t\\tx,y = cell.find_id()\\n\\t\\t\\t\\t\\timage[x,y] = rgb_black\\n\\t\\t\\t\\tif cell.state == 500:\\n\\t\\t\\t\\t\\tx,y = cell.find_id()\\n\\t\\t\\t\\t\\timage[x,y] = rgb_gold\\n\\t\\timg = Image.fromarray(image.astype('uint8'))\\n\\t\\timg = img.resize((self.space.shape[1]*3,self.space.shape[0]*3))\\n\\t\\timg.save('./static/temp/'+str(name)+'.png')\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def save(self, filename):\\n try:\\n import PIL\\n except ImportError:\\n raise RuntimeError('Could not import PIL. PIL (pillow) is required to save fresnel images.')\\n else:\\n if self._output is None:\\n self.render()\\n image = PIL.Image.fromarray(self._output[:], mode='RGBA')\\n image.save(filename)\",\n \"def testImage():\\n width = 200\\n height = 200\\n image = BitMap( width, height )\\n \\n # create a loop in order to draw some pixels\\n \\n for col in range(width):\\n if col % 10 == 0: print 'col is', col\\n for row in range(height):\\n if col % 10 == 0 or row % 10 == 0:\\n image.plotPoint( col, row ) \\n \\n # we have now looped through every image pixel\\n # next, we write it out to a file\\n \\n image.saveFile( \\\"test.bmp\\\" )\\n #changing the col and row number determines how big the grid is for the picture or how zoomed in it is. Changing the and to or just makes the grid go from dotted grid to lines.\",\n \"def save(\\n self,\\n output_path: str,\\n show_confidence: bool = True,\\n ) -> None:\\n image = self.draw(show_confidence=show_confidence)\\n save_image(image=image, path=output_path)\",\n \"def render(self, save_name: str = 'my_image.png') -> None:\\n out = self.render_mat()\\n skimage.io.imsave(save_name, out.transpose((1, 2, 0)))\\n return None\",\n \"def generate_image_file(color):\\n img = generate_image(color)\\n img.save(IMAGE_FILE)\\n return IMAGE_FILE\",\n \"def save(image, name):\\n from matplotlib import pyplot\\n import matplotlib as mpl\\n fig = pyplot.figure()\\n ax = fig.add_subplot(1,1,1)\\n imgplot = ax.imshow(image, cmap=mpl.cm.Greys)\\n imgplot.set_interpolation('nearest')\\n ax.xaxis.set_ticks_position('top')\\n ax.yaxis.set_ticks_position('left')\\n pyplot.savefig(name)\",\n \"def generate_lambda_art(filename, x_size=350, y_size=350):\\n # Functions for red, green, and blue channels - where the magic happens!\\n r_lb = random.randint(1, 2)\\n g_lb = random.randint(1, 2)\\n b_lb = random.randint(1, 2)\\n red_function = r_lambda_func(1)\\n green_function = r_lambda_func(1)\\n blue_function = r_lambda_func(1)\\n print(red_function)\\n print(red_function)\\n print(red_function(0.0, 1.0))\\n print(red_function(1.0, 0.05))\\n print(red_function(1.0, 0.0))\\n\\n # Create image and loop over all pixels\\n im = Image.new(\\\"RGB\\\", (x_size, y_size))\\n pixels = im.load()\\n for i in range(x_size):\\n for j in range(y_size):\\n x = remap_interval(i, 0, x_size, -1, 1)\\n y = remap_interval(j, 0, y_size, -1, 1)\\n pixels[i, j] = (\\n color_map(red_function(x, y)),\\n color_map(green_function(x, y)),\\n color_map(blue_function(x, y))\\n )\\n im.save(filename)\\n return 'saved'\",\n \"def __save_display_image(self):\\n\\n try:\\n self.photomosaic_generator.can_save_image()\\n if self.generating:\\n raise MissingComponentError('Cannot save. Image is currently being generated.')\\n except MissingComponentError as error_msg:\\n error_msg_box = QtWidgets.QMessageBox.critical(self, 'Error', str(error_msg))\\n else:\\n options = QtWidgets.QFileDialog.Options()\\n options |= QtWidgets.QFileDialog.DontUseNativeDialog\\n file_name, file_type = QtWidgets.QFileDialog.getSaveFileName(self, 'Save photomosaic', '..',\\n 'jpg (*.jpg);;png (*.png)', options=options)\\n file_type = file_type[-5:-1]\\n if file_name != '':\\n self.photomosaic_generator.save_image(file_name + file_type if file_name[-4:] != file_type else\\n file_name)\",\n \"def save_figure(self, data):\\n\\n\\t\\tsizes = np.shape(data)\\n\\t\\tfig = plt.figure()\\n\\t\\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\\n\\t\\tax = plt.Axes(fig, [0., 0., 1., 1.])\\n\\t\\tax.set_axis_off()\\n\\t\\tfig.add_axes(ax)\\n\\t\\tax.imshow(data, \\\"gray\\\")\\n\\n\\t\\t#plt.show()\\n\\t\\tself.plotfile = os.path.join('static', 'Figure' + '.png')\\n\\t\\tplt.savefig(self.plotfile, dpi = sizes[1])\",\n \"def test_save_png():\\n img = Image.new('RGB', (10, 20))\\n\\n parameters = {'path': 'green-dot.png', 'data': [img]}\\n\\n assert images.save(parameters)\",\n \"def save_image(start, stop, imgcount, label):\\n text = \\\"\\\"\\n imgfile = select_file(label)\\n for p in range(imgcount):\\n pxcnt = randint(start, stop)\\n imgcurrent = create_image(imgfile, pxcnt)\\n filename = \\\"img_train_\\\" + str(label) + \\\"_\\\" + str(p) + \\\"_\\\" + str(pxcnt) + \\\".png\\\"\\n text += \\\"ctq/dataset/train/\\\" + filename + \\\" \\\" + str(label) + \\\"\\\\n\\\"\\n imgcurrent.save(filename)\\n text_file = open(imgfile + \\\"_train_label.txt\\\", \\\"w\\\")\\n text_file.write(text)\\n text_file.close()\",\n \"def DrawCostMatrixAndPath( self, fname ):\\n f = open(fname, 'w')\\n w = len(self.D[0])\\n h = len(self.D)\\n f.write(\\\"img=None\\\\n\\\\ndef setup():\\\\n\\\\tglobal img\\\\n\\\")\\n f.write(\\\"\\\\tsize(%d,%d)\\\\n\\\"%( 5*w,5*h ))\\n f.write(\\\"\\\\timg = createImage( %d, %d, RGB )\\\\n\\\"%(w,h))\\n f.write(\\\"\\\\timg.loadPixels()\\\\n\\\")\\n mx = max([ max([ x for x in row]) for row in self.D])\\n pixels = []\\n i=0\\n for r,row in enumerate(self.D):\\n for c,cell in enumerate(row):\\n pixels.append( int( 255.0*cell/mx ) )\\n if( (r,c) in self.P ):\\n pixels[-1] = 255\\n i += 1\\n for i,p in enumerate(pixels):\\n f.write(\\\"\\\\timg.pixels[%d] = color(%d)\\\\n\\\"%(i,p))\\n f.write(\\\"\\\\timg.updatePixels()\\\\n\\\\ndef draw():\\\\n\\\\tglobal img\\\\n\\\\timage(img,0,0,%d,%d)\\\\n\\\"%(5*w,5*h))\\n f.close()\",\n \"def makePNG(self,outDir=os.getcwd(),tmpFname='temp.R'):\\n rscript = \\\"\\\"\\\"\\nname<-'%s'\\ncontig<-'%s'\\nstart<-%d\\nend<-%d\\nstrand<-'%s'\\nexonLengths<-c(%s)\\nexonOffsets<-c(%s)\\nmyLen<-end-start+1\\n\\npng(filename=paste('%s/',name,'.png',sep=''),width=900,height=300)\\nplot.new()\\nplot.window(xlim=c(start,end),ylim=c(0,3))\\naxis(1)\\ntitle(xlab=contig)\\ntitle(main=name)\\nlines(seq(start,end+1),rep(1,myLen+1),col='blue',lwd=2,lend='butt')\\n\\nsegments(start+exonOffsets,rep(1,length(exonOffsets)),start+exonOffsets+exonLengths,rep(1,length(exonOffsets)),col='blue',lwd=20,lend='butt')\\nif (strand=='+'){\\n arrows(start,1.5,(start+(myLen*0.05)),1.5,length=0.125,lwd=1.5,angle=30,col='black')\\n} else if (strand=='-') {\\n arrows(end,0.5,(end-(myLen*0.05)),0.5,length=0.125,lwd=1.5,angle=30,col='black')\\n}\\n\\n\\ndev.off()\\\"\\\"\\\" % (self.name,self.chr,self.start,self.end,self.strand,\\\",\\\".join([str(x) for x in self.exonLengths]),\\\",\\\".join([str(x) for x in self.exonOffsets]),outDir)\\n tmpHandle = open(tmpFname,'w')\\n print >>tmpHandle, rscript\\n tmpHandle.close()\\n commands.getoutput('R CMD BATCH --vanilla %s' % tmpFname)\\n os.remove(tmpFname)\\n return\",\n \"def draw_im(self, fname):\\n im = self.get_im()\\n im_agraph = nx.nx_agraph.to_agraph(im)\\n im_agraph.draw(fname, prog='dot')\",\n \"def run_turtle_program(source):\\n ast = parser.parse(source)\\n\\n t = turtle.Turtle()\\n for stmt in ast.statement:\\n do_statement(stmt, t)\\n canvas = turtle.Screen().getcanvas()\\n canvas.postscript(file='image.eps')\\n img = Image.open('image.eps')\\n img.save('image.png', 'png')\\n turtle.Screen().bye()\\n return 'image.png'\",\n \"def save_images(self, samples, label=None, dir=\\\"\\\"):\\n if label is None:\\n label = self.global_step_\\n fig = plt.figure()\\n self.net_.eval()\\n self.dist.visualize(fig, samples, self.energy)\\n plot_fn = os.path.join(dir, f\\\"samples_{label}.png\\\")\\n fig.savefig(plot_fn)\\n plt.close(fig)\",\n \"def clumpy_graph(self,img):\\n \\n id = self._getGraphId()\\n root = 'S_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n doStamp(img.copy(),pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n try : Painted.load()\\n except IOError : stop()\\n text = 'S=%5.2f' % (self['M_S'])\\n # Painted.Graffiti(text,commtextpos)\\n Painted.save(jpgname) \\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n self['figures']['S'] = epsname\\n self['figcomms']['S'] = text\",\n \"def displayImage():\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"r\\\")\\n epochNum = int(f.readline())\\n f.close()\\n return Image.open(\\\"outputPhotosColor/image_at_epoch_{:04d}.png\\\".format(epochNum))\",\n \"def generate(self, chars, format='png'):\\n im = self.generate_image(chars)\\n out = BytesIO()\\n im.save(out, format=format)\\n out.seek(0)\\n return out\",\n \"def _saveFig(self):\\r\\n # Save plot\\r\\n filenameG = self._vna.getDateFormatted() + \\\".png\\\"\\r\\n filenameG = \\\"Graphs/\\\" + filenameG \\r\\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\\r\\n plt.clf()\",\n \"def to_figure(self, structure):\\n if not self.bypass:\\n if self.format is \\\"show\\\":\\n plt.show()\\n elif self.format is \\\"png\\\":\\n plt.savefig(self.path + self.filename + \\\".png\\\", bbox_inches=\\\"tight\\\")\\n elif self.format is \\\"fits\\\":\\n if structure is not None:\\n structure.output_to_fits(\\n file_path=self.path + self.filename + \\\".fits\\\", overwrite=True\\n )\",\n \"def save_dataset_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n cols = 3\\n rows = 3\\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\\n # Random sample of images\\n save_name = \\\"training_data_sample.png\\\"\\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\\n for row in range(rows):\\n for col in range(cols):\\n idx = np.random.randint(0, len(lines))\\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\\n ax[row, col].set_title(\\\"Angle = \\\" + str(round(lines[idx][1], 3)))\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\\n # Distribution of steering angles\\n save_name = \\\"data_histogram.png\\\"\\n fig_size = (5, 3) # Figure width and height, in inches\\n num_bins = 100\\n angles = np.array([line[1] for line in lines])\\n hist, bins = np.histogram(angles, bins=num_bins)\\n fig = plt.figure(figsize=fig_size)\\n plt.bar(bins[:-1], hist)\\n plt.xlabel(\\\"Steering Angle\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.title(\\\"Distribution of Steering Angles in Training Data\\\")\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def generatePreview(self):\\n self.saveParameters()\\n image=self.simulation.generatePreview()\\n # convert pil image to a tkinter image\\n self.photo = ImageTk.PhotoImage(image)\\n\\n # display image\\n self.preview.create_image(0, 0, anchor='nw', image=self.photo)\",\n \"def draw(canvas_result,automatic_save,manual_save):\\r\\n if canvas_result is not None and canvas_result.image_data is not None and (automatic_save or manual_save):\\r\\n # Receive the user's drawing with the dimensions: 512X512X4\\r\\n img_data = canvas_result.image_data\\r\\n # the user's drawing is in RGBA mode with floats instead of integers - convert to uint8 type and to RGB format\\r\\n im = Image.fromarray(img_data.astype(np.uint8)[:,:,:3]).convert('RGB') # convert to dimensions 512X512X3\\r\\n # initialize a copy of the user's drawing.\\r\\n add_bg = np.array(im, dtype='uint8') # initalize a copy\\r\\n # allow the user to know that the saving is in progress.\\r\\n with st.spinner(\\\"Saving image...\\\"):\\r\\n # the drawing is lack of the GauGAN background because streamlit_drawable_canvas library doesn't allow it yet.\\r\\n # Because of that the background will be added manually - o(n^3) at the moment.\\r\\n for i in range(add_bg.shape[0]):\\r\\n for j in range(add_bg.shape[1]):\\r\\n if list(add_bg[i,j]) != [0,0,0]: # if the current RGB value is not (0,0,0) (black) -\\r\\n for k in range(add_bg.shape[2]): # then make sure we don't have white values (255)\\r\\n if add_bg[i,j][k] == 255: # we will fill them with the relevant background color position\\r\\n add_bg[i,j][k] = colors['Sky'][k] if i<300 else colors['Sea'][k]\\r\\n else: # else, we do indeed have RGB value of (0,0,0), then replace it by its entirety to the relevant\\r\\n # background color.\\r\\n add_bg[i,j] = colors['Sky'] if i<300 else colors['Sea']\\r\\n\\r\\n # Create PIL object of the manually added background with drawing on the canvas\\r\\n add_bg = Image.fromarray(add_bg)\\r\\n # Assign the path where the file will be saved\\r\\n if not os.path.exists(\\\"tmp/\\\"):\\r\\n os.makedirs(\\\"tmp/\\\")\\r\\n file_path = f\\\"tmp/pic%s.png\\\"%(len(counter))\\r\\n # Increase the counter by adding dummy element into the counter list\\r\\n counter.append(0)\\r\\n # Save the drawing in PNG format\\r\\n\\r\\n add_bg.save(file_path, \\\"PNG\\\")\\r\\n st.success(\\\"Image saved successfully. Keep drawing!!\\\")\",\n \"def add_art(self,path,size=\\\"500\\\"):\\n error=False\\n if path:\\n print(\\\"processing %s to %s\\\" % (path,self.uid))\\n f=open(path,'rb') \\n filedata=f.read()\\n extension=(imghdr.what('',filedata) or path.rsplit(\\\".\\\")[-1].lower()).replace('jpeg','jpg')\\n if not filedata:\\n error= \\\"NO IMAGE FOUND AT '%s'\\\" % path\\n print(error)\\n elif extension in ('bmp','png'):\\n filedata=self.Image.convert(filedata)\\n extension='jpg' \\n elif extension not in ('gif','png','jpg','jpeg'):\\n error=\\\"only JPEG, GIF, PNG, and BMP are supported\\\"\\n print(error)\\n if not error:\\n # create a new image page\\n image=self.Image.new()\\n image.parent=self.uid\\n image.kind='image'\\n image.seq=0xFFFFFF#place at end of siblings\\n # set default size \\n image.stage='right full %sx%s' % (size,size) #rest of stage data will be added on the fly later by get_stage_data() \\n image.set_lineage()\\n image.code=\\\"%s.%s\\\" % (image.uid,extension)\\n image.when=DATE()\\n image.flush() #store the image page\\n image.renumber_siblings_by_kind()#keep them in order\\n # save the image file\\n image.save_file(filedata)\\n # return\\n print('image \\\"%s\\\" added' % image.code)\\n return image\\n return None\",\n \"def make_montage(infile):\\n\\n #create a blank image\\n blank = Image.new(\\\"RGB\\\", OUTPIC_SIZE ,(25,23,24,255))\\n\\n #paste the background\\n bg = Image.open(BACKGROUND_FILENAME)\\n blank.paste(bg,(0,0))\\n \\n #paste the raw picture\\n im = Image.open(infile)\\n \\n # past on background\\n blank.paste(im,OUTPIC_PHOTO_OFFSET)\\n\\n #paste the stickers layer on the pic (a transparent png)\\n stickers = Image.open(STICKERS_FILENAME)\\n blank.paste(stickers,(0,0),stickers)\\n\\n return blank\",\n \"def make_mosaic(target_im, saved_file_name):\\n BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\\n color_data_file = os.path.join(BASE_DIR, 'static/images/data/average_color.csv')\\n color_data = materials_list_from_file(color_data_file)\\n\\n target_file = os.path.join(BASE_DIR, 'static/images/target/{}'.format(target_im))\\n icon_im = image_process.open_image_RGB(target_file)\\n icon_im_width, icon_im_height = icon_im.size\\n mosaic_icon_im = Image.new('RGBA', (1600, 1600))\\n\\n for left in range(0, icon_im_width, DOT_AREA_ONE_SIDE):\\n for top in range(0, icon_im_height, DOT_AREA_ONE_SIDE):\\n average_color = calc.average_color_in_range(icon_im, left, top,\\n left+DOT_AREA_ONE_SIDE, top+DOT_AREA_ONE_SIDE)\\n if len(average_color) != 3:\\n continue\\n\\n filename = similar_color_filename(average_color, color_data)\\n # 距離最小のファイルを1600×1600の画像に貼り付け\\n open_file = os.path.join(BASE_DIR, 'static/images/material/euph_part_icon/'+filename)\\n area_im = Image.open(open_file)\\n mosaic_icon_im.paste(area_im, (left//DOT_AREA_ONE_SIDE * THUMBNAIL_ONE_SIDE,\\n top//DOT_AREA_ONE_SIDE * THUMBNAIL_ONE_SIDE))\\n\\n saved_file_path = 'static/images/ftnext/{}'.format(saved_file_name)\\n saved_file = os.path.join(BASE_DIR, saved_file_path)\\n mosaic_icon_im.save(saved_file)\",\n \"def write_png(self, output_name):\\n self.fig.savefig(output_name)\\n return\",\n \"def write(self, chars, output, format='png'):\\n im = self.generate_image(chars)\\n return im.save(output, format=format)\",\n \"def fc_visual_save(fc, lowweight, savenamefile_prefix):\\r\\n\\r\\n\\r\\n ### text setup for brain areas ###\\r\\n pos_text_lefttop1 = [-80, 50, 30]\\r\\n pos_text_middletop1 = [120, 50, 30]\\r\\n pos_text_lefttop2 = [-80, 70, 10]\\r\\n pos_text_leftDown1 = [-80, 550, 30]\\r\\n pos_text_leftDown2 = [-80, 570, 10]\\r\\n pos_text_leftDown3 = [-80, 580, 10]\\r\\n \\r\\n texts_org = dict()\\r\\n\\r\\n lowweight = np.round(lowweight, decimals = 2) \\r\\n\\r\\n # plot\\r\\n df_chninf = assign_coord2chnArea(area_coord_file, fc['chnAreas'])\\r\\n for ci, cond in enumerate(fc['ciCOH'].keys()):\\r\\n ciCOH = fc['ciCOH'][cond]\\r\\n ntrials, ntemp = fc['setup']['ntrials_' + cond], fc['setup']['ntemp_' + cond]\\r\\n\\r\\n\\r\\n texts = texts_org.copy()\\r\\n \\r\\n text_thred = 'thred = ' + str(np.round(lowweight, decimals = 2))\\r\\n text_ntrials = 'ntrials = ' + str(ntrials)\\r\\n\\r\\n texts[cond] = pos_text_middletop1\\r\\n texts[text_task] = pos_text_leftDown1\\r\\n texts[text_ntrials] = pos_text_leftDown2\\r\\n texts[text_thred] = pos_text_leftDown3\\r\\n \\r\\n\\r\\n saveFCGraph = os.path.join(savefolder, savenamefile_prefix + '_lw' + str(np.round(lowweight, decimals = 2)) + '_' + cond + '.png')\\r\\n\\r\\n igplot = ciCOH_visual_save(ciCOH = ciCOH, chnInf = df_chninf, lowweight = lowweight, \\r\\n savefile = saveFCGraph, texts = texts, threds_edge = None)\\r\\n\\r\\n del texts[cond], texts[text_ntrials]\\r\\n\\r\\n img = cv2.imread(saveFCGraph)\\r\\n if ci == 0:\\r\\n imgs = img\\r\\n else:\\r\\n imgs = np.concatenate((imgs, np.zeros((img.shape[0], 5, 3)),img), axis = 1)\\r\\n\\r\\n os.remove(saveFCGraph)\\r\\n\\r\\n # combine all conditions\\r\\n print(imgs.shape)\\r\\n saveFCGraph_comb = os.path.join(savefolder, 'comb_' + savenamefile_prefix + '_lw' + str(np.round(lowweight, decimals = 2)) + '.png')\\r\\n cv2.imwrite(saveFCGraph_comb, imgs)\",\n \"def main():\\n fg = SimpleImage('image_contest/me.jpg')\\n bg = SimpleImage('image_contest/house.png')\\n bg.make_as_big_as(fg)\\n combined_img = combine(bg, fg)\\n combined_img.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71219194","0.69798446","0.68660295","0.6794313","0.6750983","0.66667235","0.6619679","0.64958155","0.6475446","0.6467824","0.6457414","0.6439815","0.6421548","0.64128166","0.64050144","0.6403127","0.63413537","0.6339301","0.63320214","0.63320214","0.63320214","0.63307863","0.6312027","0.6273251","0.62532246","0.62352294","0.6219724","0.6219724","0.6197829","0.6176649","0.61469585","0.6141042","0.6117803","0.611441","0.60925096","0.6089628","0.6086651","0.6082945","0.6078944","0.6070758","0.6068037","0.6043893","0.6038581","0.6026174","0.6023653","0.6012143","0.6009605","0.6006313","0.5995968","0.5979111","0.59742725","0.5971862","0.5967628","0.59553653","0.59529835","0.59466344","0.5945357","0.5940933","0.59406835","0.59393424","0.5937474","0.59236324","0.5919046","0.5910703","0.5904075","0.59034544","0.590219","0.59005","0.58910453","0.5889493","0.588855","0.5887311","0.5875568","0.5874886","0.58523196","0.5841721","0.5832168","0.58134186","0.5807563","0.5806564","0.5798774","0.5790734","0.57900673","0.5789332","0.578778","0.57772344","0.5772434","0.5771308","0.5770545","0.5765406","0.5760083","0.57567143","0.5756393","0.57563466","0.5751258","0.57507277","0.57472855","0.5742224","0.57386506","0.57348406"],"string":"[\n \"0.71219194\",\n \"0.69798446\",\n \"0.68660295\",\n \"0.6794313\",\n \"0.6750983\",\n \"0.66667235\",\n \"0.6619679\",\n \"0.64958155\",\n \"0.6475446\",\n \"0.6467824\",\n \"0.6457414\",\n \"0.6439815\",\n \"0.6421548\",\n \"0.64128166\",\n \"0.64050144\",\n \"0.6403127\",\n \"0.63413537\",\n \"0.6339301\",\n \"0.63320214\",\n \"0.63320214\",\n \"0.63320214\",\n \"0.63307863\",\n \"0.6312027\",\n \"0.6273251\",\n \"0.62532246\",\n \"0.62352294\",\n \"0.6219724\",\n \"0.6219724\",\n \"0.6197829\",\n \"0.6176649\",\n \"0.61469585\",\n \"0.6141042\",\n \"0.6117803\",\n \"0.611441\",\n \"0.60925096\",\n \"0.6089628\",\n \"0.6086651\",\n \"0.6082945\",\n \"0.6078944\",\n \"0.6070758\",\n \"0.6068037\",\n \"0.6043893\",\n \"0.6038581\",\n \"0.6026174\",\n \"0.6023653\",\n \"0.6012143\",\n \"0.6009605\",\n \"0.6006313\",\n \"0.5995968\",\n \"0.5979111\",\n \"0.59742725\",\n \"0.5971862\",\n \"0.5967628\",\n \"0.59553653\",\n \"0.59529835\",\n \"0.59466344\",\n \"0.5945357\",\n \"0.5940933\",\n \"0.59406835\",\n \"0.59393424\",\n \"0.5937474\",\n \"0.59236324\",\n \"0.5919046\",\n \"0.5910703\",\n \"0.5904075\",\n \"0.59034544\",\n \"0.590219\",\n \"0.59005\",\n \"0.58910453\",\n \"0.5889493\",\n \"0.588855\",\n \"0.5887311\",\n \"0.5875568\",\n \"0.5874886\",\n \"0.58523196\",\n \"0.5841721\",\n \"0.5832168\",\n \"0.58134186\",\n \"0.5807563\",\n \"0.5806564\",\n \"0.5798774\",\n \"0.5790734\",\n \"0.57900673\",\n \"0.5789332\",\n \"0.578778\",\n \"0.57772344\",\n \"0.5772434\",\n \"0.5771308\",\n \"0.5770545\",\n \"0.5765406\",\n \"0.5760083\",\n \"0.57567143\",\n \"0.5756393\",\n \"0.57563466\",\n \"0.5751258\",\n \"0.57507277\",\n \"0.57472855\",\n \"0.5742224\",\n \"0.57386506\",\n \"0.57348406\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6785918"},"document_rank":{"kind":"string","value":"4"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":936,"numItemsPerPage":100,"numTotalItems":95772,"offset":93600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTUyMzI3MiwianRpIjoiZmYzMGIwYjEtOTRjNS00M2UxLWEyYTMtZjRkNDY1ZWE4Yjg5Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU1MjY4NzIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.6GrgbWevOMX1_y3pnBsYXl1oHbP72Zk_Xqm8yI1cjWifJUrqxFqBmG-4vRz590oPIjWyWYm_RqZqgVJaDBoqDg","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 |
|---|---|---|---|---|---|---|
evolve the timedependent parameter of a lattice and generate effective Floquet Hamiltonian. | def evolve(self, k_vec, Nt,**kwargs):
M_eff = np.eye((self.Nd), dtype=complex) # aux matrix
T = 1.
for it in range(Nt):
# update the Hamiltonian for time-inteval
self.updateH(k_vec, it)
# return eigenenergies and vectors
E_k, U... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fixed_time_trajectories(self, ll=1, distributions=None, discrete=False, noise=0):\n\n self.time_uniform = np.linspace(0, self.nsteps, self.nsteps * self.padding)\n\n for t in tqdm.tqdm(range(self.ntraj)):\n\n if distributions is not None:\n\n if self.dwell_distribution =... | [
"0.58629954",
"0.5750387",
"0.57404524",
"0.5549065",
"0.55443007",
"0.5536246",
"0.54893523",
"0.54871595",
"0.5463197",
"0.54461116",
"0.5366601",
"0.5366318",
"0.5358426",
"0.53489166",
"0.5338671",
"0.5337355",
"0.53291744",
"0.52639544",
"0.52473766",
"0.5245468",
"0.522... | 0.0 | -1 |
a Hamiltonian in (kx,ky) is given, evaluate the bandstructire of a static Hamiltonian E(kx,ky) | def band_structure_static(self, kx_range, ky_range, N_res):
kxR = np.linspace(kx_range[0], kx_range[1], N_res)
kyR = np.linspace(ky_range[0], ky_range[1], N_res)
E_arr = np.zeros((2,N_res,N_res), float)
# mesh over area in k-space
# Kx, Ky = np.meshgrid(kx,ky)
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Ham_eigvals(self,kx,ky):\n tHam=self.Ham_gen(kx,ky)\n eigval=np.linalg.eigvals(tHam)\n sidc=eigval.argsort()\n eigval=eigval[sidc]\n return eigval.real",
"def Hamiltonian(self):\n U = self.U.flatten()\n Vmat = sparse.spdiags([U], [0], len(U), len(U))\n ... | [
"0.6993806",
"0.6351405",
"0.631668",
"0.6173396",
"0.6048931",
"0.5919147",
"0.59026694",
"0.5856373",
"0.5856373",
"0.5840797",
"0.58045894",
"0.5798676",
"0.57981175",
"0.57474506",
"0.5734695",
"0.57284135",
"0.5721163",
"0.5689188",
"0.5662637",
"0.56574494",
"0.5643961"... | 0.63015884 | 3 |
a Hamiltonian in (kx,ky,t) is given, evaluate the quasienergy bandstructire of a dynamic Hamiltonian E(kx,ky) | def band_structure_dynamic(self, kx_range, ky_range, N_res):
kxR = np.linspace(kx_range[0], kx_range[1], N_res)
kyR = np.linspace(ky_range[0], ky_range[1], N_res)
Nt = 3
E_arr = np.zeros((2,N_res,N_res), float)
# mesh over area in k-space
# Kx, Ky = np.meshgrid(k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def band_energy(k,t=1.0,e0=0.2,a=1.0):\n return e0-t*np.exp(1j*k*a)-t*np.exp(-1j*k*a)",
"def eval_H_QQ(psi, times, args, options=0):\n n = args['n']\n ad = create(n)\n a = destroy(n)\n # the following string describes the time dependant frequency\n strWQQ = 'w0 + dw1*exp(-0.5*(t/dt1)**2) + dw2*... | [
"0.6612545",
"0.65755147",
"0.65446347",
"0.6436535",
"0.63812095",
"0.6202196",
"0.61459804",
"0.61459804",
"0.6124098",
"0.6100168",
"0.609041",
"0.6084095",
"0.6073878",
"0.6059432",
"0.59335494",
"0.59044564",
"0.5862369",
"0.5858024",
"0.5854256",
"0.5809938",
"0.579559"... | 0.57978314 | 20 |
To calculate the Chern number of the Hamiltonian (or the Floquet Hamiltonian) over its Brillouin zone (BZ). | def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]),
ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]),
N_res=30):
x_eps = 0.3 # shift from Dirac point
x_res = 20
kx_int = 0 + x_eps # -np.pi
kx_fin = 4*np.pi/3 + x_eps
Dx = (kx_fin - kx_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chibar(z):\n return chi(z)",
"def king(r, n0, rc, b):\n return n0 * (1. + (r/rc)**2)**b",
"def Z(n):\n count5 = 0\n i = 1\n while 1:\n a = pow(5, i)\n if a > n:\n return count5\n else:\n count5 += n/a\n i += 1",
"def schmidt_number(self... | [
"0.6322738",
"0.5849933",
"0.58299345",
"0.58136356",
"0.5776217",
"0.575044",
"0.5717144",
"0.5632605",
"0.56096643",
"0.5605452",
"0.5583257",
"0.5583257",
"0.5566679",
"0.5551885",
"0.5551387",
"0.5535313",
"0.5525047",
"0.551542",
"0.55070794",
"0.55008334",
"0.5497203",
... | 0.68269795 | 0 |
Runs the given command via subprocess.check_output. Exits with 1 if the command wasn't successfull. | def run(self, command):
try:
print(f"RUNNING: {command}")
print("-" * 80)
print(subprocess.check_output(command, shell=True).decode('utf-8'))
except subprocess.CalledProcessError as e:
print(f"ERROR calling '{command}'")
print("-" * 20)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_output(command):\n process = Popen(command, shell=True, stdout=PIPE)\n output, err = process.communicate()\n if process.returncode == 0: # success\n return output\n else:\n raise RuntimeError(\"Command {0} running unsuccessfully\".format(command))",
"def checked_subprocess_run... | [
"0.83655596",
"0.80366087",
"0.80346185",
"0.780396",
"0.76619476",
"0.7643515",
"0.762701",
"0.755357",
"0.7551432",
"0.75476485",
"0.7536367",
"0.7521697",
"0.75196725",
"0.74670756",
"0.7415259",
"0.7365865",
"0.7332744",
"0.73258364",
"0.7289348",
"0.7279483",
"0.72791225... | 0.7235263 | 23 |
Runs Pyinstaller producing a binary for every platform arch. | def dist(self):
for arch, python in self.python:
# Build the binary
build_path = os.path.join("dist", f"safety-{arch}")
self.run(f"{python} -m PyInstaller safety.spec"
f" --distpath {build_path}")
# There seems to be no way to tell pyinstall... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n parser = argparse.ArgumentParser(prog='Build', description='Python script for building apps for Pyinstaller')\n # Flag arguments\n parser.add_argument('--version', action='version', version='%(prog)s 1.0.0')\n parser.add_argument('--clean', '-c', action='store_true', default=False, help... | [
"0.6310259",
"0.5789505",
"0.5693444",
"0.5510755",
"0.55103916",
"0.5497933",
"0.5497933",
"0.54874897",
"0.54428",
"0.54246897",
"0.5419463",
"0.5417989",
"0.5384044",
"0.53545874",
"0.5292452",
"0.5261924",
"0.52568054",
"0.5245243",
"0.52441704",
"0.51907384",
"0.517166",... | 0.6888925 | 0 |
Runs tests for every available arch on the current platform. | def test(self):
for arch, python in self.python:
self.run(f"{python} -m pytest") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_platform():\n build()\n sh(\"%s psutil\\\\tests\\\\test_windows.py\" % PYTHON)",
"def test_system_platform():\n accepted_values = ['windows', 'linux']\n output = sh.system_platform()\n assert output in accepted_values",
"def test_all_envs(func):\n register_tests(func, [func.__name__ ... | [
"0.638114",
"0.63241595",
"0.62285227",
"0.614223",
"0.5939137",
"0.585725",
"0.5821105",
"0.57821816",
"0.5781692",
"0.5748923",
"0.56621426",
"0.5645789",
"0.56325114",
"0.5582712",
"0.55822486",
"0.5556149",
"0.554905",
"0.5544548",
"0.5525121",
"0.5525121",
"0.5525121",
... | 0.7169691 | 0 |
Check if all elements present in the descending diagonal starting from position (i, j) in the matrix are all the same or not. | def checkDiag(mat, i, j):
res = mat[i][j]
i += 1
j += 1
while i < col and j < row:
if mat[i][j] != res:
return False
i += 1
j += 1
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkMatrix(i,j):\n # print(i,j)\n counter = Counter([grid[di][dj] for di in range(i,i+3) for dj in range(j,j+3)])\n for k in range(1,10):\n if counter[k] != 1:\n return False\n\n rows_sum = [sum(grid[k][j:j+3]) for k in range(i,i+3)... | [
"0.7221507",
"0.72052103",
"0.70935583",
"0.7079611",
"0.6919874",
"0.6859481",
"0.6859481",
"0.6692153",
"0.66862524",
"0.6574057",
"0.65542644",
"0.6525075",
"0.64994526",
"0.64286137",
"0.6414612",
"0.6412978",
"0.6392789",
"0.63825876",
"0.63576436",
"0.6351419",
"0.63253... | 0.7580794 | 0 |
Check whether the matrix is Toeplitz using our routine. | def isToeplitz(mat):
for j in range(row):
if not checkDiag(mat, 0, j):
return False
for i in range(1, col):
if not checkDiag(mat, i, 0):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_invertible(matrix: np.ndarray) -> bool:\n return matrix.shape[0] == matrix.shape[1] and np.linalg.det(matrix) != 0",
"def check_matrix(self, matrix):\n for i in range(self.size):\n if (matrix[0][i] + matrix[-1][i] == i % 2 or matrix[0][i] + matrix[-1][i] == (i + 1) % 2) and (\n ... | [
"0.62021834",
"0.6143656",
"0.6061478",
"0.58724177",
"0.5847098",
"0.5835416",
"0.579894",
"0.57757217",
"0.5651579",
"0.564704",
"0.56339616",
"0.5586131",
"0.5580269",
"0.55736345",
"0.55596083",
"0.5545253",
"0.5520429",
"0.5501175",
"0.5497774",
"0.5475992",
"0.546678",
... | 0.8034812 | 0 |
Try to locate the most frontfacing instance of the specified number in the given image. | def locate_number(
pipeline: Pipeline,
num: int,
img: ImageBGR,
) -> Optional[Tuple[int, int]]:
box = locate_front_facing_text(pipeline, str(num), img)
if box is None:
return None
(cx, cy) = center_of_box(box)
return (round(cx), round(cy)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_best_face(self, image):\n\t\ttry:\n\t\t\treturn max(self.get_faces(image),\n\t\t\t key = (lambda f: f[1]))\n\t\texcept ValueError:\n\t\t\treturn None",
"def locate_face(image, minNeighbors=5, scaleFactor=1.05):\n rects = cc_face.detectMultiScale(image, scaleFactor=scaleFactor, minNeighbors=m... | [
"0.6109257",
"0.5968454",
"0.55990577",
"0.5586432",
"0.5545742",
"0.5542052",
"0.5507893",
"0.54844373",
"0.54029626",
"0.53532827",
"0.5300011",
"0.52998513",
"0.52698857",
"0.52682185",
"0.5256586",
"0.5255363",
"0.51983386",
"0.5198194",
"0.5178408",
"0.51701695",
"0.5156... | 0.6024551 | 1 |
Try to locate the most frontfacing instance of the specified text in the given image. | def locate_front_facing_text(
pipeline: Pipeline,
text: str,
img: ImageBGR,
) -> Optional[ndarray]:
boxes = locate_all_text(pipeline, text, img)
return None if not boxes else max(boxes, key=width_of_box) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(image):\n keypoint, description = describe(image)\n # load keypoints, descriptions from mongodb\n\n bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)\n\n best_match_size = float(\"inf\")\n best_match_index = -1\n match_index = 0\n best_matches = 0\n\n for desc in descriptions:\n matches = b... | [
"0.6584374",
"0.5994109",
"0.5930117",
"0.5808667",
"0.5791923",
"0.5733024",
"0.57220936",
"0.56743777",
"0.5612249",
"0.559422",
"0.5520388",
"0.5518373",
"0.55104786",
"0.5501395",
"0.5458008",
"0.5457504",
"0.5452925",
"0.5452155",
"0.54426736",
"0.5430474",
"0.5422574",
... | 0.7968446 | 0 |
Locate all instances of the specified text in the given image. | def locate_all_text(pipeline: Pipeline, text: str, img: ImageBGR) -> List[ndarray]:
predictions = recognize(pipeline, img)
return [box for (txt, box) in predictions if txt == text] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_image_search(image_name, saved_image, text):\n with Image(filename=image_name) as img:\n with img.clone() as cloned:\n cloned.format = 'png'\n with Drawing() as draw:\n draw.font_family = 'Liberation Mono'\n draw.font_... | [
"0.7133031",
"0.6248851",
"0.62018156",
"0.6122685",
"0.5983066",
"0.59805745",
"0.5944735",
"0.5919284",
"0.5852322",
"0.5812584",
"0.5805259",
"0.57655126",
"0.57553184",
"0.57473385",
"0.5714805",
"0.56760997",
"0.566809",
"0.5653277",
"0.5649725",
"0.5605669",
"0.5579515"... | 0.73533505 | 0 |
Recognize characters in the given image. | def recognize(pipeline: Pipeline, img: ImageBGR) -> List[Prediction]:
groups: List[List[Prediction]] = pipeline.recognize([img.data])
return [] if not groups else groups[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_letters(line_image):\r\n\r\n\tif line_image.shape[0] < 40:\r\n\t\tline_image = cv2.resize(line_image, (line_image.shape[1] * 2, line_image.shape[0] * 2))\r\n\r\n\t#binary\r\n\tret,thresh = cv2.threshold(line_image, 109, 255, cv2.THRESH_BINARY_INV)\r\n\r\n\tif cv2.__version__.startswith('3.'):\r\n\t\tim2, ... | [
"0.69676256",
"0.6598435",
"0.6543282",
"0.6519579",
"0.6401202",
"0.63549",
"0.63313323",
"0.6326261",
"0.630656",
"0.6189315",
"0.6133044",
"0.61307913",
"0.61281866",
"0.6122168",
"0.61140376",
"0.60912144",
"0.6071114",
"0.6069808",
"0.6067123",
"0.59948766",
"0.59657794"... | 0.0 | -1 |
Compute the width of a bounding box. | def width_of_box(box: ndarray) -> float:
(w, _) = dimensions_of_box(box)
return w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getWidth(self):\n return _libsbml.BoundingBox_getWidth(self)",
"def width(self) -> int:\r\n return self.rect_uv.w",
"def _get_pad_width(self, bbox):\r\n if isinstance(bbox, shapely.geometry.polygon.Polygon):\r\n bbox = bbox.bounds\r\n elif isinstance(bbox, tuple):\r\n... | [
"0.78384995",
"0.7405333",
"0.72103524",
"0.71854645",
"0.71309066",
"0.698792",
"0.69232786",
"0.69125646",
"0.68847704",
"0.68847704",
"0.681629",
"0.6795641",
"0.67908436",
"0.67605865",
"0.6724223",
"0.67201644",
"0.6717353",
"0.66922086",
"0.6662561",
"0.6651283",
"0.663... | 0.7852812 | 0 |
Compute the dimensions of a bounding box. | def dimensions_of_box(box: ndarray) -> Tuple[float, float]:
(top_left, _, bottom_right, _) = box
(x1, y1) = top_left
(x2, y2) = bottom_right
return (x2 - x1, y2 - y1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDimensions(self):\n return _libsbml.BoundingBox_getDimensions(self)",
"def bounding_box_size(self):\n return self.subset.bounding_box_size()",
"def box_size(self) -> np.ndarray:\n return self.upper - self.lower + 1",
"def box_size(self) -> np.ndarray:\n return self.upper - ... | [
"0.7809096",
"0.74935055",
"0.71321684",
"0.71321684",
"0.7028061",
"0.7028061",
"0.7006185",
"0.69137424",
"0.6838827",
"0.67754894",
"0.67039317",
"0.66390294",
"0.6636376",
"0.66180444",
"0.6617061",
"0.66104996",
"0.65931004",
"0.65841496",
"0.6548105",
"0.653331",
"0.652... | 0.7216003 | 2 |
Compute the center coordinates of a bounding box. | def center_of_box(box: ndarray) -> Tuple[float, float]:
return np.average(box, axis=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center(self):\n return np.sum(self.bbox, 0) / 2",
"def getBoundingBoxCenter(self, shell=False, *args, **kwargs):\n if shell:\n self.grabShell()\n uvBB = pm.polyEvaluate(boundingBoxComponent2d=True)\n uvCenter = [((uvBB[0][1] + uvBB[0][0]) / 2), ((uvBB[1][1] + uvBB[1][0]... | [
"0.83376604",
"0.79774463",
"0.7929507",
"0.78889424",
"0.7875013",
"0.77640754",
"0.7762866",
"0.7758551",
"0.76668495",
"0.75822484",
"0.7577398",
"0.7468743",
"0.74314386",
"0.73990625",
"0.73919564",
"0.7388721",
"0.7360475",
"0.73129874",
"0.731186",
"0.728058",
"0.71837... | 0.7129428 | 28 |
Return the last commit hash that appears to have been committed by gerrit. | def get_upstream_commit():
return check_output(_GET_UPSTREAM_COMMIT_SCRIPT).strip().decode('utf-8') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_commit_hash():\n git_dir = get_git_root()\n args = [\"git\", \"-C\", git_dir, \"rev-parse\", \"--short\", \"--verify\", \"HEAD\"]\n return subprocess.check_output(args).strip().decode()",
"def commit_hash(self):\n return self._commit_hash",
"def _get_git_hash(self):\n try:\n ... | [
"0.7975856",
"0.78311783",
"0.77943695",
"0.76531535",
"0.7602308",
"0.75942075",
"0.75930107",
"0.75697476",
"0.755672",
"0.7517278",
"0.7516449",
"0.75058067",
"0.75035375",
"0.74300647",
"0.7416891",
"0.7393128",
"0.7353526",
"0.73011035",
"0.7250581",
"0.7235257",
"0.7216... | 0.603179 | 74 |
r"""Run command with arguments and return its output as a byte string. Backported from Python 2.7 as it's implemented as pure python on stdlib. >>> check_output(['/usr/bin/python', 'version']) Python 2.6.2 | def check_output(*popenargs, **kwargs):
process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
error = subprocess.CalledProcessError(ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_output(*args):\n cmd_output = subprocess.check_output(args)\n # On Python 3, this returns bytes (from STDOUT), so we\n # convert to a string.\n cmd_output = cmd_output.decode('utf-8')\n # Also strip the output since it usually has a trailing newline.\n return cmd_output.strip()",
"def... | [
"0.8171935",
"0.74754685",
"0.74212164",
"0.73357135",
"0.7299671",
"0.72751886",
"0.72603405",
"0.72177374",
"0.7188931",
"0.7186452",
"0.71609044",
"0.7144167",
"0.7137204",
"0.7025727",
"0.7009536",
"0.6982228",
"0.69801265",
"0.6913437",
"0.69010824",
"0.6882899",
"0.6862... | 0.6900501 | 20 |
Issue the given prompt, and ask the user to confirm yes/no. Returns true if the user confirms. | def confirm_prompt(prompt):
while True:
print(prompt, end=' [Y/n]: ')
if not os.isatty(sys.stdout.fileno()):
print("Not running interactively. Assuming 'N'.")
return False
pass
r = input().strip().lower()
if r in ['y', 'yes', '']:
return True
elif r in ['n', 'no']:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def confirm(self, prompt=None, resp=False):\n\n if prompt is None:\n prompt = 'Confirm'\n\n if resp:\n prompt = '%s [%s]|%s: ' % (prompt, 'y', 'n')\n else:\n prompt = '%s [%s]|%s: ' % (prompt, 'n', 'y')\n\n while True:\n ans = raw_input(prompt... | [
"0.83006346",
"0.8259412",
"0.8020167",
"0.80170214",
"0.80104864",
"0.8008348",
"0.7993725",
"0.7975639",
"0.7779552",
"0.7631397",
"0.76128113",
"0.76106507",
"0.7544541",
"0.7469662",
"0.7433531",
"0.74094915",
"0.73615307",
"0.7337983",
"0.7299126",
"0.72749245",
"0.72716... | 0.7963644 | 8 |
Return the email address in the user's git config. | def get_my_email():
return check_output(['git', 'config', '--get',
'user.email']).strip().decode('utf-8') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_email(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"user_email\")",
"def account_email(self) -> str:\n return pulumi.get(self, \"account_email\")",
"def email(self) -> str:\n return pulumi.get(self, \"email\")",
"def email(self) -> str:\n return pulumi.get(self... | [
"0.7280318",
"0.7232141",
"0.7188435",
"0.7188435",
"0.7188435",
"0.71637696",
"0.71572125",
"0.7076948",
"0.7076948",
"0.7076948",
"0.7076948",
"0.7075867",
"0.7023382",
"0.70050824",
"0.6937374",
"0.68804014",
"0.6870833",
"0.68378097",
"0.68269426",
"0.6818887",
"0.6805280... | 0.86037236 | 0 |
F1 (a.k.a. DICE) operating on two lists of offsets (e.g., character). >>> assert f1([0, 1, 4, 5], [0, 1, 6]) == 0.5714285714285714 | def f1(predictions, gold):
if len(gold) == 0:
return 1. if len(predictions) == 0 else 0.
if len(predictions) == 0:
return 0.
predictions_set = set(predictions)
gold_set = set(gold)
nom = 2 * len(predictions_set.intersection(gold_set))
denom = len(predictions_set) + len(gold_set)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f(x0: float, x1: float) -> float:\n return 8 - (x0 - 2) ** 2 - (x1 - 2) ** 2",
"def __call__(self, f1, f2):\n\n r = 0.0\n for f in f1:\n if f in f2:\n r += f1[f] * f2[f]\n\n return r",
"def calculate_f1(fx, y):\n pred_idxs = fx.max(1, keepdim=True)[1]\n ... | [
"0.5610688",
"0.55093515",
"0.5410377",
"0.52887857",
"0.52255523",
"0.520882",
"0.5139808",
"0.50946337",
"0.50892437",
"0.50515544",
"0.50473595",
"0.5026382",
"0.50248957",
"0.49842107",
"0.49398017",
"0.4938526",
"0.49344835",
"0.49316767",
"0.4920797",
"0.4916687",
"0.49... | 0.51370984 | 7 |
w = (xTx) 1 xTy | def standRegres(xArr, yArr):
xMat = np.mat(xArr)
yMat = np.mat(yArr).T
xTx = xMat.T * xMat
if np.linalg.det(xTx) == 0.0:
print 'This matrix is singular, cannot do inverse.'
return
ws = xTx.I * (xMat.T * yMat)
return ws | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eq(w, x):\n return (-w[1]*x - w[0]) / w[2]",
"def nn(x, w):\n return np.dot(x, w)",
"def applyTw(T, Wxyz=[0, 0, 0]):\n return (T * sp.Matrix([Wxyz[0], Wxyz[1], Wxyz[2], 0]))[:3, 0]",
"def applyTx(T, xyz=[0, 0, 0]):\n return (T * sp.Matrix([xyz[0], xyz[1], xyz[2], 1]))[:3, 0]",
"... | [
"0.67788756",
"0.6498502",
"0.6414204",
"0.6276771",
"0.6237516",
"0.62109613",
"0.6204428",
"0.6185558",
"0.6117792",
"0.61113244",
"0.60975444",
"0.6091444",
"0.6052467",
"0.6026854",
"0.6024035",
"0.6018883",
"0.59976965",
"0.59845245",
"0.59813404",
"0.5974722",
"0.596788... | 0.0 | -1 |
Runs the unit tests without test coverage. | def test():
tests = unittest.TestLoader().discover('auth/tests', pattern='test*.py')
result = unittest.TextTestRunner(verbosity=2).run(tests)
if result.wasSuccessful():
return 0
return 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run_ci_test():\n _run_install(False)\n _run_coverage_html(False)\n _run_typecheck_xml(False)\n _run_lint(True)",
"def main():\n import coverage\n import nose\n import os\n from shutil import rmtree\n rmtree('./covhtml', ignore_errors=True)\n try:\n os.remove('./.coverage... | [
"0.7740198",
"0.7395665",
"0.73899317",
"0.73077023",
"0.7184236",
"0.71184987",
"0.7116021",
"0.7049126",
"0.695683",
"0.6951264",
"0.6858743",
"0.682145",
"0.6820713",
"0.6819008",
"0.6809791",
"0.67945355",
"0.6780462",
"0.6756857",
"0.6749489",
"0.671787",
"0.6669164",
... | 0.0 | -1 |
Creates the db tables. | def create_db():
db.create_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_db_tables():\n\n try:\n webapp.dbsql.create_all()\n webapp.dbsql.session.commit()\n except Exception as e:\n # TODO: melhorar o ... | [
"0.90999454",
"0.90999454",
"0.8910174",
"0.86784077",
"0.8614145",
"0.8553592",
"0.8508828",
"0.845593",
"0.8445083",
"0.8376737",
"0.83389515",
"0.82984424",
"0.8226738",
"0.8191471",
"0.81631696",
"0.8158732",
"0.81120193",
"0.80407983",
"0.7961357",
"0.7934169",
"0.793311... | 0.7608928 | 63 |
Drops the db tables. | def drop_db():
db.drop_all() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop_database_tables(cls):\n cursor = Database.connect_to_db()\n # drop users table\n sql_command = \"\"\" DROP TABLE IF EXISTS users CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop parties table\n sql_command = \"\"\" DROP TABLE IF EXISTS parties C... | [
"0.8613892",
"0.85542655",
"0.8401308",
"0.8334024",
"0.829665",
"0.82727927",
"0.8257214",
"0.8239192",
"0.8230405",
"0.8215113",
"0.8172018",
"0.8147676",
"0.8134603",
"0.8033471",
"0.80164933",
"0.7894234",
"0.7875027",
"0.7873612",
"0.78511506",
"0.7773903",
"0.7724372",
... | 0.7996094 | 22 |
Germline TSV sheet without header | def tsv_sheet_germline_no_header():
f = io.StringIO(
textwrap.dedent(
"""
patientName\tfatherName\tmotherName\tsex\tisAffected\tlibraryType\tfolderName\thpoTerms
12_345\t12_346\t12_347\tM\tY\tWGS\t12_345\tHP:0009946,HP:0009899
12_348\t12_346\t12_347\tM\tN\tWGS\t12_348\t.
12_346\t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tsv_sheet_cancer_no_header():\n f = io.StringIO(\n textwrap.dedent(\n \"\"\"\n patientName\\tsampleName\\tisTumor\\tlibraryType\\tfolderName\\tncbiTaxon\\tmycnCn\\tinssStage\\tshimada4Class\\tlohChr1p\\tpatientStatus\\ttimeToEventDays\\ttimeToDeathDays\\ttestSampleNice\\tngsLibraryNice\... | [
"0.6542757",
"0.5973285",
"0.58995175",
"0.586946",
"0.56117624",
"0.5556044",
"0.5453089",
"0.54130244",
"0.5376477",
"0.53673553",
"0.53632265",
"0.52624077",
"0.52572477",
"0.52544403",
"0.52472043",
"0.52365565",
"0.5235203",
"0.5222204",
"0.52163196",
"0.51827556",
"0.51... | 0.6975893 | 0 |
Germline TSV sheet without header | def tsv_sheet_germline_no_header_hyphened_identifier():
return io.StringIO(
textwrap.dedent(
"""
patientName\tfatherName\tmotherName\tsex\tisAffected\tlibraryType\tfolderName\thpoTerms
12-345\t12-346\t12-347\tM\tY\tWGS\t12-345\tHP:0009946,HP:0009899
12-348\t12-346\t12-347\tM\tN\tWGS\... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tsv_sheet_germline_no_header():\n f = io.StringIO(\n textwrap.dedent(\n \"\"\"\n patientName\\tfatherName\\tmotherName\\tsex\\tisAffected\\tlibraryType\\tfolderName\\thpoTerms\n 12_345\\t12_346\\t12_347\\tM\\tY\\tWGS\\t12_345\\tHP:0009946,HP:0009899\n 12_348\\t12_346\\t12_347\\tM\... | [
"0.6975893",
"0.6542757",
"0.58995175",
"0.586946",
"0.56117624",
"0.5556044",
"0.5453089",
"0.54130244",
"0.5376477",
"0.53673553",
"0.53632265",
"0.52624077",
"0.52572477",
"0.52544403",
"0.52472043",
"0.52365565",
"0.5235203",
"0.5222204",
"0.52163196",
"0.51827556",
"0.51... | 0.5973285 | 2 |
Germline TSV sheet with seqPlatform name | def tsv_sheet_germline_platform_name():
f = io.StringIO(
textwrap.dedent(
"""
patientName\tfatherName\tmotherName\tsex\tisAffected\tlibraryType\tfolderName\thpoTerms\tseqPlatform
12_347\t.\t.\tF\tN\tWGS\t12_347\t.\tIllumina
12_347\t.\t.\tF\tN\tWGS\t12_347\t.\tPacBio
""".lstrip()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tsv_sheet_germline_no_header():\n f = io.StringIO(\n textwrap.dedent(\n \"\"\"\n patientName\\tfatherName\\tmotherName\\tsex\\tisAffected\\tlibraryType\\tfolderName\\thpoTerms\n 12_345\\t12_346\\t12_347\\tM\\tY\\tWGS\\t12_345\\tHP:0009946,HP:0009899\n 12_348\\t12_346\\t12_347\\tM\... | [
"0.5723765",
"0.54112744",
"0.5368876",
"0.5364168",
"0.5343656",
"0.5305883",
"0.52360225",
"0.5199959",
"0.51087195",
"0.50739825",
"0.4979598",
"0.49793586",
"0.49732012",
"0.49713272",
"0.49574873",
"0.49445036",
"0.49361375",
"0.49321032",
"0.49083406",
"0.4893043",
"0.4... | 0.71251005 | 0 |
If a defined term is part of another word, don't include it | def test_calculate_offsets_word_part(self):
applicable_terms = [('act', 'a')]
text = "I am about to act on this transaction."
t = Terms(None)
matches = t.calculate_offsets(text, applicable_terms)
self.assertEqual(1, len(matches))
self.assertEqual(1, len(matches[0][2])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_unimportant(word):\n return word in ['.', '!', ',', ] or '\\'' in word or word in stop_words",
"def isExcludedFromMerge(self, word):\n #print word\n return ((self.isExcludedWord(word) != False) \n or (self.isMeasure(word) != False) \n or (self.isShortWord(word) != False))",
"def f... | [
"0.7129404",
"0.6740497",
"0.64401877",
"0.64198786",
"0.63028586",
"0.624135",
"0.6205922",
"0.61960745",
"0.61723465",
"0.6158137",
"0.6138724",
"0.61333543",
"0.60994077",
"0.609723",
"0.6095544",
"0.6045487",
"0.60338706",
"0.6000759",
"0.5976662",
"0.59725183",
"0.597233... | 0.0 | -1 |
Make sure we don't highlight definitions that are being defined in this paragraph. | def test_process_label_in_node(self):
tree = Node(children=[
Node("Defining secret phrase.", label=['AB', 'a']),
Node("Has secret phrase. Then some other content",
label=['AB', 'b'])
], label=['AB'])
t = Terms(tree)
t.scoped_terms = {
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def no_highlight(): #py:no_highlight\n RUR._no_highlight_()",
"def no_underline(): # noqa: D416",
"def no_underline_and_no_description(): # noqa: D416",
"def test_no_spelling_mistakes_after_docstring(self, style):\n content = \"{s}{e}\\n\\\"\\\"\\\"spelling mistake\\\"\\\"\\\")\\n\\n msspltword\... | [
"0.6509171",
"0.6025568",
"0.5981216",
"0.57642",
"0.5721412",
"0.5600723",
"0.5538997",
"0.5533187",
"0.5475859",
"0.5460249",
"0.5446885",
"0.54421276",
"0.54057634",
"0.53963256",
"0.53608805",
"0.5352777",
"0.5348464",
"0.5310494",
"0.53071415",
"0.5304848",
"0.5278344",
... | 0.0 | -1 |
if your don't wanna to destory , please return True | def judge_destroy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_destroy(self) -> bool:\r\n raise NotImplementedError",
"def destroy(self):\n return True",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.delete()\n if exc_type:\n return False\n return True",
"def __del__(self):\n return ... | [
"0.7112134",
"0.7022832",
"0.6998356",
"0.68127376",
"0.67740875",
"0.6674167",
"0.6626179",
"0.6502983",
"0.638146",
"0.62835974",
"0.6254132",
"0.624675",
"0.61887157",
"0.61887157",
"0.61887157",
"0.6172241",
"0.6164332",
"0.61453766",
"0.61254376",
"0.6093295",
"0.6092467... | 0.56394315 | 79 |
`comment_list` must be an iterable containing Comment instances. | def wrap_comments(comment_list, cls=None):
if not cls:
cls = CommentDetails
return [cls(d) for d in CachedCall.multicall([cmt.details for cmt in comment_list])] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_comment_list(parser, token):\n return CommentListNode.handle_token(parser, token)",
"def get_all_comments(self, idList: Union[List, str]) -> None:\n\n #loads pickle list if it is one\n if type(idList) == str and \".pickle\" in idList:\n print(\"pickle load\")\n with... | [
"0.6494126",
"0.6294482",
"0.60200804",
"0.59759414",
"0.5885373",
"0.58529603",
"0.5835406",
"0.581138",
"0.5802858",
"0.5801029",
"0.5784154",
"0.5736132",
"0.57356554",
"0.5729952",
"0.5724823",
"0.57243335",
"0.5698182",
"0.56944305",
"0.56499034",
"0.56499034",
"0.564990... | 0.73803866 | 0 |
Strip and redirect requests with certain trailing characters left by bad URL parsers. | def redirect_trailing(view):
IGNORE_CHARS = ",./"
def wrapped(request, *args, **kwargs):
if request.META['PATH_INFO'][-1] in IGNORE_CHARS:
return HttpResponseRedirect(request.META['PATH_INFO'].rstrip(IGNORE_CHARS))
return view(request, *args, **kwargs)
return wrapped | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_drop_trailing_questionmark():\n assert normalize_url(\"http://example.com/?\") == \"http://example.com/\"\n assert normalize_url(\"http://example.com?\") == \"http://example.com/\"\n assert normalize_url(\"http://example.com/a?\") == \"http://example.com/a\"\n assert normalize_url(\"http://exa... | [
"0.6716417",
"0.65329564",
"0.6438808",
"0.6175929",
"0.6159155",
"0.61399084",
"0.60827553",
"0.6058008",
"0.60463554",
"0.6016129",
"0.6008326",
"0.59506243",
"0.59365505",
"0.59365505",
"0.59365505",
"0.59365505",
"0.59365505",
"0.59365505",
"0.59365505",
"0.58958346",
"0.... | 0.6691305 | 1 |
`force_show` if True will return as many top reply IDs as we have. | def top_reply_ids(self, force_show=False):
num_top = min(self.num_replies / Config['posts_per_top_reply'], Config['maximum_top_replies'])
min_top_replies = Config['minimum_top_replies']
top_reply_ids = []
# Avoid even hitting redis if we know we aren't going to use the data.
if f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_from_top_ten(title,users,max = 3):\n \"\"\" ten prolific users \"\"\"\n \"\"\" max : number of user with related followers \"\"\"\n getAllUsers(users,all_users,users_set,proceeded_users,max,user_cpt,title)\n for data in users_set:\n print(data.id)",
"def show_recommendation_pool(s... | [
"0.5378942",
"0.532292",
"0.52742416",
"0.5210229",
"0.514267",
"0.5120347",
"0.51002747",
"0.5028869",
"0.50170374",
"0.49864686",
"0.49803752",
"0.49629715",
"0.49612206",
"0.49332845",
"0.4932724",
"0.4930099",
"0.49299458",
"0.49253184",
"0.49134997",
"0.48672706",
"0.485... | 0.77080315 | 0 |
Returns replies with text, sorted by id | def get_text_reply_ids(self):
if not self._linked_comment:
return []
replies = Comment.objects.filter(replied_comment=self._linked_comment)
return [ids[0] for ids in replies.exclude(reply_text='').order_by('id').values_list('id')] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_message_replies(self, mid):\n pass",
"def cmd_comment_replies(client, args):\n comment_replies = client.get_comment_replies(args.comment_id)\n data = format_comment_tree(comment_replies)\n generate_output({'comment_replies': data}, args.output_file)",
"def replies(self):\n keys =... | [
"0.61649644",
"0.6155298",
"0.597946",
"0.58901846",
"0.5586778",
"0.55457026",
"0.55379367",
"0.5525999",
"0.5513527",
"0.55060965",
"0.5498998",
"0.54371476",
"0.5423341",
"0.53732705",
"0.53540397",
"0.53385663",
"0.53333944",
"0.5317818",
"0.53098434",
"0.52878696",
"0.52... | 0.6619243 | 0 |
The log function with aggregation name, process id and tag integrated. | def log (self, msg, level="info", flag=None, key = ''):
if flag is None:
flag = level
flag = flag.upper().rjust(7)
flag = "[%s]" % flag
title = self._name()
func = getattr(self.logger, level)
maxline = proc.LOG_NLINE[key]
prevlog = self.lognline['prevlog']
if key == prevlog:
if self.lognli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _log(log_fn, task_request, message):\n log_fn(\"{}: {}\".format(task_request.id, message))",
"def log_nest(module, function, tag, subtag, info):\n global nodehost, nodeuser\n \n # determine current time. ***DO THIS FIRST***\n time1 = time.time()\n time2 = time.gmtime()\n\n # see if logging is... | [
"0.6297053",
"0.62474245",
"0.6157983",
"0.61170477",
"0.61158425",
"0.60073596",
"0.5902459",
"0.58434343",
"0.57823247",
"0.57499766",
"0.571752",
"0.5716251",
"0.5713921",
"0.57046956",
"0.5695376",
"0.5694506",
"0.5606004",
"0.55924064",
"0.55867314",
"0.5582783",
"0.5529... | 0.49975112 | 86 |
Calcuate a uid for the process according to the configuration | def _suffix (self):
if self.suffix:
return self.suffix
config = { key:val for key, val in self.config.iteritems() if key not in ['workdir', 'forks', 'cache', 'retcodes', 'echo', 'runner', 'exportdir', 'exporthow', 'exportow', 'errorhow', 'errorntry'] or key.endswith ('Runner') }
config['id'] = self.id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getuid(): # type: ignore\n return 0",
"def known_uid():\n return '48ee71d9-20f0-41fc-a99f-c518121a880e'",
"def getmyuid():\n raise NotImplementedError()",
"def get_user_id():\n return os.getuid()",
"def uid(self) -> str:\n return pulumi.get(self, \"uid\")",
"def uid():\n\n ... | [
"0.73529434",
"0.6904269",
"0.6874896",
"0.68143004",
"0.6640332",
"0.66186196",
"0.6611936",
"0.65890056",
"0.6499807",
"0.64870447",
"0.646705",
"0.646705",
"0.646705",
"0.6399656",
"0.63789135",
"0.63695127",
"0.6366331",
"0.63619816",
"0.635309",
"0.63286996",
"0.63102037... | 0.0 | -1 |
Do some preparation before running jobs | def _tidyBeforeRun (self):
self._buildProps ()
self._buildInput ()
self._buildProcVars ()
self._buildJobs () | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare(self):",
"def prepare(self):\n if self.opts['verbose']:\n print(\"Preparing dataset (one-time operation)...\")\n # Create paths files and load them back in\n self._build_ID_sets()\n self._create_ID_files()\n self._load_ID_files()\n if self.opts['ve... | [
"0.7044057",
"0.68709004",
"0.68693995",
"0.68585104",
"0.68585104",
"0.68585104",
"0.6740922",
"0.6718343",
"0.6686946",
"0.666077",
"0.666077",
"0.666077",
"0.666077",
"0.666077",
"0.6644439",
"0.6626265",
"0.6626265",
"0.65906596",
"0.65197337",
"0.6379625",
"0.6327932",
... | 0.71023333 | 0 |
Do some cleaning after running jobs | def _tidyAfterRun (self):
failedjobs = []
for i in self.ncjobids:
job = self.jobs[i]
if not job.succeed():
failedjobs.append (job)
if not failedjobs:
self.log ('Successful jobs: ALL', 'debug')
if callable (self.callback):
self.log('Calling callback ...', 'debug')
self.callback (self)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean(self, args):\n for j in self.jobs:\n j.clean(args)",
"def cleanup():",
"def clean_up(self) -> None:\n print('Doing some clean-up work...')",
"def clean(self):\n self._raw_execute(\"clean\", {\"job_id\": self.job_id})",
"def cleanup(self):",
"def cleanup(self):",
... | [
"0.78071237",
"0.77039135",
"0.7624755",
"0.74840623",
"0.74488914",
"0.74488914",
"0.74488914",
"0.7341595",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7322051",
"0.7302214",
"0.7296591... | 0.65145636 | 92 |
Get my name include `aggr`, `id`, `tag` | def _name (self, incAggr = True):
aggrName = "@%s" % self.aggr if self.aggr and incAggr else ""
tag = ".%s" % self.tag if self.tag != "notag" else ""
return "%s%s%s" % (self.id, tag, aggrName) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_name():",
"def get_name() -> str:",
"def get_name(self):",
"def get_name(self):",
"def get_name_tag(obj):\n if 'Name' in obj.tags:\n return obj.tags['Name']\n else:\n return \"\"",
"def get_name_tag(obj):\n if 'Name' in obj.tags:\n return obj.tags['Na... | [
"0.6776478",
"0.6571145",
"0.64042926",
"0.64042926",
"0.6375301",
"0.6357653",
"0.63202906",
"0.6207927",
"0.6207927",
"0.6207927",
"0.6207927",
"0.6207927",
"0.6207927",
"0.62068367",
"0.61977625",
"0.61679345",
"0.6132641",
"0.6104459",
"0.60582983",
"0.6038414",
"0.603841... | 0.73647666 | 0 |
Run the jobs with a configuration | def run (self, config = None):
timer = time()
if config is None:
config = {}
self.logger.info ('[ START] ' + utils.padBoth(' ' + self._name() + ' ', 80, '-'))
# log the dependencies
self.log ("%s => %s => %s" % ([p._name() for p in self.depends] if self.depends else "START", self._name(), [p._name() for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(config):\n for section in config.sections():\n if 'module' in [tuple[0] for tuple in config.items(section)]:\n read_metric = Process(target=worker.start_worker,\n args=(config[section]['module'], config[section]['worker'],\n ... | [
"0.6929816",
"0.69011277",
"0.66671133",
"0.6641401",
"0.6581517",
"0.64800954",
"0.6476801",
"0.64720464",
"0.64445555",
"0.64079905",
"0.6249662",
"0.6244178",
"0.62345445",
"0.6228042",
"0.62246597",
"0.6196507",
"0.6164982",
"0.6157132",
"0.61275566",
"0.60870254",
"0.607... | 0.5928229 | 26 |
Build the input data | def _buildInput (self):
indata = self.config['input']
if not isinstance (indata, dict):
indata = ','.join(utils.alwaysList (indata))
depdchan = channel.fromChannels (*[d.channel for d in self.depends])
indata = {indata: depdchan if self.depends else channel.fromArgv()}
# expand to one key-chan... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(self, data: dict):",
"def build_data(self):\n\n _header_ = self._header_ + 'build_data(): '\n\n if self.verbose:\n print(_header_ + 'Building data for %s ...' % self.p_data)\n\n self.read_data()\n self.map_data()\n self.partition_data()\n self.compos... | [
"0.7103907",
"0.7050694",
"0.66928786",
"0.66268075",
"0.6621313",
"0.65265703",
"0.65073645",
"0.64411193",
"0.64387316",
"0.6423669",
"0.6376527",
"0.63698995",
"0.63683873",
"0.63594806",
"0.6341443",
"0.6325721",
"0.6296348",
"0.62902075",
"0.6282229",
"0.62391293",
"0.62... | 0.6791348 | 2 |
also add proc.props, mostly scalar values | def _buildProcVars (self):
alias = {val:key for key, val in proc.ALIAS.iteritems()}
for prop in sorted(self.props.keys()):
val = self.props[prop]
if not prop in ['id', 'tag', 'tmpdir', 'forks', 'cache', 'workdir', 'echo', 'runner',
'errorhow', 'errorntry', 'defaultSh', 'exportdir', 'exporthow', 'export... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_proc_attr_order(self):\n jobad = classad.ClassAd()\n for attr, val in [(x, condor_meter.PROC_ATTRS.index(x)) for x in reversed(condor_meter.PROC_ATTRS)]:\n jobad[attr] = val\n self.assertEqual(condor_meter.get_num_procs(jobad), val)",
"def props(self):\r\n retu... | [
"0.5752733",
"0.56328917",
"0.56328917",
"0.56328917",
"0.5615482",
"0.5577076",
"0.5544038",
"0.54323864",
"0.5425881",
"0.54114395",
"0.53192484",
"0.52942336",
"0.52895135",
"0.5284507",
"0.52701503",
"0.52666897",
"0.5265208",
"0.52173996",
"0.52003396",
"0.5196597",
"0.5... | 0.63126945 | 0 |
Tell whether the jobs are cached | def _isCached (self):
self.props['ncjobids'] = range(self.length)
if self.cache == False:
self.log ('Not cached, because proc.cache is False', 'debug')
return False
if self.cache == True:
for depend in self.depends:
if depend.cached: continue
self.log ('Not cached, my dependent "%s" is not cac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_cached(self):\n return False",
"def getCacheable(self):\n return False",
"def mark_if_cached(self, args):\n pass",
"def is_cached(name, typ=\"pkl\"):\n return os.path.exists(cache_name(name, typ))",
"def enable_caching_acts_data() -> bool:\n return True",
"def cached(s... | [
"0.760183",
"0.7193296",
"0.7158146",
"0.7049321",
"0.6945171",
"0.69392574",
"0.67610794",
"0.67602086",
"0.6705713",
"0.66986024",
"0.66811",
"0.6526449",
"0.6522423",
"0.6519703",
"0.65172327",
"0.65119636",
"0.64544183",
"0.6348132",
"0.633575",
"0.6330356",
"0.6327569",
... | 0.7973835 | 0 |
Run the `beforeCmd` or `afterCmd` | def _runCmd (self, key):
if not self.props[key]:
return 0
cmd = utils.format(self.props[key], self.procvars)
self.log ('Running <%s>: %s' % (key, cmd), 'info')
p = Popen (cmd, shell=True, stdin=PIPE, stderr=PIPE, stdout=PIPE)
if self.echo:
for line in iter(p.stdout.readline, ''):
self.logger.inf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_cmd(self):\r\n self.run = True",
"def at_pre_cmd(self):\n pass",
"def normal(self):\n self.run_command('normal')",
"def run_command_check(self):\n pass",
"def test_run_command(self):\n self.build()\n self.data_formatter_commands()",
"def do_before(self):\r\n ... | [
"0.6794517",
"0.65953815",
"0.641636",
"0.6380787",
"0.62030005",
"0.61738706",
"0.6168429",
"0.61490905",
"0.6098857",
"0.6054008",
"0.6047767",
"0.60379046",
"0.6029685",
"0.6021883",
"0.6005523",
"0.59682816",
"0.5947254",
"0.59307516",
"0.59238434",
"0.591363",
"0.5903428... | 0.0 | -1 |
Submit and run the jobs | def _runJobs (self):
# submit jobs
def sworker (q):
"""
The worker to run jobs
"""
while True:
(run, i) = q.get()
sleep (i)
if run.isRunning():
self.log ("Job #%s is already running, skip submitting." % run.job.index, 'info')
else:
run.submit()
run.wait()
run.finish()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n self.submit()\n self.start()",
"def submit(self):\n self.keep_data = False\n ManagedJob.submit(self)",
"def submit(self, **kwargs):\n pwd = curdir\n wd = dirname(self.logFile)\n chdir(wd)\n d = OrderedDict()\n #d['universe'] = 'van... | [
"0.7423292",
"0.7267833",
"0.71237546",
"0.69903475",
"0.6716146",
"0.67021185",
"0.6673676",
"0.6648856",
"0.66117823",
"0.6582873",
"0.6563722",
"0.65595084",
"0.6535261",
"0.65330726",
"0.6530133",
"0.6523355",
"0.6512174",
"0.65109503",
"0.65062904",
"0.6478821",
"0.64662... | 0.74873537 | 0 |
The worker to run jobs | def sworker (q):
while True:
(run, i) = q.get()
sleep (i)
if run.isRunning():
self.log ("Job #%s is already running, skip submitting." % run.job.index, 'info')
else:
run.submit()
run.wait()
run.finish()
q.task_done() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getWorker(self):\n pass",
"def work(self, job):\n pass",
"def _worker(self, args):\n pass",
"def worker(self, **options):\n pass",
"def worker(self):\n return self._worker",
"def run_worker(self):\n # TODO(xiejw): To allow execution framework to add train hooks.\... | [
"0.80843735",
"0.78820264",
"0.7827158",
"0.782191",
"0.767357",
"0.7649135",
"0.74996334",
"0.7405024",
"0.7321206",
"0.72851163",
"0.7198679",
"0.7160309",
"0.7145514",
"0.7112629",
"0.70511824",
"0.70066136",
"0.69530994",
"0.69140154",
"0.6912274",
"0.6886605",
"0.6870932... | 0.67186964 | 29 |
Checks if the digits in a UPC is consistent with checksum | def checksum (upc):
# check type of input
# raise TypeError if not string
# xxxxxxxxxxx x
# check length of string
# raise ValueError if not 12
# convert string to array
# generate checksum using the first 11 digits provided
# check against the the twelfth digit
# result of fir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checksum(upc):\n\n # check type of input\n if type(upc) != str:\n # raise TypeError if not string\n raise TypeError(\"Input must be a string\")\n # check length of string\n elif len(upc) != 12:\n # raise ValueError if not 12\n raise ValueError(\"Invalid UPC length\")\n ... | [
"0.76931924",
"0.7153059",
"0.6873011",
"0.6843878",
"0.6791563",
"0.67721796",
"0.67342436",
"0.6706044",
"0.66468424",
"0.6590527",
"0.65206844",
"0.651262",
"0.64882284",
"0.64793825",
"0.6446997",
"0.643259",
"0.64238644",
"0.6422077",
"0.6409033",
"0.63966155",
"0.639355... | 0.7522875 | 1 |
Checks if any execute sent from this function creates a table. | def test_create_staging_table_should_sends_create_table_sql(db_connection):
loader = PostgresLoader("local", 5432, "db", "user", "pass")
loader.create_staging_table()
execute_params = []
for name, args, _ in db_connection.mock_calls:
if name.endswith("execute"):
for arg in args:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\n try:\n _ = self.engine.table_names()\n except OperationalError:\n return False\n else:\n return True",
"def check_table(self, table_name: str) -> bool:\n try:\n if self.engine.dialect.has_table(self.engine.connect(), ta... | [
"0.723119",
"0.67749983",
"0.6705648",
"0.6699322",
"0.6656466",
"0.6656466",
"0.6647835",
"0.66467416",
"0.6632517",
"0.6606211",
"0.6589696",
"0.6562214",
"0.65404904",
"0.65256304",
"0.65187347",
"0.6497645",
"0.6485021",
"0.6475742",
"0.6475169",
"0.6461142",
"0.646054",
... | 0.0 | -1 |
This function is used to get results from elasticsearch response | def get_source(self, results):
if results:
json_results = [book['_source'] for book in results]
return json_results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_es_response(self, index_name, lucene_query=False):\n body = dict()\n lucene_query = self.build_lucene_query() if lucene_query else None\n if lucene_query is None:\n if self.fetch_querydict():\n body[\"query\"] = self.fetch_querydict()\n if self.fe... | [
"0.7462794",
"0.73649436",
"0.6880637",
"0.6855493",
"0.68401885",
"0.6836686",
"0.67950594",
"0.6596483",
"0.65936184",
"0.6456584",
"0.64349544",
"0.643421",
"0.6362724",
"0.63475496",
"0.6272457",
"0.62275684",
"0.62275684",
"0.6222748",
"0.61975014",
"0.6183554",
"0.61835... | 0.0 | -1 |
This function saves elastic search results to file. | def save_results(self, results, file_name, file_type):
if file_type == 'csv':
csv_filename = '{}.csv'.format(file_name)
with open(csv_filename, 'w', newline='') as file:
writer = csv.writer(file)
writer.writerows(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_results_to_disk(self, result_path,results):\n with open(result_path+\"/results.txt\",\"w+\") as out:\n\n for query_num in results:\n for doc_num in results[query_num]:\n out.write(str(query_num)+\" 0 \"+doc_num+\" 1 42.38 mt\\n\")\n out.close... | [
"0.72657835",
"0.69508463",
"0.6894959",
"0.67859924",
"0.6658391",
"0.642102",
"0.6414044",
"0.64095086",
"0.63856673",
"0.6371732",
"0.63349044",
"0.6330079",
"0.62855315",
"0.6249051",
"0.62146336",
"0.6207243",
"0.6203761",
"0.61993134",
"0.6197115",
"0.619168",
"0.618454... | 0.6300343 | 12 |
This function is used to fetch elastic search results based on action parameter | def command(self, action, payload):
try:
if action == 'append_book':
self.client.create_book_doc(
title=payload['title'],
authors=payload['authors'],
summary=payload['summary'],
publisher=payload['publis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search_action(self):\n #TODO: No access control checks for dataproxy resources!\n request_data = self._get_request_data(try_url_params=True)\n resource = Resource.get(request_data['resource_id'])\n if resource is not None and resource.url_type == 'dataproxy':\n pylons.res... | [
"0.69977385",
"0.6270674",
"0.6155154",
"0.6091651",
"0.60744435",
"0.6063062",
"0.60566103",
"0.60520285",
"0.60469556",
"0.6026246",
"0.601409",
"0.5985297",
"0.5985294",
"0.59679466",
"0.5951445",
"0.5915874",
"0.59071684",
"0.59010565",
"0.58931863",
"0.58861864",
"0.5877... | 0.0 | -1 |
Return the value associated to the label name in the nearest context that contains it. (search in context then context's parent and then parents of context's parent...) | def __getitem__(self, item):
current = self
while current is not None:
if item in current.locals:
return current.locals[item]
current = current.parent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _findLabel(self, label):\n if self.label == label:\n return self\n else:\n for i in range(self.nChildren()):\n found = self.children[i]._findLabel(label)\n if found:\n return found\n return None",
"def findLabel(s... | [
"0.6732785",
"0.6472502",
"0.63983274",
"0.6362595",
"0.6354665",
"0.6187552",
"0.5988228",
"0.5817141",
"0.5763987",
"0.57545006",
"0.565232",
"0.5647036",
"0.56420135",
"0.5641238",
"0.5640664",
"0.5623526",
"0.56224996",
"0.5612701",
"0.5604131",
"0.5601643",
"0.5600807",
... | 0.0 | -1 |
Override 'in' operator, search the label in the local dict and all the parents dicts. | def __contains__(self, item):
current = self
while current is not None:
if item in current.locals:
return True
current = current.parent
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deepin(self, key):\n \n if DEBUG:\n print(repr(self))\n if '.' in key:\n top, rest = key.split('.', 1)\n return self[top].deepin(rest)\n else:\n return key in self",
"def in_(self, other):\n if hasattr(other, 'cypher'):\n ... | [
"0.61111313",
"0.6106368",
"0.6081639",
"0.597423",
"0.5954512",
"0.5913556",
"0.5911842",
"0.59089094",
"0.58900696",
"0.58285034",
"0.58161646",
"0.5758629",
"0.5724211",
"0.5722771",
"0.5711671",
"0.5666077",
"0.56355524",
"0.56164795",
"0.5580589",
"0.5564229",
"0.5564229... | 0.5927448 | 5 |
Add a new instance. | def add_instance(self, context):
self.instance_contexts.append(context)
self.total_count += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_instance(self,name):\n new = self.create_instance(name)\n self.model.append(new)\n return new",
"def add(self, *args, **kwargs):\n obj = self._class(*args, **kwargs)\n self._items.append(obj)",
"def add(self):\n pass",
"def add_instance(instance_class, instance):\n ... | [
"0.76611966",
"0.7174424",
"0.70480835",
"0.70297074",
"0.67531794",
"0.67020816",
"0.67020816",
"0.66728026",
"0.6642528",
"0.66386175",
"0.6512499",
"0.6512499",
"0.6508215",
"0.64572376",
"0.6341272",
"0.6316406",
"0.63124824",
"0.63124824",
"0.63124824",
"0.63124824",
"0.... | 0.70086604 | 4 |
Reset the current_instance counter. | def reset_current_instance(self):
self.current_instance = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_counter(self) -> None:",
"def reset (self):\n self.counter = 0",
"def reset(self):\n self.counter = 0",
"def reset(cls):\n cls.__instance = None",
"def reset_count(self):\n self.count = 0",
"def reset_counter(self):\n if hasattr(self._id_generator, \"reset_cou... | [
"0.75970316",
"0.7579666",
"0.7566452",
"0.73800683",
"0.7352367",
"0.73349226",
"0.722008",
"0.7206008",
"0.7027615",
"0.69778574",
"0.69737387",
"0.6953763",
"0.69374794",
"0.6844482",
"0.6788848",
"0.678196",
"0.6729615",
"0.6675882",
"0.66605294",
"0.6637174",
"0.6578837"... | 0.8937279 | 0 |
Get the last instance added. | def get_last_instance(self):
return self.instance_contexts[-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_my_last_event(self):\r\n return self._handler.get_my_last_event()",
"def at_last(self):\n return self._collection.at_last()",
"def last(self):\n return self.last and self.last.value or None",
"def last(self):\n return self.deque[-1]",
"def getLastWorker(self):\n r... | [
"0.68711853",
"0.6810386",
"0.6726944",
"0.66564316",
"0.66301244",
"0.6626313",
"0.66114026",
"0.65852886",
"0.65747017",
"0.6562729",
"0.6555281",
"0.655031",
"0.6537491",
"0.65363795",
"0.6502471",
"0.6441597",
"0.6427053",
"0.6420172",
"0.640018",
"0.6364432",
"0.63504106... | 0.7894895 | 0 |
Get the current instance, then increment the current_instance value. | def get_next_instance(self):
self.current_instance += 1
return self.instance_contexts[self.current_instance - 1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_current_instance(self):\r\n self.current_instance = 0",
"def inc(self):\n with self.mutex:\n self.value += 1\n return self.value",
"def updateCounter(self):\n self.counter = self.counter + 1\n self.syncDataStructure[\"+\"][str(self.instanceID)] = self... | [
"0.690823",
"0.68347883",
"0.6701055",
"0.66770405",
"0.66295475",
"0.64652735",
"0.6456468",
"0.64496535",
"0.6416826",
"0.6364535",
"0.63558865",
"0.625179",
"0.6242719",
"0.62325436",
"0.6130614",
"0.61168027",
"0.6098057",
"0.608348",
"0.60704607",
"0.60397077",
"0.603596... | 0.8085299 | 0 |
Add a label to the current context. Override [] assignment. | def __setitem__(self, name: str, address: int):
if self.loaded:
return
if address is None:
address = self.mem_offset
elif address.bit_length() > 32:
raise ValueError("Label address should be 32 bits long!")
self.current_context[name] = addre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addLabel(*args):",
"def add_label(self, label):\n if not self.has_label(label):\n self.add_category(scheme=LABELS_SCHEME,\n term='%s#%s' % (LABELS_NS, label),\n label=label)",
"def add_label(self, label):\n status = self.ocp.add_label(resource_na... | [
"0.70385796",
"0.6876934",
"0.6845709",
"0.6823565",
"0.6769882",
"0.6705551",
"0.6681595",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.64906585",
"0.6435672",
"0.63145304",
"0.... | 0.5952216 | 48 |
Get address associated to the label name in current_context. | def __getitem__(self, name):
if name not in self.current_context:
raise KeyError("Trying to use an undefined label!")
return self.current_context[name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addr(label_name):\n\n if not utils.is_string_type(label_name):\n return None\n\n return labelmanager.addr(label_name)",
"def label(self):\n return self.address.label",
"def get_label(self):\r\n return _(\"Address:\")",
"def get_current_address(self):\n pass",
"def addr... | [
"0.8102275",
"0.74246526",
"0.69652647",
"0.69573796",
"0.68766636",
"0.67406845",
"0.66722447",
"0.662005",
"0.6568933",
"0.6568933",
"0.6568933",
"0.6543465",
"0.64369625",
"0.6348741",
"0.6345188",
"0.6335663",
"0.6335663",
"0.6301542",
"0.62912315",
"0.62291235",
"0.62291... | 0.5937727 | 47 |
Register a new macro in the macros dict. | def register_macro(self, name: str):
self.macros.setdefault(name, Macro()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_macro_context(self, name: str, context: dict = None):\r\n if context is None:\r\n context = dict()\r\n self.macros[name].add_instance(dict())",
"def _expand_macros(tokdict,macrodict):\r\n def macro_value(m):\r\n return '(?:%s)' % macrodict[m.groupdict()['macro']]\r\n ... | [
"0.667128",
"0.6386615",
"0.6171267",
"0.5982367",
"0.59769773",
"0.58068347",
"0.57270074",
"0.5714279",
"0.5649475",
"0.56381917",
"0.5628102",
"0.5482599",
"0.5440994",
"0.5368773",
"0.5367753",
"0.5353264",
"0.53425723",
"0.5309798",
"0.5293307",
"0.52802014",
"0.52768517... | 0.8195985 | 0 |
Add a new instance/context to a Macro object | def add_macro_context(self, name: str, context: dict = None):
if context is None:
context = dict()
self.macros[name].add_instance(dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_instance(self, context):\r\n self.instance_contexts.append(context)\r\n self.total_count += 1",
"def add(self, context):\n self._contexts.add(context)",
"def __init__(self, macro_name, macro_content):\n self._macro_name = process_for_latex(macro_name)\n self._macro_co... | [
"0.64550906",
"0.5815178",
"0.581206",
"0.57343155",
"0.56727946",
"0.565651",
"0.56156",
"0.5564796",
"0.5564684",
"0.5454445",
"0.536506",
"0.5324165",
"0.53177595",
"0.5314927",
"0.5123087",
"0.5122237",
"0.508866",
"0.50394654",
"0.5033408",
"0.5000955",
"0.49768367",
"... | 0.8081105 | 0 |
Switch the current context. | def switch_context(self, context):
self.context_stack.append(self.current_context)
self.current_context = context | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def switch(self, context):\n return",
"def _set_context(self, ctx):\n try:\n current_engine_name = self.parent.engine.name \n if sgtk.platform.current_engine(): \n sgtk.platform.current_engine().destroy()\n sgtk.platform.start_engine(curren... | [
"0.7744432",
"0.7199943",
"0.71186477",
"0.69892776",
"0.68974406",
"0.68526095",
"0.68338317",
"0.68338317",
"0.678041",
"0.6674753",
"0.66629636",
"0.66492593",
"0.6548222",
"0.6524813",
"0.6431893",
"0.61897355",
"0.6144941",
"0.6088508",
"0.60671574",
"0.60372967",
"0.594... | 0.8493895 | 0 |
Restore the previous context. | def restore_context(self):
self.current_context = self.context_stack.pop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def context_reset(self):\n self._context_state = None\n logging.info('Resetting the context')",
"def restore_context(self, filepath):\n\n raise NotImplementedError()",
"def reset(self, *_):\n with self._context.lock:\n super().reset()\n self.__context_init()",
"def r... | [
"0.7633371",
"0.71010125",
"0.7044028",
"0.6811748",
"0.6767361",
"0.6687625",
"0.66691613",
"0.6668881",
"0.65513235",
"0.6521201",
"0.6511832",
"0.6501799",
"0.65001637",
"0.6458619",
"0.6444411",
"0.6437519",
"0.64000064",
"0.6383079",
"0.6379866",
"0.63735694",
"0.6261989... | 0.8610675 | 0 |
The macro function decorator. | def macro(self, func):
self.register_macro(func.__name__)
def wrapper(*args, **kwargs):
old = func.__globals__.copy()
for key in self.current_context.keys():
del func.__globals__[key]
if not self.loaded:
self.add_macro_contex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_macro(extension):\n def macro(body, args, kwargs, is_block, environ):\n if extension.is_void and body:\n return wrap(MarkupErrorElement(\n _(u'Macro “%s” was passed a body but does not '\n u'support it.') % extension.name))\n # ensure the body is... | [
"0.6746005",
"0.65535325",
"0.65420234",
"0.6394286",
"0.630091",
"0.62976325",
"0.6149211",
"0.6125098",
"0.6049065",
"0.5981956",
"0.5956665",
"0.5904848",
"0.5892715",
"0.5882666",
"0.58784175",
"0.5797652",
"0.5781429",
"0.5764209",
"0.5754016",
"0.57075137",
"0.5688477",... | 0.6873393 | 0 |
Creates four plotly visualizations | def return_figures():
graph_one = []
df = cleanparrisdf('data/Salem-Village-Data-Set.csv')
sources = [0,0,0,1,1,1]
targets = [2,3,4,2,3,4]
values = df["petition_count"].tolist()
data_one = dict(
type = 'sankey',
node = dict(
pad = 10,
thickness = 30,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_four_subplots():\n pass",
"def _dump_plotly(objs, images, func):\n l = len(objs)\n #print(l)\n titles = []\n for i,x in enumerate(objs):\n if 'id' in x:\n titles.append('shape id %d' % x.id)\n else:\n titles.append('item %d' % i)\n fig = tools.make... | [
"0.67787457",
"0.67741823",
"0.6709394",
"0.66095567",
"0.6584778",
"0.6558427",
"0.65149283",
"0.65014064",
"0.6490014",
"0.6450255",
"0.64477116",
"0.64458466",
"0.6433457",
"0.64264965",
"0.63953656",
"0.63761175",
"0.6325457",
"0.6275925",
"0.6252392",
"0.62307435",
"0.62... | 0.65156674 | 6 |
Called once for each new DBAPI connection or Pool's ``creator()``. | def connect(self, dbapi_connection, connection_record): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_db(self):",
"def __post_init__(self):\n self.dbase = databases.Database(\n self.dsn,\n min_size=self.min_size,\n max_size=self.max_size\n )\n self.engine, self.meta = self.get_engine_metadata()",
"def __init__(self):\r\n self.conn = create... | [
"0.67084223",
"0.6569219",
"0.6454597",
"0.6436407",
"0.63408655",
"0.6325389",
"0.6321908",
"0.6320368",
"0.6276563",
"0.6123838",
"0.6116719",
"0.60971427",
"0.60663396",
"0.6058905",
"0.6053489",
"0.60504884",
"0.6048023",
"0.60348487",
"0.6015557",
"0.60084504",
"0.600389... | 0.5790405 | 43 |
Called exactly once for the first DBAPI connection. | def first_connect(self, dbapi_connection, connection_record): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._connection = get_db_connection()",
"def connect(self, dbapi_connection, connection_record):",
"def _db_connection(self):\n pass",
"def init(self):\n self.conn = None\n\n return True",
"def __init__(self):\n\t\tself.obtainDatabaseConnection()",
"def ... | [
"0.67195183",
"0.6715476",
"0.656256",
"0.6527683",
"0.65126604",
"0.6497691",
"0.64863473",
"0.6459973",
"0.64582694",
"0.6446564",
"0.6421492",
"0.64208746",
"0.64178276",
"0.6338431",
"0.63314486",
"0.63314486",
"0.63314486",
"0.63299924",
"0.6309114",
"0.62960386",
"0.627... | 0.82037026 | 0 |
Called when a connection is retrieved from the Pool. | def checkout(self, dbapi_connection, connection_record, connection_proxy): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connection_handler(self):\n\t\tyield",
"def connection(self):\n pass",
"def handle_connect(self):\n pass",
"def onConnect(self, fetcher, connectionRespInfo): #$NON-NLS-1$\r",
"def on_connection_closed(self):",
"def _get_pool (self, event):\n return self.pool",
"def connectionMade(s... | [
"0.68182594",
"0.65938705",
"0.65584147",
"0.6508858",
"0.6370177",
"0.63244736",
"0.631224",
"0.625429",
"0.61409163",
"0.61398953",
"0.61378413",
"0.61329424",
"0.6114277",
"0.6067553",
"0.6044404",
"0.6031086",
"0.6023959",
"0.5957651",
"0.5946259",
"0.59285915",
"0.58868"... | 0.0 | -1 |
Called when a connection returns to the pool. Note that the connection may be closed, and may be None if the connection has been invalidated. ``checkin`` will not be called for detached connections. (They do not return to the pool.) | def checkin(self, dbapi_connection, connection_record): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect_ping_listener(connection, branch):\n if branch:\n return\n\n save_should_close_with_result = connection.should_close_with_result\n connection.should_close_with_result = False\n try:\n connection.scalar(select([1]))\n except Exception as ex:\n connection.scalar(selec... | [
"0.60195",
"0.5795708",
"0.5717088",
"0.5673639",
"0.5561772",
"0.5525928",
"0.5447038",
"0.54178834",
"0.53633946",
"0.53565466",
"0.53255045",
"0.5321494",
"0.5262716",
"0.5241045",
"0.5227323",
"0.5221151",
"0.5160429",
"0.5118911",
"0.5092049",
"0.5090331",
"0.507445",
... | 0.566654 | 4 |
Create the response for a resource. Note this will only be called on a GET request, or on a POST request if always_return_data is True | def create_response(self, *args, **kwargs):
response = super(BaseCorsResource, self).create_response(*args, **kwargs)
response['Access-Control-Allow-Origin'] = '*'
response['Access-Control-Allow-Headers'] = 'Content-Type'
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_response(self, request, data, response_class=HttpResponse, **response_kwargs):\n desired_format = self.determine_format(request)\n serialized = self.serialize(request, data, desired_format)\n return response_class(content=serialized, content_type=build_content_type(desired_format), ... | [
"0.684795",
"0.67284703",
"0.65661",
"0.65661",
"0.6558773",
"0.6552452",
"0.65262616",
"0.64544326",
"0.6433191",
"0.64107007",
"0.6401898",
"0.6400182",
"0.6398697",
"0.6370619",
"0.63630956",
"0.6340539",
"0.63312286",
"0.63245285",
"0.63164157",
"0.6306914",
"0.62642473",... | 0.5979391 | 38 |
In case of POST make sure we return the AccessControlAllow Origin regardless of returning data | def post_list(self, request, **kwargs):
response = super(BaseCorsResource, self).post_list(request, **kwargs)
response['Access-Control-Allow-Origin'] = '*'
response['Access-Control-Expose-Headers'] = 'Location'
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allow_cors(response):\n response.headers['Access-Control-Allow-Origin'] = '*'\n return response",
"def set_allow_origin(resp):\r\n\r\n h = resp.headers\r\n\r\n # Allow crossdomain for other HTTP Verbs\r\n if request.method != 'OPTIONS' and 'Origin' in request.headers:\r\n h['Access-Cont... | [
"0.7086852",
"0.69381195",
"0.6836254",
"0.66719115",
"0.6659176",
"0.6654634",
"0.6618818",
"0.6615156",
"0.66011363",
"0.6375704",
"0.63684464",
"0.63684464",
"0.63429356",
"0.63429356",
"0.63219905",
"0.6309055",
"0.63040024",
"0.6261309",
"0.62494254",
"0.62150615",
"0.61... | 0.6290511 | 17 |
Check for an OPTIONS request. If so return the Allow headers | def method_check(self, request, allowed=None):
if allowed is None:
allowed = []
request_method = request.method.lower()
allows = ','.join(map(lambda s: s.upper(), allowed))
if request_method == 'options':
response = HttpResponse(allows)
response['A... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OPTIONS(self, req):\r\n resp = req.get_response(self.app)\r\n return resp",
"def option_autoreply():\r\n\r\n if request.method == 'OPTIONS':\r\n resp = app.make_default_options_response()\r\n\r\n headers = None\r\n if 'ACCESS_CONTROL_REQUEST_HEADERS' in request.headers:\... | [
"0.71109694",
"0.69889754",
"0.6984551",
"0.6971069",
"0.6924216",
"0.66727746",
"0.6659201",
"0.66527027",
"0.66407734",
"0.66034204",
"0.6574077",
"0.6539291",
"0.6531127",
"0.6491254",
"0.6491254",
"0.6483288",
"0.6477986",
"0.6375473",
"0.63449395",
"0.6335919",
"0.632943... | 0.6661477 | 6 |
This function returns a Pyramid WSGI application. | def main(global_config, **settings):
session_factory = UnencryptedCookieSessionFactoryConfig('ent85an')
config = Configurator(settings=settings, session_factory=session_factory)
config.include('pyramid_chameleon')
config.add_static_view('static', 'test2:static')
config.add_route('home', '/')
con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wsgi_app():\n return bottle.default_app()",
"def wsgi_app():\n return bottle.default_app()",
"def bootstrap_wsgi():\n return get_wsgi_application()",
"def app():\n return create_app()",
"def app():\n app = create_app()\n return app",
"def create_app():\n from server.web import cr... | [
"0.7845448",
"0.7845448",
"0.77415055",
"0.77049613",
"0.7661403",
"0.7531494",
"0.7400627",
"0.72649485",
"0.7240864",
"0.7236693",
"0.71695787",
"0.7167029",
"0.7141517",
"0.7115303",
"0.7102023",
"0.7096362",
"0.7059266",
"0.7029423",
"0.7027549",
"0.7004948",
"0.70026654"... | 0.0 | -1 |
update a client entry | def set(self, client):
if not client:
raise SurvoxAPIMissingParameter('client')
c = self.get()
if not c:
raise SurvoxAPIRuntime('No client available named: {name}'.format(name=self.name))
return self.api_put(endpoint=self.url, data=client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_client(client_name, updated_client_name): # Operacion modificar\n global clients\n\n if client_name in clients:\n index = clients.index(client_name)\n clients[index] = updated_client_name\n else:\n print(\"Client isn\\'t in the client list\")",
"def update(self, klient):... | [
"0.7091264",
"0.68076223",
"0.66998833",
"0.631657",
"0.6194887",
"0.6194887",
"0.61497957",
"0.61200696",
"0.61006886",
"0.60602057",
"0.603199",
"0.6016784",
"0.60054356",
"0.597109",
"0.5959419",
"0.5959419",
"0.5959419",
"0.5945082",
"0.5945082",
"0.5945082",
"0.5945082",... | 0.61617506 | 6 |
Creates an HTML file with given template and content. | def create_html(text, template, output):
# TODO uncomment this for orginal DMP format (right now difficult with differing section sizes)
#templateLoader = jinja2.FileSystemLoader(searchpath="../templates/new")
templateLoader = jinja2.FileSystemLoader(searchpath="../templates")
templateEnv = jinja2.Envi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def provide_html_template():\n get_content = str(input(\"Paste the content you want to see displayed in the browser here. \\n\"))\n get_name = input(\"I am going to create an html file with your content. What do you want to call your file? \\n\")\n \n new_html_file = open(str(get_name) + '.html', 'w')\... | [
"0.76947534",
"0.70680845",
"0.6908305",
"0.68400776",
"0.68179643",
"0.6798371",
"0.6737883",
"0.67168546",
"0.6636704",
"0.655709",
"0.65269643",
"0.646904",
"0.6464826",
"0.64504373",
"0.6447081",
"0.64354914",
"0.6418375",
"0.6408326",
"0.640207",
"0.63944256",
"0.6386369... | 0.7549857 | 1 |
Converts a given HTML file into a PDF. | def create_pdf(html, options):
# TODO: we will change this path, or use an other library for converting PDF!
# TODO: otherwise just say that wkhtmltopdf needs to be pre-installed (and how) and added to windows path
path_wkthmltopdf = "C:/Program Files/wkhtmltopdf/bin/wkhtmltopdf.exe"
config = pdfkit.co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def html2pdf(html_filename, output_filename=None, **options):\n\n if not output_filename:\n output_filename = newTempfile(suffix='.pdf')\n\n if not pdfreactor_available:\n raise RuntimeError(\"The external 'pdfreactor' converter isn't available\")\n\n cmd = '%s \"pdfreactor\" \"%s\" \"%s\"' ... | [
"0.7248246",
"0.7169749",
"0.71362674",
"0.6948476",
"0.6708248",
"0.6610215",
"0.658075",
"0.6533911",
"0.6426139",
"0.642575",
"0.63720566",
"0.63564223",
"0.61420655",
"0.6088606",
"0.60696626",
"0.6064924",
"0.6037568",
"0.6029076",
"0.6007931",
"0.5998022",
"0.59935737",... | 0.756505 | 0 |
Return list of groups (id) for requested projects flag groups declared as projects owner | def get_project_groups_id(self, names):
assert isinstance(names, list)
# Getting access rules for all projects hosted
# is done by one request specifiying multiple
# project names inside the query string. To act safer
# bulk limits the amount of projects requested in one shot
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_groups(self, obj):\n groupsForCompany = get_groups_with_perms(obj)\n return [x.id for x in groupsForCompany]",
"def get_groups(id_project):\n data = sql.list_groups(id_project)\n names = [(d['id'], d['name']) for d in data]\n return names",
"def list_projects(ctx):\n pprint(ct... | [
"0.66103697",
"0.6584689",
"0.6564444",
"0.6420417",
"0.6404506",
"0.63974404",
"0.6299866",
"0.627742",
"0.62102056",
"0.6117552",
"0.61089313",
"0.60776865",
"0.60669416",
"0.60601676",
"0.60473305",
"0.6034015",
"0.6022365",
"0.59869814",
"0.5985959",
"0.5977469",
"0.59712... | 0.66556174 | 0 |
Request the group endpoint to get details of multiple groups | def get_groups_details(self, groups):
assert isinstance(groups, list)
# It may be require we request the API by splitting the names list
# If the list is too long to be handled by the Gerrit server (URI)
query_args = "?%s" % "&".join(["q=%s" % g for g in groups])
query_args += "&... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def groups(self):\n #return self.get('{}/groups'.format(ApiVersion.A1.value))\n return self.get('{}/groups'.format(ApiVersion.CM1.value))",
"def test_api_v1_groups_get(self):\n pass",
"def get_groups():\r\n if 'username' not in flask.session:\r\n return flask.jsonify(**{'message': 'Forbi... | [
"0.7579643",
"0.7527016",
"0.7344905",
"0.7330088",
"0.72096586",
"0.7103131",
"0.70869297",
"0.70068043",
"0.7004014",
"0.69652194",
"0.69452596",
"0.6931994",
"0.6902277",
"0.6881346",
"0.6832857",
"0.6832857",
"0.679868",
"0.6796173",
"0.6764522",
"0.6754042",
"0.6751882",... | 0.72024137 | 5 |
Update a gerrit account. Only 'full_name' and 'email' can be updated. | def update_account(self, id=None, username=None, **kwargs):
if not (bool(id) != bool(username)):
raise TypeError('account id OR username needed')
if 'full_name' in kwargs.keys():
try:
self.g.put('accounts/%s/name' % id or username,
data=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account_update(request):\r\n params = request.params\r\n json_body = request.json_body\r\n user_acct = request.user\r\n\r\n if 'name' in params and params['name'] is not None:\r\n name = params.get('name')\r\n user_acct.name = name\r\n\r\n if 'name' in json_body and json_body['name... | [
"0.7108805",
"0.6938995",
"0.6783032",
"0.65848964",
"0.6567411",
"0.6345919",
"0.63428134",
"0.63318664",
"0.6312359",
"0.6220183",
"0.6206186",
"0.6164123",
"0.60568076",
"0.60517806",
"0.60360813",
"0.60136294",
"0.60079366",
"0.59596103",
"0.5938938",
"0.5931337",
"0.5928... | 0.74522334 | 0 |
Add a group as a member of targetgroup | def add_group_group_member(self, targetgroup, groupname):
try:
targetgroup = self.quote(targetgroup)
groupname = self.quote(groupname)
self.g.put('groups/%s/groups/%s' % (targetgroup,
groupname),
headers={... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def target_add():\r\n try:\r\n target_id = request.post_vars[\"target\"]\r\n group_id = request.post_vars[\"group\"]\r\n except KeyError:\r\n pass\r\n\r\n result = gl.add_to_targetgroup(target_id, group_id)\r\n\r\n if result:\r\n return response.json({'success': 'true'})\r\n... | [
"0.7717108",
"0.7391383",
"0.71136713",
"0.7108314",
"0.7095311",
"0.7065485",
"0.701168",
"0.7006552",
"0.70005846",
"0.6773371",
"0.67148256",
"0.66208655",
"0.65720075",
"0.6564292",
"0.6531716",
"0.65001243",
"0.63495827",
"0.6329787",
"0.62838423",
"0.6272301",
"0.626889... | 0.7701457 | 1 |
Get members (only groups) from a group | def get_group_group_members(self, group_id):
try:
group_id = self.quote(group_id)
return self.g.get('groups/%s/groups/' % group_id)
except HTTPError as e:
return self._manage_errors(e) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetGroupMembers(self, group):\n return []",
"def get_group_members(self, group):\n members = []\n result = self.search('ou=groups,dc=mozilla',\n filterstr='cn=%s' % (group))\n if result == False:\n raise self.SearchError\n elif result == []:\n ... | [
"0.83936936",
"0.8045745",
"0.79308033",
"0.78087026",
"0.76893365",
"0.7658868",
"0.7603729",
"0.741923",
"0.7283984",
"0.7239289",
"0.71412396",
"0.7121257",
"0.7118644",
"0.7051566",
"0.6994696",
"0.69646496",
"0.69614774",
"0.6901935",
"0.6875227",
"0.68618",
"0.68494815"... | 0.73979783 | 8 |
Delete a group from targetgroup | def delete_group_group_member(self, targetgroup, groupname):
try:
targetgroup = self.quote(targetgroup)
groupname = self.quote(groupname)
self.g.delete('groups/%s/groups/%s' % (targetgroup,
groupname),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_targetgroup(self, group_id):\r\n result = False\r\n if self._db(self._db.targetgroup.id==group_id).select():\r\n result = True\r\n self._db(self._db.targetgroup.id==group_id).delete()\r\n self._db.commit()\r\n return result",
"def delete_group(self, gr... | [
"0.8396896",
"0.8185979",
"0.7967666",
"0.7891638",
"0.77520156",
"0.77520156",
"0.77403957",
"0.7690325",
"0.76890093",
"0.7616403",
"0.7475202",
"0.7426562",
"0.7398512",
"0.7395208",
"0.7328195",
"0.72837687",
"0.7269247",
"0.7232773",
"0.720851",
"0.7190769",
"0.71823627"... | 0.7907041 | 3 |
Query and report the OSP version installed. | def version(version_file=default_version_file, osp_package=default_osp_package):
if os.path.exists(version_file):
(version_string, version_name) = version_from_file(version_file)
else:
package_info = get_package_info(osp_package)
repo_name = get_package_repo_name(package_info)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_version(self):\n verxml = self._ncc.nxoscli('show version')\n self.logger.debug(verxml)\n verparsed = _begin_parse(verxml)\n sysmgrclischema = parse_get_nsmap(verparsed)\n self.logger.debug(\"NSMAP: {}\".format(sysmgrclischema))\n showversion = find_element(['sys_v... | [
"0.62560534",
"0.62320054",
"0.61539745",
"0.6118965",
"0.6067751",
"0.6008523",
"0.60057247",
"0.5996084",
"0.5991579",
"0.5935117",
"0.59256303",
"0.58937836",
"0.58934015",
"0.58901566",
"0.58520997",
"0.58439976",
"0.5840832",
"0.58345205",
"0.579143",
"0.5719222",
"0.570... | 0.0 | -1 |
From OSP 13 on the version release and build numbers are reported in a | def version_from_file(version_filename):
version_pattern = "Red Hat OpenStack Platform release ([\d.]+) \((.*)\)"
version_re = re.compile(version_pattern)
# should try and check. A single line with a newline
version_file = open(version_filename)
release_string = version_file.read().strip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBuild(number):",
"def getBuild(number):",
"def getBuild():",
"def test_get_build_number(self):\n pass",
"def _get_version(self):",
"def Version(self) -> _n_0_t_12:",
"def Version(self) -> _n_0_t_12:",
"def get_comp_versions (component):\n vprint (\"Detecting current version for \" + ... | [
"0.7062167",
"0.7062167",
"0.68922627",
"0.6604141",
"0.6483877",
"0.6466972",
"0.6466972",
"0.6383637",
"0.6371243",
"0.6340458",
"0.62917477",
"0.62903494",
"0.6287496",
"0.62805766",
"0.62408024",
"0.6207156",
"0.6180137",
"0.6142765",
"0.6140882",
"0.60793465",
"0.6038238... | 0.0 | -1 |
Query the system for package information of a specified RPM Query the package information only for the installed package and work from cached data to avoid side effects to the host. Return a list of lines from the response STDOUT | def get_package_info(package_name):
info_command_template = "yum info installed --cacheonly {}"
info_command = info_command_template.format(package_name)
# subprocess wants a list of arguments, not a single string
try:
package_info = subprocess.check_output(info_command.split(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_packages(module, repo_mgr, list_type, package):\n rc_code, out, err = module.run_command(\"/usr/bin/%s -q list %s %s\"\n % (repo_mgr, list_type, package), environ_update=ENV_LOCALE)\n if rc_code is 0:\n return out.splitlines()\n else:\n if rc... | [
"0.6890891",
"0.6458352",
"0.6417518",
"0.6267885",
"0.61134464",
"0.6095884",
"0.60921556",
"0.60532266",
"0.6008601",
"0.59963685",
"0.59829915",
"0.594374",
"0.59393394",
"0.5866107",
"0.5844895",
"0.58440983",
"0.56793255",
"0.5670345",
"0.5658176",
"0.5651326",
"0.563908... | 0.66073734 | 1 |
The source repo name is stored with the package. The "From repo" line indicates where the package came from. Return the repo name or None if not found | def get_package_repo_name(package_info):
# should check that there is EXACTLY one line
repo_lines = \
[line for line in package_info if line.startswith("From repo ")]
# "From repo : <repo name>"
# Get the value and remove white space.
if len(repo_lines) > 0:
repo_name = repo_lin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def source_repo_name(vcs):\n return 'source'",
"def repo_of_package(self, package_name: str) -> str:\n if package_name not in self.all_packages_dict:\n return Colors.BOLD(Colors.LIGHT_MAGENTA(\"local/\") + package_name)\n package = self.all_packages_dict[package_name]\n if pack... | [
"0.7836136",
"0.7142839",
"0.6934166",
"0.6934166",
"0.6934166",
"0.66367394",
"0.6576414",
"0.6525963",
"0.64376867",
"0.6327674",
"0.6325919",
"0.631426",
"0.6271193",
"0.62525576",
"0.62364066",
"0.6220603",
"0.6095599",
"0.6084242",
"0.6082746",
"0.6072888",
"0.6054819",
... | 0.78646374 | 0 |
Get the repo name for an OSP package That name should indicate the major version of OSP from a table. Return the version matching the repo name or None if not found | def get_version_from_repo_name(package_repo_name):
version_string = yum_repos[package_repo_name] \
if package_repo_name in yum_repos.keys() \
else None
return version_string | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_package_repo_name(package_info):\n\n # should check that there is EXACTLY one line\n repo_lines = \\\n [line for line in package_info if line.startswith(\"From repo \")]\n\n # \"From repo : <repo name>\"\n # Get the value and remove white space.\n if len(repo_lines) > 0:\n r... | [
"0.69046545",
"0.66761976",
"0.64646137",
"0.6194541",
"0.61512",
"0.61512",
"0.61512",
"0.61041784",
"0.6055042",
"0.6055042",
"0.60245675",
"0.6001156",
"0.59974265",
"0.59744567",
"0.59740454",
"0.5970664",
"0.59664947",
"0.5939434",
"0.5933307",
"0.5932706",
"0.591309",
... | 0.7307918 | 0 |
Given xyz coordinates & dimensions of array, returns the vector index | def ravel_index(x, dims):
i = 0
for dim, j in zip(dims, x):
i *= dim
i += j
return i | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _index(tensor_3d, tensor_2d):\n x, y, z = tensor_3d.size()\n t = tensor_3d.reshape(x * y, z)\n tt = tensor_2d.reshape(x * y)\n v = t[torch.arange(x * y), tt]\n v = v.reshape(x, y)\n return v",
"def get_ind(self,*q):\n try:\n if( len(q) == 1 ):\n x = q[0][:,0... | [
"0.6535142",
"0.6418414",
"0.63375473",
"0.62212586",
"0.60786873",
"0.6034432",
"0.6029652",
"0.60194445",
"0.6014285",
"0.5993988",
"0.5975879",
"0.59538525",
"0.59294975",
"0.5920307",
"0.5894706",
"0.58881086",
"0.58801156",
"0.5853542",
"0.5853542",
"0.58395815",
"0.5832... | 0.6307502 | 3 |
Each of the columns in X will be correlated with each of the columns in Y. Each column represents a variable, with the rows containing the observations. | def custom_corrcoef(X, Y=None):
if Y is None:
Y = X
if X.shape[0] != Y.shape[0]:
raise Exception("X and Y must have the same number of rows.")
X = X.astype(float)
Y = Y.astype(float)
X -= X.mean(axis=0)[np.newaxis,...]
Y -= Y.mean(axis=0)
xx = np.sum(X**2,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correlateX(X, y, corr=\"spearman\"):\n \n X = np.array(X)\n y = np.array(y)\n ## Force... just in case\n \n checkX(X)\n\n if corr == \"pearson\":\n corrf = pearsonr\n elif corr == \"spearman\":\n corrf = spearmanr\n else:\n raise ValueError(\"stat was not val... | [
"0.7245431",
"0.69604236",
"0.68757576",
"0.64894485",
"0.6477084",
"0.6451335",
"0.6428377",
"0.63228226",
"0.63146174",
"0.62669325",
"0.6253946",
"0.623037",
"0.62075186",
"0.6185182",
"0.61833954",
"0.61788404",
"0.6172652",
"0.61705166",
"0.6142473",
"0.613695",
"0.61175... | 0.6433049 | 6 |
Takes an input and converts it into a float number | def main():
try:
x = input("Type in a number to be converted to a float: ")
floatnum = float(x)
print(floatnum)
except(ValueError):
print("Could not convert the string to a float") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_float(self, prompt=\"> \"):\n\t\twhile True:\n\t\t\tans = raw_input(prompt)\n\t\t\ttry: \t\n\t\t\t\tans = float(ans)\n\t\t\t\treturn ans\n\t\t\texcept ValueError:\n\t\t\t\tif ans == \"quit\": quit()\n\t\t\t\telse: print \"Please enter a number using decimal notation.\"",
"def char_float(inp_char):\n try... | [
"0.7609443",
"0.75654024",
"0.7514502",
"0.74880666",
"0.73692375",
"0.73636425",
"0.7316602",
"0.72737426",
"0.7193005",
"0.7177591",
"0.71387315",
"0.70654273",
"0.7059681",
"0.70422375",
"0.7035431",
"0.7034577",
"0.7033259",
"0.7026536",
"0.69930553",
"0.6986892",
"0.6977... | 0.80235124 | 0 |
Loads a human readable English name for each softmax node. | def load(self, label_lookup_path, uid_lookup_path):
if not tf.gfile.Exists(uid_lookup_path):
tf.logging.fatal('File does not exist %s', uid_lookup_path)
if not tf.gfile.Exists(label_lookup_path):
tf.logging.fatal('File does not exist %s', label_lookup_path)
# Loads mapping from string UID to hu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self):\n return \"Softmax. T=\" + str(self.temperature)",
"def get_name():\n return \"SVM\"",
"def get_name():\n return \"SVM+\"",
"def get_name():\n return \"SVMd+\"",
"def get_name():\n return \"SVMd+ - simplified approach\"",
"def _generate_node_name(self):\... | [
"0.6529055",
"0.60038584",
"0.5878624",
"0.5807888",
"0.5711545",
"0.55374044",
"0.5468764",
"0.54467833",
"0.5432578",
"0.54321104",
"0.5411982",
"0.54081184",
"0.5389949",
"0.5364748",
"0.53441465",
"0.5273549",
"0.5242557",
"0.5232287",
"0.52074456",
"0.5201877",
"0.520096... | 0.0 | -1 |
Runs inference on an image. | def run_inference_on_image(image):
if not tf.gfile.Exists(image):
tf.logging.fatal('File does not exist %s', image)
image_data = tf.gfile.FastGFile(image, 'rb').read()
# Creates graph from saved GraphDef.
#create_graph()
with tf.Session() as sess:
# Some useful tensors:
# 'softmax:0': A tensor c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_inference_on_image(image):\n if not gfile.Exists(image):\n tf.logging.fatal('File does not exist %s', image)\n image_data = gfile.FastGFile(image, 'rb').read()\n\n # Creates graph from saved GraphDef.\n create_graph()\n\n with tf.Session() as sess:\n # Runs the softmax tensor by feeding the imag... | [
"0.80876434",
"0.76775897",
"0.7585265",
"0.7361889",
"0.72406197",
"0.7163995",
"0.70659184",
"0.69971216",
"0.69961894",
"0.69929576",
"0.69677186",
"0.6897145",
"0.68879974",
"0.6879423",
"0.6831557",
"0.68114525",
"0.67840654",
"0.6757619",
"0.67368376",
"0.6732527",
"0.6... | 0.7535307 | 3 |
Download and extract model tar file. | def maybe_download_and_extract():
dest_directory = FLAGS.model_dir
if not os.path.exists(dest_directory):
os.makedirs(dest_directory)
filename = DATA_URL.split('/')[-1]
filepath = os.path.join(dest_directory, filename)
if not os.path.exists(filepath):
def _progress(count, block_size, total_size):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_and_unpack_model(model_name, model_date='20200711'):\n\n # pretrained models\n pretrained_models_dir = os.path.join(ROOT_DIR, 'pre-trained-models')\n create_directory_if_not_exists(pretrained_models_dir)\n\n # pretrained model archives\n model_archive_dir = os.path.join(pretrained_model... | [
"0.783391",
"0.77010363",
"0.7660963",
"0.7633819",
"0.7511147",
"0.7439116",
"0.7427492",
"0.73181266",
"0.71618634",
"0.70268524",
"0.700018",
"0.6992704",
"0.6983917",
"0.6976861",
"0.68549454",
"0.6840488",
"0.68346643",
"0.6769262",
"0.67121315",
"0.67109853",
"0.6683404... | 0.7627266 | 4 |
Builds a random function of depth at least min_depth and depth at most max_depth (see assignment writeup for definition of depth in this context) | def build_random_function(min_depth, max_depth):
listoffunctions = [ ["x"] , ["y"] , [""] ]
var = random.randrange(0,7) #this is not inclusive at the upper end
halfvar = random.randrange(0,2)
otherhalfvar = random.randrange(0,2)
if max_depth == 0: # if you get the the max depth... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_random_function(min_depth, max_depth):\n depth = random.randint(min_depth, max_depth)\n return build_random_function_helper(depth)",
"def build_random_function(min_depth, max_depth):\n\n # your code goes here",
"def build_rand_func(min_depth, max_depth):\n\n\toptions = [['prod'],['sin_pi'],[... | [
"0.89440006",
"0.87607706",
"0.8079794",
"0.801927",
"0.79594904",
"0.78108656",
"0.7484326",
"0.64881915",
"0.6170833",
"0.6011024",
"0.5912187",
"0.5898084",
"0.5888185",
"0.57918245",
"0.5591146",
"0.55420274",
"0.550629",
"0.54398507",
"0.541542",
"0.532502",
"0.53238696"... | 0.7593185 | 6 |
Evaluate the random function f with inputs x,y Representation of the function f is defined in the assignment writeup | def evaluate_random_function(f, x, y):
# this section actually evaluates the functions
if f[0] == "x":
return x
elif f[0] == "y":
return y
elif f[0] == "sin_pi":
return math.sin(math.pi*evaluate_random_function(f[1], x, y ))
elif f[0] == "cos_pi":
return math.co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_random_function(f, x, y):\n\n # your code goes here",
"def evaluate_random_function(f, x, y):\n\n if f[0] == \"prod\":\n return evaluate_random_function(f[1],x,y) * evaluate_random_function(f[2],x,y)\n elif f[0] == \"sin_pi\":\n return sin(evaluate_random_function(f[1],x,y) * ... | [
"0.8462733",
"0.8068793",
"0.8034158",
"0.7850618",
"0.7745526",
"0.76073825",
"0.7115134",
"0.6986317",
"0.66636187",
"0.6654048",
"0.64210814",
"0.63877445",
"0.6360093",
"0.6220911",
"0.6102655",
"0.6082553",
"0.60335815",
"0.60012615",
"0.5903432",
"0.57977605",
"0.579170... | 0.7887029 | 3 |
Given an input value in the interval [input_interval_start, input_interval_end], return an output value scaled to fall within the output interval [output_interval_start, output_interval_end]. | def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):
inputrange = float(input_interval_end) - float(input_interval_start) #finds length or original interval
outputrange = float(output_interval_end) - float(output_interval_start) #finds length of t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remap_interval(val, input_interval_start, input_interval_end, output_interval_start, output_interval_end):\n convert = float (val - input_interval_start) / float ( input_interval_end - input_interval_start)\n output1 = output_interval_start + convert* (output_interval_end - output_interval_start)\n re... | [
"0.79932183",
"0.7901168",
"0.7887289",
"0.7876046",
"0.7751076",
"0.7288981",
"0.7237463",
"0.7120831",
"0.7019347",
"0.6851704",
"0.68007386",
"0.66910595",
"0.6677727",
"0.6569077",
"0.6418457",
"0.62758476",
"0.625303",
"0.6198374",
"0.6172267",
"0.616496",
"0.616496",
... | 0.8289255 | 0 |
Maps input value between 1 and 1 to an integer 0255, suitable for use as an RGB color code. | def color_map(val):
# NOTE: This relies on remap_interval, which you must provide
color_code = remap_interval(val, -1, 1, 0, 255)
return int(color_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def color_map(val):\n color_code = remap_interval(val, -1, 1, 0, 255)\n return int(color_code)",
"def c_map(val):\n return int(remap(val, -1, 1, 0, 255))",
"def get_color(self, value):\n value = min(max(0,value), 1) * 510\n\n if value < 255:\n redValue = 255\n green... | [
"0.7930761",
"0.7340916",
"0.6859213",
"0.6619156",
"0.6548862",
"0.6361467",
"0.62869173",
"0.61980194",
"0.6166142",
"0.60413206",
"0.60389495",
"0.5965779",
"0.5909593",
"0.58895975",
"0.5883732",
"0.586125",
"0.5825624",
"0.58123803",
"0.5805797",
"0.58012986",
"0.5790884... | 0.7823721 | 3 |
Generate test image with random pixels and save as an image file. | def test_image(filename, x_size=350, y_size=350):
# Create image and loop over all pixels
im = Image.new("RGB", (x_size, y_size))
pixels = im.load()
for i in range(x_size):
for j in range(y_size):
x = remap_interval(i, 0, x_size, -1, 1)
y = remap_interval(j, 0, y_size, -1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_image(filename, x_size=350, y_size=350):\n # Create image and loop over all pixels\n im = Image.new(\"RGB\", (x_size, y_size))\n pixels = im.load()\n for i in range(x_size):\n for j in range(y_size):\n pixels[i, j] = (random.randint(0, 255), # Red channel\n ... | [
"0.7916328",
"0.73138684",
"0.7276964",
"0.72279763",
"0.6833925",
"0.67390573",
"0.6636539",
"0.6577365",
"0.6552666",
"0.654833",
"0.6493901",
"0.64547956",
"0.6446572",
"0.6445794",
"0.6444757",
"0.6440958",
"0.6415097",
"0.6344109",
"0.63346565",
"0.6326465",
"0.6290015",... | 0.7180069 | 6 |
Generate computational art and save as an image file. | def generate_art(filename, x_size=1920, y_size=1080):
# Functions for red, green, and blue channels - where the magic happens!
red_function = build_random_function(7,8)
green_function = build_random_function(4,6)
blue_function = build_random_function(3,5)
# Create image and loop over all pixels
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_art(filename, x_size=350, y_size=350):\n # Functions for red, green, and blue channels - where the magic happens!\n r_lb = random.randint(6, 10)\n g_lb = random.randint(6, 10)\n b_lb = random.randint(6, 10)\n red_function = build_random_function(r_lb, r_lb+1)\n green_function = build... | [
"0.71219194",
"0.69798446",
"0.68660295",
"0.6794313",
"0.6750983",
"0.66667235",
"0.6619679",
"0.64958155",
"0.6475446",
"0.6467824",
"0.6457414",
"0.6439815",
"0.6421548",
"0.64128166",
"0.64050144",
"0.6403127",
"0.63413537",
"0.6339301",
"0.63320214",
"0.63320214",
"0.633... | 0.6785918 | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.