CONFIDENCE:\n print(img_names[ite])\n # print(outputs)\n N += 1\n #dessiner carre sur image\n slh = int(img_names[ite].split('_')[4])\n slw = int(img_names[ite].split('_')[5][:-4])\n x1 = int(slh * slice_size / step)\n x2 = x1 + slice_size\n y1 = int(slw * slice_size / step)\n y2 = y1 + slice_size\n\n if slh == 16 and slw == 27 and width ==450 :\n print (x1, y1, x2, y2)\n\n print(r)\n rh = orh / height\n rw = orw / width\n x1 = x1 * rh\n x2 = x2 * rh\n y1 = y1 * rw\n y2 = y2 * rw\n\n draw.rectangle(((y1, x1), (y2, x2)), outline=\"red\")\n # draw.text((y2,x2), img_names[0])\n copyfile(\"./testsliceimage/\"+img_names[ite], \"./goodimage/\"+ img_names[ite])\n\n if width <= 200 or height <= 200:\n flag_continue = False\n else:\n r = r * scale\n width, height = int(width/scale), int(height/scale)\n slicesh = int(math.ceil(height/slice_size))\n slicesw = int(math.ceil(width/slice_size))\n img = img.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\n width, height = img.size\n\n # imgout = imgout.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\n imgout.save(\"./rectangle/out\", \"PNG\")","def load_images_from_folder(folder, n_cases,patch_size, mask_path, mask_type, mask_name,normalize=False, imrotate=False):\n\n# # Initialize the arrays:\n# if imrotate: # number of images is 4 * n_im\n# bigy = np.empty((n_im * 4, 64, 64))\n# bigx = np.empty((n_im * 4, 64, 64, 2))\n# else:\n# bigy = np.empty((n_im, 64, 64))\n# bigx = np.empty((n_im, 64, 64, 2))\n\n# im = 0 # image counter\n bigy = []\n filenames = os.listdir(folder)\n\n for filename in filenames[n_cases[0]:n_cases[1]]:\n if not filename.startswith('.'):\n temp = loadmat(os.path.join(folder, filename))['res']\n print temp.shape\n # Clean the STONE sense recon data\n row, col = temp.shape\n temp = np.reshape(temp, (row, col, -1))\n #valid_mask = (np.abs(np.squeeze(temp[int(row/2), int(col/2), :])) != 0)\n #final_images = temp[:,:,valid_mask]\n final_images = temp\n \n# # Resize images\n #final_images = np.abs(final_images)\n final_images_resized = np.zeros((patch_size,patch_size,final_images.shape[2]))\n for i in range(final_images.shape[2]):\n final_images_resized[:,:,i] = cv2.resize(final_images[:,:,i], (patch_size,patch_size))\n \n# # Only take a small part of the data\n# final_images = final_images[140:180,140:180,:]\n \n# # Convert to abs values\n# final_images = np.abs(final_images)\n# \n# # Normalize based on single patient case\n# final_images = (final_images - np.mean(final_images)) / np.std(final_images)\n \n# bigy_temp = cv2.imread(os.path.join(folder, filename),\n# cv2.IMREAD_GRAYSCALE)\n \n \n bigy.append(final_images_resized)\n \n bigy = np.asarray(bigy)\n cases, row, col, imgs = bigy.shape\n bigy = np.transpose(np.reshape(np.transpose(bigy, (1,2,3,0)), (row, col, -1)), (2,0,1))\n \n # convert to k-space\n imgs, row, col = bigy.shape\n bigx = np.empty((imgs, row, col, 2))\n mask = read_mask(mask_path=mask_path,mask_type=mask_type,mask_name=mask_name,patch_size=patch_size,show_image=False)\n for i in range(imgs):\n bigx[i, :, :, :] = create_x(np.squeeze(bigy[i,:,:]),mask)\n \n # convert bigx from complex to abs values\n bigy = np.abs(bigy)\n \n# im += 1\n# if imrotate:\n# for angle in [90, 180, 270]:\n# bigy_rot = im_rotate(bigy_temp, angle)\n# bigx_rot = create_x(bigy_rot, normalize)\n# bigy[im, :, :] = bigy_rot\n# bigx[im, :, :, :] = bigx_rot\n# im += 1\n\n# if imrotate:\n# if im > (n_im * 4 - 1): # how many images to load\n# break\n# else:\n# if im > (n_im - 1): # how many images to load\n# break\n\n# if normalize:\n# bigx = (bigx - np.amin(bigx)) / (np.amax(bigx) - np.amin(bigx))\n\n return bigx, bigy","def crop_images_same_dir(data_set_dir):\n data = glob(os.path.join(data_set_dir, \"*.png\"))\n\n # data_length = len(data)\n # high < 256 because want to cut the bottom\n # offs_h = np.random.randint(low=0, high=200, size=data_length)\n # offs_h_end = offs_h + 256\n # offs_w = np.random.randint(low=0, high=512, size=data_length)\n # offs_w_end = offs_w + 512\n # print offs_h, offs_h_end\n\n for index, filePath in enumerate(data):\n print ('%d/%d' % (index, len(data)))\n\n img = scipy.misc.imread(filePath).astype(np.float)\n #img = scipy.misc.imresize(img, 0.25, interp='bilinear', mode=None)\n #scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/CITYSCAPES_crop_random/' + filePath.split('/')[-1],\n # img[offs_h[index]:offs_h_end[index], offs_w[index]:offs_w_end[index] :])\n scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/CITYSCAPES_crop_bottom_192/' + filePath.split('/')[-1],\n img[0:192, :, :])\n #break","def single_channel_stacking(tifs):\n template_ID=int(len(tifs)/2)\n \n template_raster=gdal_array.LoadFile(tifs[template_ID-1])\n avg_raster=np.zeros_like(template_raster)\n avg_raster=avg_raster+1\n new_raster=np.copy(template_raster)\n # ones=np.full(template_raster.shape, 1)\n for i, tif in enumerate(tifs, start=1):\n if i==template_ID: \n continue\n \n tif_raster=gdal_array.LoadFile(tif)\n # tif_raster=cut_transformed_array_borders(tif_raster)\n result=ird.similarity(template_raster,tif_raster , numiter=1, order=1)\n img_transformed= ird.transform_img(tif_raster, scale=result['scale'], angle=result['angle'], tvec=result['tvec'], mode='constant', bgval=0, order=2)\n \n img_transformed=cut_transformed_array_borders(img_transformed)\n \n # ones_transformed=ird.transform_img(ones, scale=result['scale'], angle=result['angle'], tvec=result['tvec'], mode='constant', bgval=0, order=1)\n ones_transformed=np.zeros_like(template_raster)\n ones_transformed[np.where(img_transformed>0)]=1\n print(ones_transformed)\n \n print(np.mean(ones_transformed), np.max(ones_transformed), np.min(ones_transformed))\n print(ones_transformed[np.where(ones_transformed>0)])\n print(np.min(ones_transformed[np.where(ones_transformed>0)]))\n print(np.max(ones_transformed[np.where(ones_transformed>0)]))\n\n plt.imshow(ones_transformed)\n plt.show()\n plt.close()\n \n # ones_transformed=cut_transformed_array_borders(ones_transformed)\n \n avg_raster=avg_raster+ones_transformed\n # ird.imshow(template_raster, tif_raster, img_transformed)\n \n new_raster=new_raster+img_transformed\n \n # new_raster=new_raster+template_raster \n # new_raster=new_raster/len(tifs)\n\n gtz=np.where(avg_raster>0)\n \n\n \n\n \n \n plt.imshow(new_raster)\n plt.show()\n plt.close()\n # gdal_array.SaveArray(new_raster, tifs[0][:-4]+\"_not_abvertaghe_stacked_.tiff\")\n new_raster[gtz]=new_raster[gtz]/avg_raster[gtz] \n gdal_array.SaveArray(new_raster, tifs[0][:-4]+\"_stacked_.tiff\")\n plt.imshow(new_raster)\n plt.savefig(\"test.tif\", dpi=800)\n plt.show()\n plt.close()\n\n def discrete_cmap(N, base_cmap=None):\n \"\"\"Create an N-bin discrete colormap from the specified input map\"\"\"\n \n # Note that if base_cmap is a string or None, you can simply do\n # return plt.cm.get_cmap(base_cmap, N)\n # The following works for string, None, or a colormap instance:\n \n base = plt.cm.get_cmap(base_cmap)\n color_list = base(np.linspace(0, 1, N))\n cmap_name = base.name + str(N)\n return base.from_list(cmap_name, color_list, N)\n\n cmap=discrete_cmap(int(avg_raster.max())+1, base_cmap=\"ocean\") \n \n norm=mpl.colors.BoundaryNorm(np.arange(-0.5,int(avg_raster.max()+1)), cmap.N)\n fig=plt.figure()\n fig.set_size_inches(5,4)\n ax=fig.add_subplot(111)\n data=ax.matshow(avg_raster, cmap=cmap, norm=norm)\n fig.colorbar(data, ticks=np.linspace(0,int(avg_raster.max()),int(avg_raster.max()+1)), drawedges=True)\n\n plt.show()\n plt.close()\n\n\n # gdal_array.SaveArray(new_raster, tifs[0][:-4]+\"_stacked_.tiff\")","def three_sample_images():\n samples = samples_path()\n _truck = np.array(Image.open(os.path.join(samples, \"truck.png\")))\n _deer = np.array(Image.open(os.path.join(samples, \"deer.png\")))\n _frog = np.array(Image.open(os.path.join(samples, \"frog.png\")))\n truck = transforms.ToTensor()(_truck)\n deer = transforms.ToTensor()(_deer)\n frog = transforms.ToTensor()(_frog)\n return torch.stack([truck, deer, frog])","def quadriview_old(nifti_image, slice_sag, slice_orth,\n slice_cor_1, slice_cor_2):\n view_1 = nifti_image[slice_sag, :, :]\n view_2 = nifti_image[:, slice_orth, :]\n view_3 = nifti_image[:, :, slice_cor_1]\n view_4 = nifti_image[:, :, slice_cor_2]\n\n pad_lign = max(view_1.shape[0] + view_2.shape[0], view_3.shape[0] + view_4.shape[0])\n pad_col = max(view_1.shape[1] + view_3.shape[1], view_2.shape[1] + view_4.shape[1])\n pad = np.zeros((pad_lign, pad_col), dtype=np.float64)\n\n pad[:view_1.shape[0], :view_1.shape[1]] = view_1\n pad[-view_2.shape[0]:, :view_2.shape[1]] = view_2\n pad[:view_3.shape[0], -view_3.shape[1]:] = view_3\n pad[-view_4.shape[0]:, -view_4.shape[1]:] = view_4\n\n return pad","def assemble_image_stack(image_stack, index_map):\n # get boundary\n index_max_x = np.max(index_map[:, :, :, 0])\n index_max_y = np.max(index_map[:, :, :, 1])\n # set holder\n image = np.zeros((index_max_x, index_max_y))\n # loop through the panels\n for l in range(index_map.shape[0]):\n image[index_map[l, :, :, :]] = image_stack[l, :, :]\n\n return image","def split_combined_polys(polys, poly_lens, polys_per_mask):\n mask_polys_list = []\n for img_id in range(len(polys)):\n polys_single = polys[img_id]\n polys_lens_single = poly_lens[img_id].tolist()\n polys_per_mask_single = polys_per_mask[img_id].tolist()\n\n split_polys = mmcv.slice_list(polys_single, polys_lens_single)\n mask_polys = mmcv.slice_list(split_polys, polys_per_mask_single)\n mask_polys_list.append(mask_polys)\n return mask_polys_list","def _crop_write_image(self, inroot, images, outroot):\n for image in images:\n inimage_path = osp.join(inroot, image)\n cvimg = cv2.imread(inimage_path)\n cvimg = cvimg[60:-30, 25:-25]\n h, w, _ = cvimg.shape\n assert h == w == 128\n outimage_path = osp.join(outroot, image)\n cv2.imwrite(outimage_path, cvimg)\n print(outimage_path)","def concatenate_datasets(filenames_list, img_rows=128, img_cols=128):\n print('Concatenating the datasets created by data augmentation into a single one')\n print('Using the following pairs of images / masks datasets: ')\n print(filenames_list)\n print('\\n')\n\n # total number of images\n n_samples = 600 * len(filenames_list)\n\n # create np.ndarrays for the images and the targets: xCenter, yCenter, xOrientation, yOrientation\n images_dataset = np.ndarray((n_samples, img_rows, img_cols), dtype=np.uint8)\n targets_dataset = np.ndarray((n_samples, 4), dtype=np.float32)\n\n for ds, (img, mask) in enumerate(filenames_list):\n print(\" Processing {}\".format(img))\n images = np.load(\"output/augmented_data/{}.npy\".format(img))\n masks = np.load(\"output/augmented_data/{}.npy\".format(mask))\n\n for idx, mat in enumerate(masks):\n\n # get the center coordinates of the left ventricle (on the resized image)\n row, col = findCenter(img=mat, pixelvalue=1)\n\n # get the orientation of the left ventricle (on the resized image)\n x_v1, y_v1 = findMainOrientation(img=mat, pixelvalue=1)\n\n # save the center coordinates & orientation to the y dataframe (which will be the output of the network)\n targets_dataset[ds*600 + idx] = np.array([row, col, x_v1, y_v1])\n\n # save image in main dataset file\n images_dataset[ds*600 + idx] = images[idx]\n\n print('Concatenated all datasets into one & created target values for (center, orientation)')\n\n print('Splitting the dataset into 70% training & 30% testing')\n images_train, images_test, targets_train, targets_test = train_test_split(images_dataset, targets_dataset,\n test_size=0.3,\n random_state=42,\n shuffle=True)\n\n # save all ndarrays to a .npy files (for faster loading later)\n # Create directory to store files.\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # save training set to file\n np.save('output/processed_data/images_train.npy', images_train)\n np.save('output/processed_data/targets_train.npy', targets_train)\n\n # save testing set to file\n np.save('output/processed_data/images_test.npy', images_test)\n np.save('output/processed_data/targets_test.npy', targets_test)\n print('Saving to .npy files done. See files: ')\n print('output/processed_data/images_train.npy')\n print('output/processed_data/targets_train.npy')\n print('output/processed_data/images_test.npy')\n print('output/processed_data/targets_test.npy')","def pre_process_data(input_path: list, cuts: int, shape: int = 32, normalize: bool = True) -> list:\n images = []\n images_uncut = []\n for files_path in input_path:\n\n files = os.listdir(files_path) # TODO paths\n for f in files:\n file_path = f'{files_path}/{f}'\n im_uncut = cv2.imread(file_path)\n im_uncut = cv2.cvtColor(im_uncut, cv2.COLOR_RGB2GRAY)\n images_uncut.append(cv2.resize(im_uncut, (shape * cuts, shape * cuts)))\n x = np.array(images_uncut)\n\n if normalize:\n x_mean = np.mean(x, axis=(0, 1, 2))\n x_std = np.std(x, axis=(0, 1, 2))\n x = (x - x_mean) / (x_std + 1e-9)\n\n for im in x:\n height = im.shape[0]\n width = im.shape[1]\n frac_h = height // cuts\n frac_w = width // cuts\n i = 0\n image = []\n for h in range(cuts):\n for w in range(cuts):\n crop = im[h * frac_h:(h + 1) * frac_h, w * frac_w:(w + 1) * frac_w]\n crop_rehaped = cv2.resize(crop, (shape, shape))\n image.append([crop_rehaped, i, number_to_angle(i, cuts), neighbours(i, cuts)])\n i = i + 1\n images.append(image)\n # return np.array(images) # todo back to array\n return images","def __augmented_images(self, info, start):\n count = start\n final_img_to_save = []\n for pair in info:\n processedImage = self.__processImage(os.path.join(WORKING_DIR, pair[0]))\n if processedImage == None:\n continue\n # translation is not that important since CNNs are resistant to image translations\n rotatedImages = self.__applyRotations(processedImage)\n\n rotCount = 1\n for img in rotatedImages:\n filename = str(count) + \"_\" + str(rotCount) + \".jpg\"\n # img.save(os.path.join(directory, filename))\n final_img_to_save.append((img, pair[1], filename))\n rotCount += 1\n\n print(\"Augmenting image: {:05}\".format(count))\n count += 1\n return final_img_to_save","def beam_slices(map_file, fee_map, nside):\n\n t_name, r_name, _, _ = Path(map_file).stem.split(\"_\")\n\n pointings = [\"0\", \"2\", \"4\"]\n\n maps = []\n\n # load data from map .npz file\n tile_map = np.load(map_file, allow_pickle=True)\n fee_m = np.load(fee_map, allow_pickle=True)\n\n for p in pointings:\n\n tile = tile_map[p]\n\n if \"XX\" in t_name:\n fee = fee_m[p][0]\n else:\n fee = fee_m[p][1]\n\n # rotate maps so slices can be taken\n fee_r = rotate_map(nside, angle=-np.pi / 4, healpix_array=fee)\n tile_r = rotate_map(nside, angle=-np.pi / 4, healpix_array=tile)\n\n # fee_r[PB_0] = np.nan\n # tile_r[PB_0] = np.nan\n\n # slice the tile and fee maps along NS, EW\n # zenith angle thresh of 70 to determine fit gain factor\n NS_f, EW_f = healpix_cardinal_slices(nside, fee_r, 70)\n NS_t, EW_t = map_slices(nside, tile_r, 70)\n\n gain_NS = chisq_fit_gain(data=NS_t[0], model=NS_f[0])\n gain_EW = chisq_fit_gain(data=EW_t[0], model=EW_f[0])\n\n # slice the tile and fee maps along NS, EW.\n # the above gain factor is applied to full beam slices\n NS_fee, EW_fee = healpix_cardinal_slices(nside, fee_r, 85)\n NS_tile, EW_tile = map_slices(nside, tile_r, 85)\n\n # Scale the data so that it best fits the beam slice\n NS_tile_med = NS_tile[0] - gain_NS[0]\n EW_tile_med = EW_tile[0] - gain_EW[0]\n\n # delta powers\n del_NS = NS_tile_med - NS_fee[0]\n del_EW = EW_tile_med - EW_fee[0]\n\n # 3rd order poly fits for residuals\n fit_NS = poly_fit(NS_tile[2], del_NS, NS_tile[0], 3)\n fit_EW = poly_fit(EW_tile[2], del_EW, EW_tile[0], 3)\n\n maps.append(\n [\n [NS_tile, NS_fee, NS_tile_med, del_NS, fit_NS],\n [EW_tile, EW_fee, EW_tile_med, del_EW, fit_EW],\n ]\n )\n\n return maps","def _augment_images(self, images, random_state, parents, hooks):\n nb_images = len(images)\n samples = self.p.draw_samples((nb_images,), random_state=random_state)\n for i in sm.xrange(nb_images):\n if samples[i] == 1:\n if self.axis == 1:\n images[i] = np.fliplr(images[i])\n elif self.axis == 0:\n images[i] = np.flipud(images[i])\n self.samples = samples\n return images","def crops(fields, anchor, crop, pad, size):\n ndim = len(size)\n assert all(len(x) == ndim for x in [anchor, crop, pad, size]), 'inconsistent ndim'\n new_fields = []\n for x in fields: #loop over channel dim\n ind = []\n for d, (a, c, (p0, p1), s) in enumerate(zip(anchor, crop, pad, size)):\n i = np.arange(a - p0, a + c + p1)\n i %= s\n i = i.reshape((-1,) + (1,) * (ndim - d - 1))\n ind.append(i)\n \n x = x[tuple(ind)]\n\n new_fields.append(x)\n return np.array(new_fields)","def prepare_voxel_slice(self,slices,llc,urc,direction):\n\t\tsize=urc-llc\n\t\tres = float(size[direction] / slices)\n\t\tdims=numpy.ceil(size/res)\n\t\treturn numpy.zeros((dims[(direction+1) % 3],dims[(direction+2) % 3]),dtype='bool'), res","def align_images(self, translation_only=False):\n # Extract feature point locations and descriptors.\n points_and_descriptors = []\n for file in self.files:\n image = sol4_utils.read_image(file, 1)\n self.images.append(image)\n self.h, self.w = image.shape\n pyramid, _ = sol4_utils.build_gaussian_pyramid(image, 3, PYR_FLT_LEVEL)\n points_and_descriptors.append(find_features(pyramid))\n\n # Compute homographies between successive pairs of images.\n Hs = []\n for i in range(len(points_and_descriptors) - 1):\n points1, points2 = points_and_descriptors[i][0], points_and_descriptors[i + 1][0]\n desc1, desc2 = points_and_descriptors[i][1], points_and_descriptors[i + 1][1]\n\n # Find matching feature points.\n ind1, ind2 = match_features(desc1, desc2, MATCH_MIN_SCORE)\n points1, points2 = points1[ind1, :], points2[ind2, :]\n\n # Compute homography using RANSAC.\n H12, inliers = ransac_homography(points1, points2,\n RANSAC_ITER_NUM, RANAC_ERR_TOL,\n translation_only)\n\n # Uncomment for debugging: display inliers and outliers among matching points.\n # In the submitted code this function should be commented out!\n if(self.display_match):\n display_matches(self.images[i], self.images[i+1], points1 , points2, inliers)\n\n Hs.append(H12)\n\n # Compute composite homographies from the central coordinate system.\n accumulated_homographies = accumulate_homographies(Hs, (len(Hs) - 1) // 2)\n self.homographies = np.stack(accumulated_homographies)\n self.frames_for_panoramas = filter_homographies_with_translation(self.homographies, minimum_right_translation=5)\n print((self.frames_for_panoramas.shape))\n self.homographies = self.homographies[self.frames_for_panoramas]","def concat_images_vert(imga, imgb):\n ha,wa = imga.shape[:2]\n hb,wb = imgb.shape[:2]\n max_width = np.max([wa, wb])\n total_height = ha+hb\n new_img = np.zeros(shape=(total_height, max_width, 3), dtype=np.uint8)\n new_img[:ha,:wa]=imga\n #new_img[:hb,wa:wa+wb]=imgb\n new_img[ha:ha+hb,:wb]=imgb\n return new_img","def _compute_ij_images_for_source_line(\n src_j0: int,\n src_x_image: np.ndarray,\n src_y_image: np.ndarray,\n src_i_min: int,\n src_j_min: int,\n dst_src_ij_images: np.ndarray,\n dst_x_offset: float,\n dst_y_offset: float,\n dst_x_scale: float,\n dst_y_scale: float,\n uv_delta: float\n):\n src_width = src_x_image.shape[-1]\n\n dst_width = dst_src_ij_images.shape[-1]\n dst_height = dst_src_ij_images.shape[-2]\n\n dst_px = np.zeros(4, dtype=src_x_image.dtype)\n dst_py = np.zeros(4, dtype=src_y_image.dtype)\n\n u_min = v_min = -uv_delta\n uv_max = 1.0 + 2 * uv_delta\n\n for src_i0 in range(src_width - 1):\n src_i1 = src_i0 + 1\n src_j1 = src_j0 + 1\n\n dst_px[0] = dst_p0x = src_x_image[src_j0, src_i0]\n dst_px[1] = dst_p1x = src_x_image[src_j0, src_i1]\n dst_px[2] = dst_p2x = src_x_image[src_j1, src_i0]\n dst_px[3] = dst_p3x = src_x_image[src_j1, src_i1]\n\n dst_py[0] = dst_p0y = src_y_image[src_j0, src_i0]\n dst_py[1] = dst_p1y = src_y_image[src_j0, src_i1]\n dst_py[2] = dst_p2y = src_y_image[src_j1, src_i0]\n dst_py[3] = dst_p3y = src_y_image[src_j1, src_i1]\n\n dst_pi = np.floor((dst_px - dst_x_offset)\n / dst_x_scale).astype(np.int64)\n dst_pj = np.floor((dst_py - dst_y_offset)\n / dst_y_scale).astype(np.int64)\n\n dst_i_min = np.min(dst_pi)\n dst_i_max = np.max(dst_pi)\n dst_j_min = np.min(dst_pj)\n dst_j_max = np.max(dst_pj)\n\n if dst_i_max < 0 \\\n or dst_j_max < 0 \\\n or dst_i_min >= dst_width \\\n or dst_j_min >= dst_height:\n continue\n\n if dst_i_min < 0:\n dst_i_min = 0\n\n if dst_i_max >= dst_width:\n dst_i_max = dst_width - 1\n\n if dst_j_min < 0:\n dst_j_min = 0\n\n if dst_j_max >= dst_height:\n dst_j_max = dst_height - 1\n\n # u from p0 right to p1, v from p0 down to p2\n det_a = _fdet(dst_p0x, dst_p0y, dst_p1x, dst_p1y, dst_p2x, dst_p2y)\n # u from p3 left to p2, v from p3 up to p1\n det_b = _fdet(dst_p3x, dst_p3y, dst_p2x, dst_p2y, dst_p1x, dst_p1y)\n\n if np.isnan(det_a) or np.isnan(det_b):\n # print('no plane at:', src_i0, src_j0)\n continue\n\n for dst_j in range(dst_j_min, dst_j_max + 1):\n dst_y = dst_y_offset + (dst_j + 0.5) * dst_y_scale\n for dst_i in range(dst_i_min, dst_i_max + 1):\n dst_x = dst_x_offset + (dst_i + 0.5) * dst_x_scale\n\n # TODO: use two other combinations,\n # if one of the dst_px<n>,dst_py<n> pairs is missing.\n\n src_i = src_j = -1\n\n if det_a != 0.0:\n u = _fu(dst_x, dst_y,\n dst_p0x, dst_p0y, dst_p2x, dst_p2y) / det_a\n v = _fv(dst_x, dst_y,\n dst_p0x, dst_p0y, dst_p1x, dst_p1y) / det_a\n if u >= u_min and v >= v_min and u + v <= uv_max:\n src_i = src_i0 + _fclamp(u, 0.0, 1.0)\n src_j = src_j0 + _fclamp(v, 0.0, 1.0)\n if src_i == -1 and det_b != 0.0:\n u = _fu(dst_x, dst_y,\n dst_p3x, dst_p3y, dst_p1x, dst_p1y) / det_b\n v = _fv(dst_x, dst_y,\n dst_p3x, dst_p3y, dst_p2x, dst_p2y) / det_b\n if u >= u_min and v >= v_min and u + v <= uv_max:\n src_i = src_i1 - _fclamp(u, 0.0, 1.0)\n src_j = src_j1 - _fclamp(v, 0.0, 1.0)\n if src_i != -1:\n dst_src_ij_images[0, dst_j, dst_i] = src_i_min + src_i\n dst_src_ij_images[1, dst_j, dst_i] = src_j_min + src_j","def extract(self, files):\n for i in range(len(files)):\n print(files[i])\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\n\n \"\"\"\n Find the indices of array elements that are non-zero, i.e,\n find the pixels' positions that represents the respiratory\n functions (pixels in the respiratory function are brighter).\n \"\"\"\n color_pts = np.argwhere(img > 70)\n\n \"\"\"\n Sorts the pixels according to their x coordenate.\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\n the parameter of itemgetter is 1 (to get x coordinate)\n \"\"\"\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\n\n \"\"\"\n If there is no pixel representing the respiratory function\n (i.e., lighter pixel) it creates an empty image (without any\n respiratory function)\n \"\"\"\n if len(lcolor_pts) == 0:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open(\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], []))\n # file.close()\n\n continue\n\n # Reverse the coordinates and store the result in lordered_pts list\n lordered_pts = []\n for j in range(len(lcolor_pts)):\n lordered_pts.append(lcolor_pts[j][::-1])\n\n \"\"\"\n Convert pixels coordinates into a tuples and check which column\n has pixels that corresponding to diaphragmatic level\n Obs. There are some columns that doesnt have any pixel that\n correpond to diaphragmatic level.\n \"\"\"\n # Columns that have a pixel corresponding diaphragmatic level\n lcolumn_available = []\n for j in range(len(lordered_pts)):\n lordered_pts[j] = tuple(lordered_pts[j])\n lcolumn_available.append(lordered_pts[j][0])\n lcolumn_available = list(set(lcolumn_available))\n # print(\"Ordered points: \", lordered_pts)\n # print(\"Columns available: \", lcolumn_available)\n\n \"\"\"\n If there is not enough columns to build a respiratory pattern,\n create a blank image\n \"\"\"\n if len(lcolumn_available) < 20:\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n continue\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n first column, assign to it the value of the second y coordinate\n \"\"\"\n if lcolumn_available[0] is not 0:\n y = max(\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\n key=itemgetter(1))[1]\n lordered_pts.insert(0, (0, y))\n lcolumn_available.insert(0, 0)\n\n \"\"\"\n If there are no pixel that corresponding diaphragmatic level in the\n last column, assign to it the value of the penultimate y coordinate\n available\n \"\"\"\n if lcolumn_available[-1] is not 49:\n lordered_pts.append(\n (49, lordered_pts[len(lcolumn_available)][1]))\n lcolumn_available.append(49)\n\n \"\"\"\n Get the biggest y value in each column that represents the\n diaphragmatic level\n \"\"\"\n column = 0\n lcolumn = []\n ldiaphragm_pts = []\n for j in range(50):\n # Get the column's points\n lcolumn = [x for x in lordered_pts if x[0] == column]\n # print('{}: {}'.format(j, lcolumn))\n\n if len(lcolumn) > 0:\n ldiaphragm_pts.append(\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\n else:\n # Get the y value from the previous column\n lcolumn_available.insert(column, column)\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\n column += 1\n lcolumn = []\n\n # Draw diaphragmatic level\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\n j = 0\n while(j < len(lcolumn_available) - 1):\n cv2.line(\n diaphragmatic_lvl,\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\n (0, 0, 255), 1)\n j = j + 1\n\n lcolumn_available = []\n\n print(\"Diaphragmatic's points: \", ldiaphragm_pts)\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n cv2.imwrite('{}/{}/{}/{}'.format(\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\n\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\n # file.write(\"{}:{}\\n\".format(files[i], ldiaphragm_pts))\n # file.close()\n\n # return ldiaphragm_pts","def data_augmenter(image, label, shift, rotate, scale, intensity, flip):\n image2 = np.zeros(image.shape, dtype=np.float32)\n label2 = np.zeros(label.shape, dtype=np.int32)\n for i in range(image.shape[0]):\n # For each image slice, generate random affine transformation parameters\n # using the Gaussian distribution\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\n np.clip(np.random.normal(), -3, 3) * shift]\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\n\n # Apply the affine transformation (rotation + scale + shift) to the image\n row, col = image.shape[1:3]\n M = cv2.getRotationMatrix2D((row / 2, col / 2), rotate_val, 1.0 / scale_val)\n M[:, 2] += shift_val\n for c in range(image.shape[3]):\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(image[i, :, :, c],\n M[:, :2], M[:, 2], order=1)\n\n # Apply the affine transformation (rotation + scale + shift) to the label map\n label2[i, :, :] = ndimage.interpolation.affine_transform(label[i, :, :],\n M[:, :2], M[:, 2], order=0)\n\n # Apply intensity variation\n image2[i] *= intensity_val\n\n # Apply random horizontal or vertical flipping\n if flip:\n if np.random.uniform() >= 0.5:\n image2[i] = image2[i, ::-1, :, :]\n label2[i] = label2[i, ::-1, :]\n else:\n image2[i] = image2[i, :, ::-1, :]\n label2[i] = label2[i, :, ::-1]\n return image2, label2","def show_slices(slices, colour_map):\n fig, axes = plt.subplots(1, len(slices))\n for i, slice in enumerate(slices):\n axes[i].imshow(slice.T, cmap=colour_map, origin=\"lower\")\n plt.show()","def load_images(input_dir=\"/tmp/mapswipe/project-1\", n_images=2000, seed=1):\n class_map = {1: \"1\", 0: \"5\"}\n output_dir = \"/Users/thead/git/dreamview/data/\"\n\n X_ = []\n y_ = []\n for new_klass in class_map:\n images = []\n for klass in class_map[new_klass]:\n for img in glob.glob(input_dir + \"/%s/*/*/*/aerial.jpeg\" % klass):\n if os.stat(img).st_size > 0:\n images.append(img)\n\n images = shuffle(images, random_state=seed+42+new_klass)\n images = images[:n_images]\n X_ += images\n y_ += [new_klass] * len(images)\n\n # XXX deduce array size from an actual image\n X = np.zeros((2*n_images, 256*256), dtype=np.ubyte)\n y = np.zeros(2*n_images, dtype=np.int)\n\n for n, (img_path, klass) in enumerate(zip(X_, y_)):\n # the order of these OPs has been chosen on purpose, don't mess\n # without checking what happens\n img = imread(img_path)\n img = equalize_adapthist(img)\n img = rgb2grey(img)\n img = img_as_ubyte(img)\n\n if not n % 10:\n fname = os.path.split(img_path)[:-1]\n fname = os.path.join(*fname, \"aerial-processed.jpeg\")\n imsave(fname, img)\n\n X[n,:] = img.ravel()\n y[n] = klass\n\n return X, y","def long_slice(image_data):\n\n\t# Process binary data and open.\n\tim = image_data.split('base64,')[1]\n\tim = base64.b64decode(im)\n\tim = io.BytesIO(im)\n\t\n\timg = Image.open(im)\n\twidth, height = img.size\n\tupper = 0\n\tleft = 0\n\t\n\t# Max height to fit pdf.\n\tmax_height_mm = 198\n\tmax_height = (max_height_mm * 96) / 25.4\n\n\tslice_size = max_height\n\n\tslices = int(math.ceil(height/slice_size))\n\tcount = 1\n\n\tfinal_slices = []\n\tfor slice in range(slices):\n\t\t# If no more slices needed, set the lower bound to bottom of image.\n\t\tif count == slices:\n\t\t\tlower = height\n\t\telse:\n\t\t\tlower = int(count * slice_size) \n\t\t \n\t\t# Set the bounding box. \n\t\tbbox = (left, upper, width, lower)\n\t\tworking_slice = img.crop(bbox)\n\n\t\t# Save png as bytes object.\n\t\tbyte_io = io.BytesIO()\n\t\tworking_slice.save(byte_io, 'png')\n\t\t\n\t\t# Convert bytes object to base64 string and save to list.\n\t\timg_str = base64.b64encode(byte_io.getvalue())\n\t\timg_str = 'data:image/png;base64,' + img_str.decode()\n\t\tfinal_slices.append(img_str)\n\n\t\tupper = upper + slice_size\n\t\tcount = count + 1\n\n\treturn final_slices","def crop_acc_mask(images_dir, images_output_dir, masks_dir, mask_suffix=None, masks_output_dir=None): \n image_suffix_list = [\"C0\", \"DE\", \"T2\"]\n if not os.path.exists(images_output_dir):\n os.makedirs(images_output_dir)\n if masks_output_dir is not None and (not os.path.exists(masks_output_dir)):\n os.makedirs(masks_output_dir)\n margin = [0, 30, 30]\n masks_list = os.listdir(masks_dir)\n masks_list.sort()\n json_dict = OrderedDict()\n for mask in masks_list:\n mask_path = os.path.join(masks_dir, mask)\n if mask.endswith(\".nii.gz\"):\n print(\"#\" * 11 *11)\n print(mask_path)\n mask_sitk = sitk.ReadImage(mask_path)\n mask_npy = sitk.GetArrayFromImage(mask_sitk)\n mask_shape = mask_npy.shape\n crop_bbox_min, crop_bbox_max = get_ND_bounding_box(mask_npy, margin=margin)\n # do not crop along depth dimension\n crop_bbox_min[0] = 0\n crop_bbox_max[0] = mask_shape[0]\n print(crop_bbox_min, crop_bbox_max)\n json_dict[mask_path] = {\"crop_bbox_min\": crop_bbox_min, \"crop_bbox_max\": crop_bbox_max}\n mask_output_npy = crop_ND_volume_with_bounding_box(mask_npy, crop_bbox_min, crop_bbox_max)\n if mask_suffix is not None:\n mask = mask.replace(\"_\" + mask_suffix + \".nii.gz\", \".nii.gz\")\n if masks_output_dir is not None:\n save_cropped_array_as_nifty_volume(mask_output_npy, os.path.join(masks_output_dir, mask), mask_sitk)\n save_cropped_array_as_nifty_volume(convert_label(mask_output_npy, [1, 2, 3, 4, 5], [1, 2, 3, 1, 1]), \\\n os.path.join(images_output_dir, mask.replace(\".nii.gz\", \"_{0:04d}.nii.gz\".format(len( \\\n image_suffix_list)))), mask_sitk)\n for i, image_suffix in enumerate(image_suffix_list):\n image = mask.replace(\".nii.gz\", \"_{}.nii.gz\".format(image_suffix))\n image_path = os.path.join(images_dir, image)\n print(image_path)\n image_sitk = sitk.ReadImage(image_path)\n image_npy = sitk.GetArrayFromImage(image_sitk)\n image_output_npy = crop_ND_volume_with_bounding_box(image_npy, crop_bbox_min, crop_bbox_max)\n save_cropped_array_as_nifty_volume(image_output_npy, os.path.join(images_output_dir, mask.replace( \\\n \".nii.gz\", \"_{0:04d}.nii.gz\".format(i))), image_sitk)\n save_json(json_dict, os.path.join(images_output_dir, \"crop_information.json\"))\n if masks_output_dir is not None:\n save_json(json_dict, os.path.join(masks_output_dir, \"crop_information.json\"))","def slice_array():\n img = Image.open(\"flamingo.jpg\")\n image_as_array = np.array(img)\n width, height, depth = image_as_array.shape\n\n red_channel = image_as_array[:, :, 0]\n green_channel = image_as_array[:, :, 1]\n blue_channel = image_as_array[:, :, 2]\n\n top_left_corner = image_as_array[:height // 2, :width // 2, :]\n top_right_corner = image_as_array[:height // 2, width // 2:, :]\n random_middle_pixels = image_as_array[11:29, 101:400, :]","def show_slice(file_path, x, y, z):\n img = nib.load(file_path)\n img = img.get_fdata()\n print(\"The scan has dimensions {}.\".format(img.shape))\n slice_0 = img[x, :, :]\n slice_1 = img[:, y, :]\n slice_2 = img[:, :, z]\n slices = [slice_0, slice_1, slice_2]\n fig, axes = plt.subplots(1, len(slices), figsize=[12, 4])\n for i, sli in enumerate(slices):\n axes[i].imshow(sli.T, cmap=\"gray\", origin=\"lower\")","def plot_pet_image(pet_image, yz_slice_pos, xz_slice_pos, xy_slice_pos, pixel_shape,\n pixel_spacing, mask=None):\n # create axis for plotting\n x = np.arange(0.0, (pixel_shape[0] + 1) * pixel_spacing[0], pixel_spacing[0])\n y = np.arange(0.0, (pixel_shape[1] + 1) * pixel_spacing[1], pixel_spacing[1])\n z = np.arange(0.0, (pixel_shape[2] + 1) * pixel_spacing[2], pixel_spacing[2])\n if mask is not None:\n pet_image = np.ma.masked_array(pet_image, mask)\n # create slices that will be shown\n yz_slice = pet_image[yz_slice_pos, :, :]\n xz_slice = pet_image[:, xz_slice_pos, :]\n xy_slice = pet_image[:, :, xy_slice_pos]\n vmin = min(np.min(yz_slice), np.min(xz_slice), np.min(xy_slice))\n vmax = max(np.max(yz_slice), np.max(xz_slice), np.max(xy_slice))\n yz_slice = np.rot90(yz_slice)\n xz_slice = np.fliplr(np.rot90(xz_slice))\n # normalize values\n vmin = min(np.min(yz_slice), np.min(xz_slice), np.min(xy_slice))\n vmax = max(np.max(yz_slice), np.max(xz_slice), np.max(xy_slice))\n cmap = plt.cm.gray\n cmap.set_bad('r', 1)\n # show images\n plt.figure(0)\n plt.clf()\n plt.subplot(221)\n plt.pcolormesh(y, z, yz_slice, vmin=vmin, vmax=vmax, cmap=cmap)\n plt.ylabel('z')\n plt.subplot(222)\n plt.pcolormesh(x, z, xz_slice, vmin=vmin, vmax=vmax, cmap=cmap)\n plt.xlabel('x')\n plt.subplot(223)\n plt.pcolormesh(x, y, xy_slice, vmin=vmin, vmax=vmax, cmap=cmap)\n plt.xlabel('y')\n plt.ylabel('x')\n plt.subplot(224)\n plt.axis([0, 5, 0, 4.5])\n plt.axis('off')\n plt.text(1, 3, \"x: {:.4f}\".format(yz_slice_pos * pixel_spacing[0]), fontsize=15)\n plt.text(1, 2, \"y: {:.4f}\".format(xz_slice_pos * pixel_spacing[1]), fontsize=15)\n plt.text(1, 1, \"z: {:.4f}\".format(xy_slice_pos * pixel_spacing[2]), fontsize=15)\n return vmin, vmax"],"string":"[\n \"def generate_panoramic_images(self, number_of_panoramas):\\n assert self.homographies is not None\\n\\n # compute bounding boxes of all warped input images in the coordinate system of the middle image (as given by the homographies)\\n self.bounding_boxes = np.zeros((self.frames_for_panoramas.size, 2, 2))\\n for i in range(self.frames_for_panoramas.size):\\n self.bounding_boxes[i] = compute_bounding_box(self.homographies[i], self.w, self.h)\\n\\n # change our reference coordinate system to the panoramas\\n # all panoramas share the same coordinate system\\n global_offset = np.min(self.bounding_boxes, axis=(0, 1))\\n self.bounding_boxes -= global_offset\\n\\n slice_centers = np.linspace(0, self.w, number_of_panoramas + 2, endpoint=True, dtype=np.int)[1:-1]\\n warped_slice_centers = np.zeros((number_of_panoramas, self.frames_for_panoramas.size))\\n # every slice is a different panorama, it indicates the slices of the input images from which the panorama\\n # will be concatenated\\n for i in range(slice_centers.size):\\n slice_center_2d = np.array([slice_centers[i], self.h // 2])[None, :]\\n # homography warps the slice center to the coordinate system of the middle image\\n warped_centers = [apply_homography(slice_center_2d, h) for h in self.homographies]\\n # we are actually only interested in the x coordinate of each slice center in the panoramas' coordinate system\\n warped_slice_centers[i] = np.array(warped_centers)[:, :, 0].squeeze() - global_offset[0]\\n\\n panorama_size = np.max(self.bounding_boxes, axis=(0, 1)).astype(np.int) + 1\\n\\n # boundary between input images in the panorama\\n x_strip_boundary = ((warped_slice_centers[:, :-1] + warped_slice_centers[:, 1:]) / 2)\\n x_strip_boundary = np.hstack([np.zeros((number_of_panoramas, 1)),\\n x_strip_boundary,\\n np.ones((number_of_panoramas, 1)) * panorama_size[0]])\\n x_strip_boundary = x_strip_boundary.round().astype(np.int)\\n\\n self.panoramas = np.zeros((number_of_panoramas, panorama_size[1], panorama_size[0], 3), dtype=np.float64)\\n for i, frame_index in enumerate(self.frames_for_panoramas):\\n # warp every input image once, and populate all panoramas\\n image = sol4_utils.read_image(self.files[frame_index], 2)\\n warped_image = warp_image(image, self.homographies[i])\\n x_offset, y_offset = self.bounding_boxes[i][0].astype(np.int)\\n y_bottom = y_offset + warped_image.shape[0]\\n\\n for panorama_index in range(number_of_panoramas):\\n # take strip of warped image and paste to current panorama\\n boundaries = x_strip_boundary[panorama_index, i:i + 2]\\n image_strip = warped_image[:, boundaries[0] - x_offset: boundaries[1] - x_offset]\\n x_end = boundaries[0] + image_strip.shape[1]\\n self.panoramas[panorama_index, y_offset:y_bottom, boundaries[0]:x_end] = image_strip\\n\\n # crop out areas not recorded from enough angles\\n # assert will fail if there is overlap in field of view between the left most image and the right most image\\n crop_left = int(self.bounding_boxes[0][1, 0])\\n crop_right = int(self.bounding_boxes[-1][0, 0])\\n assert crop_left < crop_right, 'for testing your code with a few images do not crop.'\\n print(crop_left, crop_right)\\n self.panoramas = self.panoramas[:, :, crop_left:crop_right, :]\",\n \"def generate_panoramic_images(self, number_of_panoramas):\\n assert self.homographies is not None\\n\\n # compute bounding boxes of all warped input images in the coordinate system of the middle image (as given by the homographies)\\n self.bounding_boxes = np.zeros((self.frames_for_panoramas.size, 2, 2))\\n for i in range(self.frames_for_panoramas.size):\\n self.bounding_boxes[i] = compute_bounding_box(self.homographies[i], self.w, self.h)\\n\\n # change our reference coordinate system to the panoramas\\n # all panoramas share the same coordinate system\\n global_offset = np.min(self.bounding_boxes, axis=(0, 1))\\n self.bounding_boxes -= global_offset\\n\\n slice_centers = np.linspace(0, self.w, number_of_panoramas + 2, endpoint=True, dtype=np.int)[1:-1]\\n warped_slice_centers = np.zeros((number_of_panoramas, self.frames_for_panoramas.size))\\n # every slice is a different panorama, it indicates the slices of the input images from which the panorama\\n # will be concatenated\\n for i in range(slice_centers.size):\\n slice_center_2d = np.array([slice_centers[i], self.h // 2])[None, :]\\n # homography warps the slice center to the coordinate system of the middle image\\n warped_centers = [apply_homography(slice_center_2d, h) for h in self.homographies]\\n # we are actually only interested in the x coordinate of each slice center in the panoramas' coordinate system\\n warped_slice_centers[i] = np.array(warped_centers)[:, :, 0].squeeze() - global_offset[0]\\n\\n panorama_size = np.max(self.bounding_boxes, axis=(0, 1)).astype(np.int) + 1\\n\\n # boundary between input images in the panorama\\n x_strip_boundary = ((warped_slice_centers[:, :-1] + warped_slice_centers[:, 1:]) / 2)\\n x_strip_boundary = np.hstack([np.zeros((number_of_panoramas, 1)),\\n x_strip_boundary,\\n np.ones((number_of_panoramas, 1)) * panorama_size[0]])\\n x_strip_boundary = x_strip_boundary.round().astype(np.int)\\n\\n self.panoramas = np.zeros((number_of_panoramas, panorama_size[1], panorama_size[0], 3), dtype=np.float64)\\n for i, frame_index in enumerate(self.frames_for_panoramas):\\n # warp every input image once, and populate all panoramas\\n image = sol4_utils.read_image(self.files[frame_index], 2)\\n warped_image = warp_image(image, self.homographies[i])\\n x_offset, y_offset = self.bounding_boxes[i][0].astype(np.int)\\n y_bottom = y_offset + warped_image.shape[0]\\n\\n for panorama_index in range(number_of_panoramas):\\n # take strip of warped image and paste to current panorama\\n boundaries = x_strip_boundary[panorama_index, i:i + 2]\\n image_strip = warped_image[:, boundaries[0] - x_offset: boundaries[1] - x_offset]\\n x_end = boundaries[0] + image_strip.shape[1]\\n self.panoramas[panorama_index, y_offset:y_bottom, boundaries[0]:x_end] = image_strip\\n\\n # crop out areas not recorded from enough angles\\n # assert will fail if there is overlap in field of view between the left most image and the right most image\\n crop_left = int(self.bounding_boxes[0][1, 0])\\n crop_right = int(self.bounding_boxes[-1][0, 0])\\n assert crop_left < crop_right, 'for testing your code with a few images do not crop.'\\n print(crop_left, crop_right)\\n self.panoramas = self.panoramas[:, :, crop_left:crop_right, :]\",\n \"def _make_slices(self, img_stacks, mask_stacks, patient_id, out_pth):\\n img_file_name = \\\"{patient}_{id}_stack\\\"\\n msk_file_name = \\\"{patient}_{id}_stack_mask\\\"\\n for s in range(1, img_stacks.shape[0] + 1):\\n if s < self.stack_size or img_stacks.shape[0] - s <= self.stack_size:\\n continue\\n slice_idx = np.arange(-1, self.stack_size-1) + s\\n im_block = img_stacks[slice_idx,:, :, 1]\\n msk_block = mask_stacks[s, :, :, 1] # Output is the mask for the center channel\\n np.save(os.path.join(out_pth, img_file_name.format(patient=patient_id, id=s)), im_block)\\n np.save(os.path.join(out_pth, msk_file_name.format(patient=patient_id, id=s)), msk_block)\",\n \"def viz(self,slices):\\n #layers_copy = deepcopy(self.layers)\\n self.layers_copy = self.layers\\n imgs = [torch.zeros([1,3,self.N_in,self.N_in])]\\n \\n for layer in self.layers:\\n if isinstance(layer,nn.Conv2d):\\n layer2 = nn.Conv2d(3,3,layer.kernel_size,layer.stride,layer.padding)\\n imgs.append(layer2(imgs[-1]))\\n else:\\n imgs.append(layer(imgs[-1]))\\n \\n assert(len(self.projs) == len(imgs)-1)\\n for proj,img in zip(self.projs[::-1],imgs[::-1]):\\n (x1,x2),(y1,y2) = slices\\n img[0,:,x1:x2+1,y1:y2+1] = 255\\n slices = proj(slices)\\n (x1,x2),(y1,y2) = slices\\n imgs[0][0,:,x1:x2+1,y1:y2+1] = 255\\n \\n dim = int(np.floor(np.sqrt(len(self.layers))))+1\\n fig,axes = plt.subplots(dim,dim,figsize=(10,10))\\n for i,img in enumerate(imgs):\\n a,b = np.unravel_index(i,(dim,dim))\\n axes[a,b].imshow((img[0].detach().permute(1,2,0).numpy()).astype(np.uint8))\\n axes[a,b].set_title(str(i))\",\n \"def image_clip_to_segment_and_convert(image_ms_array, image_pan_array, mask_array, factor, image_height_size, \\r\\n image_width_size):\\r\\n \\r\\n img_pan_list = []\\r\\n img_ms_list = []\\r\\n mask_list = []\\r\\n \\r\\n n_bands = image_ms_array.shape[2]\\r\\n \\r\\n for i in range(0, image_pan_array.shape[0] - image_height_size, int(factor)):\\r\\n for j in range(0, image_pan_array.shape[1] - image_width_size, int(factor)):\\r\\n M_90 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 90, 1.0)\\r\\n M_180 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 180, 1.0)\\r\\n M_270 = cv2.getRotationMatrix2D((image_width_size / 2, image_height_size / 2), 270, 1.0)\\r\\n \\r\\n img_original = image_pan_array[i : i + image_height_size, j : j + image_width_size, 0]\\r\\n img_rotate_90 = cv2.warpAffine(img_original, M_90, (image_height_size, image_width_size))\\r\\n img_rotate_180 = cv2.warpAffine(img_original, M_180, (image_width_size, image_height_size))\\r\\n img_rotate_270 = cv2.warpAffine(img_original, M_270, (image_height_size, image_width_size))\\r\\n img_flip_hor = cv2.flip(img_original, 0)\\r\\n img_flip_vert = cv2.flip(img_original, 1)\\r\\n img_flip_both = cv2.flip(img_original, -1)\\r\\n img_pan_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \\r\\n img_flip_both])\\r\\n mask_patch = mask_array[i : i + image_height_size, j : j + image_width_size, 0]\\r\\n label = mask_patch[int(image_height_size / 2), int(image_width_size / 2)]\\r\\n mask_list.extend([label] * 7)\\r\\n \\r\\n for i in range(0, int(image_ms_array.shape[0] - (image_height_size / factor)), 1):\\r\\n for j in range(0, int(image_ms_array.shape[1] - (image_width_size / factor)), 1):\\r\\n M_90_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 90, 1.0)\\r\\n M_180_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 180, 1.0)\\r\\n M_270_ms = cv2.getRotationMatrix2D(((image_width_size / factor) / 2, (image_height_size / factor) / 2), 270, 1.0)\\r\\n \\r\\n img_original = image_ms_array[i : i + image_height_size, j : j + image_width_size, 0 : n_bands]\\r\\n img_rotate_90 = cv2.warpAffine(img_original, M_90_ms, (image_height_size, image_width_size))\\r\\n img_rotate_180 = cv2.warpAffine(img_original, M_180_ms, (image_width_size, image_height_size))\\r\\n img_rotate_270 = cv2.warpAffine(img_original, M_270_ms, (image_height_size, image_width_size))\\r\\n img_flip_hor = cv2.flip(img_original, 0)\\r\\n img_flip_vert = cv2.flip(img_original, 1)\\r\\n img_flip_both = cv2.flip(img_original, -1)\\r\\n img_ms_list.extend([img_original, img_rotate_90, img_rotate_180, img_rotate_270, img_flip_hor, img_flip_vert, \\r\\n img_flip_both])\\r\\n \\r\\n image_pan_segment_array = np.zeros((len(img_pan_list), image_height_size, image_width_size, image_pan_array.shape[2]))\\r\\n image_ms_segment_array = np.zeros((len(img_ms_list), int(image_height_size / factor), int(image_width_size / factor), \\r\\n image_ms_array.shape[2]))\\r\\n \\r\\n for index in range(len(img_pan_list)):\\r\\n image_pan_segment_array[index] = img_pan_list[index]\\r\\n image_ms_segment_array[index] = img_ms_list[index]\\r\\n \\r\\n mask_array = np.array(mask_list)\\r\\n \\r\\n return image_ms_segment_array, image_pan_segment_array, mask_array\",\n \"def combine_images(args):\\n\\n # Read all images into a cube (TODO: think about the RAM)\\n with fits.open(args.input[0]) as im0:\\n lx, ly = im0[0].data.shape\\n ref_hdr = im0[0].header\\n\\n headers = [fits.open(im_name)[0].header for im_name in args.input]\\n cube = numpy.ma.zeros((len(args.input), lx, ly))\\n cube.mask = numpy.zeros_like(cube.data)\\n for ii, im_name in enumerate(args.input):\\n with astroim.Astroim(im_name) as im:\\n cube.data[ii, :,:] = im.chips[0].data\\n if im.chips[0].mask is not None:\\n cube.mask[ii,:,:] = im.chips[0].mask\\n\\n # Scale images\\n scale_functions = {\\\"median\\\": numpy.ma.median,\\n \\\"mean\\\": numpy.ma.mean,\\n \\\"mode\\\": scipy.stats.mstats.mode,\\n \\\"none\\\": lambda x: 1}\\n for ii, im_name in enumerate(args.input):\\n func = scale_functions[args.scale.lower()]\\n cube[ii,:,:] /= func(cube[ii,:,:])\\n\\n\\n # Reproject all images to the ref_hdr\\n for ii, _ in enumerate(args.input):\\n if ii == 0:\\n continue\\n cube.data[ii,:,:], footprint = reproject_interp((cube.data[ii,:,:], headers[ii]), ref_hdr)\\n cube.mask[ii,:,:], footprint = reproject_interp((cube.mask[ii,:,:], headers[ii]), ref_hdr)\\n #whr = numpy.isnan(cube.data[ii,:,:])\\n #cube.mask[ii,:,:][whr] = True\\n\\n # Do average\\n average_functions = {\\\"median\\\": numpy.ma.median, \\\"mean\\\": numpy.ma.mean, \\\"sum\\\": numpy.ma.sum}\\n func = average_functions[args.average.lower()]\\n final_image = func(cube, axis=0)\\n ref_hdr[\\\"NCOMBINE\\\"] = len(args.input)\\n\\n mask_name = utilities.replace_extension(args.output, \\\".fits.msk\\\")\\n mask_name_header = utilities.replace_extension(os.path.basename(args.output), \\\".fits.msk\\\")\\n ref_hdr[\\\"MASK\\\"] = mask_name_header\\n fits.writeto(args.output, final_image.data, ref_hdr, clobber=True )\\n fits.writeto(mask_name, numpy.array(final_image.mask, dtype=int), clobber=True)\\n\\n return args.output\",\n \"def get_2D_slices(atlas: str):\\n if atlas == \\\"avg\\\":\\n AVGT, metaAVGT = nrr.read(\\\"nrrd/average_template_10.nrrd\\\")\\n folder = \\\"avg\\\"\\n elif atlas == \\\"nissl\\\":\\n AVGT, metaAVGT = nrr.read(\\\"nrrd/ara_nissl_10.nrrd\\\")\\n folder = \\\"nissl\\\"\\n else:\\n raise Exception(\\\"Wrong argument for var atlas\\\")\\n\\n degress = [i for i in range(-15, 16, 3)]\\n\\n for degree in tqdm(degress):\\n rotated = rot(AVGT, angle=degree, mode=\\\"nearest\\\", order=0, reshape=True)\\n print(degree)\\n for plate_no in tqdm(range(300, 1300, 5)):\\n save_img(rotated[plate_no], folder=folder, plate_no=plate_no, degree=degree)\",\n \"def get_slice(P1, P2, name):\\n \\n centre_dist = distance_3D(P1, P2)\\n plot_img = np.zeros((ceil(centre_dist / 2. + 1), centre_dist + 2 ))\\n Xrange = np.arange(-centre_dist / 4., centre_dist / 4. + 1)\\n \\n # time goes along the vector between P1 and P2\\n # since it might be at an angle, I can't loop in 1\\n # pixel increments - this will miss certain slices. Therefore,\\n # I need to loop through by 1/cosA, where A is angle between\\n # the xy plane and vector P1->P2\\n sampling = sample_rate(P1, P2)\\n \\n for time in np.linspace(0, centre_dist + 1,\\n centre_dist * sampling):\\n # Go up along the line\\n new_pt = vector_3D(P1, P2, time)\\n old_pt = vector_3D(P1, P2, time - centre_dist / 2. * sampling)\\n\\n if time == 0:\\n input_file = name % int(round(new_pt[2], 0))\\n img = io.imread(input_file)\\n \\n # Check if the previous slice is the same as the next\\n # don't load it again if it is - save computation time\\n if int(round(new_pt[2], 0)) != int(round(old_pt[2], 0)):\\n \\n input_file = name % int(round(new_pt[2], 0))\\n img = io.imread(input_file)\\n \\n for X in Xrange:\\n \\n # Get along the X direction for every height\\n x, y, z = vector_perpendicular_3D(new_pt, P2, 1, 0, X)\\n \\n pixel_value = interpolation(x, y, img)\\n \\n plot_img[X + centre_dist / 4., time] = pixel_value\\n else:\\n for X in Xrange:\\n \\n # Get along the X direction for every height\\n x, y, z = vector_perpendicular_3D(new_pt, P2, 1, 0, X)\\n\\n pixel_value = interpolation(x, y, img)\\n \\n plot_img[X + centre_dist / 4., time] = pixel_value\\n \\n return plot_img\",\n \"def slice_im_plus_boxes(image_path, out_name, out_dir_images, \\n boxes=[], yolo_classes=[], out_dir_labels=None, \\n mask_path=None, out_dir_masks=None,\\n sliceHeight=416, sliceWidth=416,\\n overlap=0.1, slice_sep='|', pad=0,\\n skip_highly_overlapped_tiles=False,\\n overwrite=False,\\n out_ext='.png', verbose=False):\\n\\n if len(out_ext) == 0:\\n im_ext = '.' + image_path.split('.')[-1]\\n else:\\n im_ext = out_ext\\n\\n t0 = time.time()\\n image = skimage.io.imread(image_path) #, as_grey=False).astype(np.uint8) # [::-1]\\n print(\\\"image.shape:\\\", image.shape)\\n if mask_path:\\n mask = skimage.io.imread(mask_path)\\n win_h, win_w = image.shape[:2]\\n win_size = sliceHeight*sliceWidth\\n dx = int((1. - overlap) * sliceWidth)\\n dy = int((1. - overlap) * sliceHeight)\\n \\n n_ims = 0\\n for y0 in range(0, image.shape[0], dy):\\n for x0 in range(0, image.shape[1], dx):\\n out_boxes_yolo = []\\n out_classes_yolo = []\\n n_ims += 1\\n\\n if (n_ims % 100) == 0:\\n print(n_ims)\\n\\n # make sure we don't have a tiny image on the edge\\n if y0+sliceHeight > image.shape[0]:\\n # skip if too much overlap (> 0.6)\\n if skip_highly_overlapped_tiles:\\n if (y0+sliceHeight - image.shape[0]) > (0.6*sliceHeight):\\n continue\\n else:\\n y = image.shape[0] - sliceHeight\\n else:\\n y = image.shape[0] - sliceHeight\\n else:\\n y = y0\\n if x0+sliceWidth > image.shape[1]:\\n # skip if too much overlap (> 0.6)\\n if skip_highly_overlapped_tiles:\\n if (x0+sliceWidth - image.shape[1]) > (0.6*sliceWidth):\\n continue\\n else:\\n x = image.shape[1] - sliceWidth\\n else:\\n x = image.shape[1] - sliceWidth\\n else:\\n x = x0\\n\\n xmin, xmax, ymin, ymax = x, x+sliceWidth, y, y+sliceHeight\\n\\n # find boxes that lie entirely within the window\\n if len(boxes) > 0:\\n out_path_label = os.path.join(\\n out_dir_labels,\\n out_name + slice_sep + str(y) + '_' + str(x) + '_'\\n + str(sliceHeight) + '_' + str(sliceWidth)\\n + '_' + str(pad) + '_' + str(win_w) + '_' + str(win_h)\\n + '.txt')\\n for j,b in enumerate(boxes):\\n yolo_class = yolo_classes[j]\\n xb0, yb0, xb1, yb1 = b\\n if (xb0 >= xmin) and (yb0 >= ymin) \\\\\\n and (xb1 <= xmax) and (yb1 <= ymax):\\n # get box coordinates within window\\n out_box_tmp = [xb0 - xmin, xb1 - xmin,\\n yb0 - ymin, yb1 - ymin]\\n print(\\\" out_box_tmp:\\\", out_box_tmp)\\n # out_boxes.append(out_box_tmp)\\n # convert to yolo coords (x,y,w,h)\\n yolo_coords = prep_train.convert((sliceWidth, sliceHeight),\\n out_box_tmp)\\n print(\\\" yolo_coords:\\\", yolo_coords)\\n out_boxes_yolo.append(yolo_coords)\\n out_classes_yolo.append(yolo_class)\\n \\n # skip if no labels?\\n if len(out_boxes_yolo) == 0:\\n continue\\n\\n # save yolo labels\\n txt_outfile = open(out_path_label, \\\"w\\\") \\n for yolo_class, yolo_coord in zip(out_classes_yolo, out_boxes_yolo): \\n outstring = str(yolo_class) + \\\" \\\" + \\\" \\\".join([str(a) for a in yolo_coord]) + '\\\\n'\\n if verbose: \\n print(\\\" outstring:\\\", outstring.strip())\\n txt_outfile.write(outstring)\\n txt_outfile.close() \\n\\n # save mask, if desired\\n if mask_path:\\n mask_c = mask[y:y + sliceHeight, x:x + sliceWidth]\\n outpath_mask = os.path.join(\\n out_dir_masks,\\n out_name + slice_sep + str(y) + '_' + str(x) + '_'\\n + str(sliceHeight) + '_' + str(sliceWidth)\\n + '_' + str(pad) + '_' + str(win_w) + '_' + str(win_h)\\n + im_ext)\\n skimage.io.imsave(outpath_mask, mask_c, check_contrast=False)\\n\\n # extract image\\n window_c = image[y:y + sliceHeight, x:x + sliceWidth]\\n outpath = os.path.join(\\n out_dir_images,\\n out_name + slice_sep + str(y) + '_' + str(x) + '_'\\n + str(sliceHeight) + '_' + str(sliceWidth)\\n + '_' + str(pad) + '_' + str(win_w) + '_' + str(win_h)\\n + im_ext)\\n if not os.path.exists(outpath):\\n skimage.io.imsave(outpath, window_c, check_contrast=False)\\n elif overwrite:\\n skimage.io.imsave(outpath, window_c, check_contrast=False)\\n else:\\n print(\\\"outpath {} exists, skipping\\\".format(outpath))\\n \\n print(\\\"Num slices:\\\", n_ims,\\n \\\"sliceHeight\\\", sliceHeight, \\\"sliceWidth\\\", sliceWidth)\\n print(\\\"Time to slice\\\", image_path, time.time()-t0, \\\"seconds\\\")\\n return\",\n \"def animate_slices_multi(field='uu1', datadir1='data/', datadir2='data/', proc=-1, extension='xz',\\n format='native', tmin=0., tmax=1.e38, wait=0.,\\n amin=0., amax=1., transform='', oldfile=False,\\n makemovie=False):\\n\\n import pylab as plt\\n\\n datadir1 = os.path.expanduser(datadir1)\\n if proc < 0:\\n filename1 = join(datadir1, 'slice_' + field + '.' + extension)\\n else:\\n filename1 = join(datadir1, 'proc' + str(proc),\\n 'slice_' + field + '.' + extension)\\n\\n datadir2 = os.path.expanduser(datadir2)\\n if proc < 0:\\n filename2 = join(datadir2, 'slice_' + field + '.' + extension)\\n else:\\n filename2 = join(datadir2, 'proc' + str(proc),\\n 'slice_' + field + '.' + extension)\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir1, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane1 = np.zeros((vsize, hsize), dtype=precision)\\n plane2 = np.zeros((vsize, hsize), dtype=precision)\\n\\n infile1 = npfile(filename1, endian=format)\\n infile2 = npfile(filename2, endian=format)\\n\\n #ax = plt.axes()\\n #ax.set_xlabel('')\\n #ax.set_ylabel('')\\n #ax.set_ylim\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n\\n fig, (ax1,ax2) = plt.subplots(1,2)\\n #fig.suptitle('Re = 400', fontsize=20)\\n image1 = ax1.imshow(plane1, vmin=amin, vmax=amax)\\n image2 = ax2.imshow(plane2, vmin=amin, vmax=amax)\\n ax1.set_xlabel('')\\n ax1.set_ylabel('')\\n ax1.get_xaxis().set_visible(False)\\n ax1.get_yaxis().set_visible(False)\\n ax2.set_xlabel('')\\n ax2.set_ylabel('')\\n ax2.get_xaxis().set_visible(False)\\n ax2.get_yaxis().set_visible(False)\\n\\n # Get the figure manager for real-time image display.\\n manager = plt.get_current_fig_manager()\\n manager.show()\\n\\n ifirst = True\\n islice = 0\\n files = []\\n\\n while True:\\n try:\\n raw_data1 = infile1.fort_read(precision)\\n raw_data2 = infile2.fort_read(precision)\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data1[-1]\\n plane1 = raw_data1[:-1].reshape(vsize, hsize)\\n plane2 = raw_data2[:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data1[-2]\\n plane1 = raw_data1[:-2].reshape(vsize, hsize)\\n plane2 = raw_data2[:-2].reshape(vsize, hsize)\\n\\n if transform:\\n exec('plane = plane' + transform)\\n\\n if t > tmin and t < tmax:\\n title = 't = %11.3e' % t\\n #fig.set_title(title)\\n image1.set_data(plane1)\\n image2.set_data(plane2)\\n manager.canvas.draw()\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" \\\\ # Python 2\\n #% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plane1.min(), plane1.max(), plane1.max() - plane1.min()))\\n\\n if(makemovie):\\n fname = '_tmp%03d.png' % islice\\n fig.savefig(fname)\\n files.append(fname)\\n\\n ifirst = False\\n islice += 1\\n\\n sleep(wait)\\n\\n infile1.close()\\n infile2.close()\\n\\n if(makemovie):\\n print('Making movie animation.mpg - this make take a while')\\n # SC: Not all systems use mencoder. Need to change this into ffmpeg.\\n os.system(\\\"mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg\\\")\\n os.system(\\\"rm _tmp*.png\\\")\",\n \"def chain(self,slices):\\n for proj in self.projs[::-1]:\\n slices = proj(slices)\\n return\",\n \"def transform_images(img1,img2):\",\n \"def _stack_output_images(self):\\n\\n self._logger.info(\\\"Stacking the grayscale image stack.\\\")\\n command = self._get_generic_stack_slice_wrapper(\\n 'resliced_gray_mask', 'out_volume_gray')\\n self.execute(command)\\n\\n self._logger.info(\\\"Stacking the multichannel image stack.\\\")\\n command = self._get_generic_stack_slice_wrapper(\\n 'resliced_color_mask', 'out_volume_color')\\n self.execute(command)\\n\\n self._logger.info(\\\"Reslicing is done.\\\")\",\n \"def stitch_multiple_images(imgs, desc_func=simple_descriptor, patch_size=5):\\n # Detect keypoints in each image\\n keypoints = [] # keypoints[i] corresponds to imgs[i]\\n for img in imgs:\\n kypnts = corner_peaks(harris_corners(img, window_size=3),\\n threshold_rel=0.05,\\n exclude_border=8)\\n keypoints.append(kypnts)\\n # Describe keypoints\\n descriptors = [] # descriptors[i] corresponds to keypoints[i]\\n for i, kypnts in enumerate(keypoints):\\n desc = describe_keypoints(imgs[i], kypnts,\\n desc_func=desc_func,\\n patch_size=patch_size)\\n descriptors.append(desc)\\n # Match keypoints in neighboring images\\n matches = [] # matches[i] corresponds to matches between\\n # descriptors[i] and descriptors[i+1]\\n for i in range(len(imgs)-1):\\n mtchs = match_descriptors(descriptors[i], descriptors[i+1], 0.7)\\n matches.append(mtchs)\\n\\n ### YOUR CODE HERE\\n raise NotImplementedError() # Delete this line\\n ### END YOUR CODE\\n\\n return panorama\",\n \"def get_4d(slice, copylayers=[], transparancy=0):\\n assert slice.ndim < 3\\n img = np.zeros(slice.shape)\\n img = img[:, :, np.newaxis]\\n img = np.repeat(img, 4, 2)\\n transparancy = 255 - (255 * transparancy)\\n img[:, :, -1] = transparancy\\n for layer in copylayers:\\n img[:, :, layer] = slice\\n return(img)\",\n \"def concat_3dimages(imga, imgb, xoffset=0, yoffset=0, zoffset=0,\\n transpose=True, ontop=True, center_offset=True,\\n adjust_z=(0, 1)):\\n if transpose:\\n print(\\\"Transpose images\\\")\\n imga = np.transpose(imga, axes=(0, 2, 1))\\n imgb = np.transpose(imgb, axes=(0, 2, 1))\\n\\n max_dim = np.maximum.reduce([imga.shape, imgb.shape])\\n\\n center_a = np.array(np.divide(imga.shape, 2), dtype=int)\\n center_b = np.array(np.divide(imgb.shape, 2), dtype=int)\\n offset = (abs(zoffset), abs(yoffset), abs(xoffset))\\n\\n if center_offset:\\n new_offset = np.subtract(center_a, np.add(center_b, offset))\\n else:\\n new_offset = np.array(offset)\\n\\n if (max_dim == imgb.shape).all():\\n tmp = np.copy(imgb)\\n imgb = np.copy(imga)\\n imga = np.copy(tmp)\\n ontop = toggle(ontop)\\n xoffset *= -1\\n yoffset *= -1\\n zoffset *= -1\\n\\n new_offset[new_offset > 0] = 0\\n center_new = np.array(np.divide(max_dim, 2), dtype=int)\\n new_img = np.full(np.add(max_dim, np.abs(new_offset)), np.nan)\\n\\n Sa0 = slice(int(center_new[0] - imga.shape[0]/2 + 0.5),\\n int(center_new[0] + imga.shape[0]/2 + 0.5))\\n Sa1 = slice(int(center_new[1] - imga.shape[1]/2 + 0.5),\\n int(center_new[1] + imga.shape[1]/2 + 0.5))\\n Sa2 = slice(int(center_new[2] - imga.shape[2]/2 + 0.5),\\n int(center_new[2] + imga.shape[2]/2 + 0.5))\\n Sb0 = slice(int(center_new[0] + abs(zoffset) - imgb.shape[0]/2 + 0.5),\\n int(center_new[0] + abs(zoffset) + imgb.shape[0]/2 + 0.5))\\n Sb1 = slice(int(center_new[1] + abs(yoffset) - imgb.shape[1]/2 + 0.5),\\n int(center_new[1] + abs(yoffset) + imgb.shape[1]/2 + 0.5))\\n Sb2 = slice(int(center_new[2] + abs(xoffset) - imgb.shape[2]/2 + 0.5),\\n int(center_new[2] + abs(xoffset) + imgb.shape[2]/2 + 0.5))\\n\\n xdir = np.sign(xoffset)\\n ydir = np.sign(yoffset)\\n zdir = np.sign(zoffset)\\n\\n if ydir == 0:\\n ydir = 1\\n if xdir == 0:\\n xdir = 1\\n if zdir == 0:\\n zdir = 1\\n\\n imga = imga[::zdir, ::ydir, ::xdir]\\n imgb = imgb[::zdir, ::ydir, ::xdir]\\n\\n if adjust_z:\\n for ix in adjust_z:\\n top_img = 1 * new_img[ix]\\n top_img[Sa1, Sa2] = imga[ix]\\n top_img[Sb1, Sb2] = imgb[ix]\\n low_img = 1 * new_img[ix]\\n low_img[Sb1, Sb2] = imgb[ix]\\n low_img[Sa1, Sa2] = imga[ix]\\n\\n diff = top_img - low_img\\n m = np.nanmean(diff)\\n s = np.nanstd(diff)\\n mask = np.abs(diff) < m + s\\n diff[mask] = np.nan\\n add = np.nanmean(diff)\\n\\n print(add)\\n\\n imgb[ix] -= add\\n\\n print(\\\"new_img shape: \\\", new_img.shape)\\n\\n if ontop:\\n new_img[Sa0, Sa1, Sa2] = imga\\n new_img[Sb0, Sb1, Sb2] = imgb\\n else:\\n new_img[Sb0, Sb1, Sb2] = imgb\\n new_img[Sa0, Sa1, Sa2] = imga\\n\\n if transpose:\\n print(\\\"Transpose back\\\")\\n return np.transpose(new_img[::zdir, ::ydir, ::xdir], axes=(0, 2, 1))\\n else:\\n return new_img[::zdir, ::ydir, ::xdir]\",\n \"def __generate_slices_a_set(self, set_id):\\n image_set_path = os.path.join(self.__data_dir, set_id)\\n os.chdir(image_set_path)\\n try:\\n os.mkdir(self.__new_dir_name)\\n except FileExistsError:\\n print('Directory already exist! Pass making new directory.')\\n slice_dir = os.path.join(image_set_path, self.__new_dir_name)\\n image_dir = os.path.join(image_set_path, 'normal')\\n texts = os.listdir(image_dir)\\n os.chdir(image_dir)\\n for text in texts:\\n if text.endswith('txt'):\\n image_name = text.split('.')[0]\\n # image_path = os.path.join(image_dir, '{}.jpg'.format(image_name))\\n points = []\\n count = 0\\n with open(text, 'r') as f:\\n for line in f.readlines():\\n line = line.strip()\\n points.append(line.split(' '))\\n cv_image = cv2.imread(\\\"{}.jpg\\\".format(image_name))\\n for point in points:\\n count += 1\\n x = int(point[0])\\n y = int(point[1])\\n a_slice = cv_image[\\n x - self.__width:\\n x + self.__width,\\n y - self.__width:\\n y + self.__width]\\n new_dir = os.path.join(slice_dir, '{0}_p{1}.jpg'.format(image_name, count))\\n cv2.imwrite(new_dir, a_slice)\",\n \"def quadriview(nifti_title, prefix, slices_array=None):\\n # img = np.load(prefix + nifti_title)\\n img = nb.load(prefix + nifti_title)\\n to = time()\\n if slices_array is None:\\n slice_sag = np.random.randint(0.2 * img.shape[0], 0.8 * img.shape[0])\\n slice_orth = np.random.randint(0.2 * img.shape[1], 0.8 * img.shape[1])\\n slice_cor_1 = np.random.randint(0.3 * img.shape[2], 0.5 * img.shape[2])\\n slice_cor_2 = np.random.randint(0.5 * img.shape[2], 0.7 * img.shape[2])\\n else:\\n slice_sag, slice_orth, slice_cor_1, slice_cor_2 = slices_array\\n nifti_image = img.dataobj\\n view_1 = nifti_image[slice_sag, :, :]\\n view_2 = nifti_image[:, slice_orth, :]\\n view_3 = nifti_image[:, :, slice_cor_1]\\n view_4 = nifti_image[:, :, slice_cor_2]\\n\\n pad_lign = max(view_1.shape[0] + view_2.shape[0], view_3.shape[0] + view_4.shape[0])\\n pad_col = max(view_1.shape[1] + view_3.shape[1], view_2.shape[1] + view_4.shape[1])\\n pad = np.zeros((pad_lign, pad_col), dtype=np.float64)\\n pad[:view_1.shape[0], :view_1.shape[1]] = view_1\\n pad[-view_2.shape[0]:, :view_2.shape[1]] = view_2\\n pad[:view_3.shape[0], -view_3.shape[1]:] = view_3\\n pad[-view_4.shape[0]:, -view_4.shape[1]:] = view_4\\n return pad\",\n \"def slice_im(image_path, out_name, out_dir, sliceHeight=256, sliceWidth=256,\\n zero_frac_thresh=0.2, overlap=0.2, slice_sep='|',\\n out_ext='.png', verbose=False):\\n\\n use_cv2 = True\\n # read in image, cv2 fails on large files\\n print(\\\"Read in image:\\\", image_path)\\n try:\\n # convert to rgb (cv2 reads in bgr)\\n img_cv2 = cv2.imread(image_path, 1)\\n # print (\\\"img_cv2.shape:\\\", img_cv2.shape)\\n image0 = cv2.cvtColor(img_cv2, cv2.COLOR_BGR2RGB)\\n except:\\n image0 = skimage.io.imread(\\n image_path, as_grey=False).astype(np.uint8) # [::-1]\\n use_cv2 = False\\n print(\\\"image.shape:\\\", image0.shape)\\n # image0 = cv2.imread(image_path, 1) # color\\n\\n if len(out_ext) == 0:\\n ext = '.' + image_path.split('.')[-1]\\n else:\\n ext = out_ext\\n\\n win_h, win_w = image0.shape[:2]\\n\\n # if slice sizes are larger than image, pad the edges\\n pad = 0\\n if sliceHeight > win_h:\\n pad = sliceHeight - win_h\\n if sliceWidth > win_w:\\n pad = max(pad, sliceWidth - win_w)\\n # pad the edge of the image with black pixels\\n if pad > 0:\\n border_color = (0, 0, 0)\\n image0 = cv2.copyMakeBorder(image0, pad, pad, pad, pad,\\n cv2.BORDER_CONSTANT, value=border_color)\\n\\n win_size = sliceHeight*sliceWidth\\n\\n t0 = time.time()\\n n_ims = 0\\n n_ims_nonull = 0\\n dx = int((1. - overlap) * sliceWidth)\\n dy = int((1. - overlap) * sliceHeight)\\n\\n # for y0 in xrange(0, image0.shape[0], dy):#sliceHeight):\\n # for x0 in xrange(0, image0.shape[1], dx):#sliceWidth):\\n for y0 in range(0, image0.shape[0], dy): # sliceHeight):\\n for x0 in range(0, image0.shape[1], dx): # sliceWidth):\\n n_ims += 1\\n\\n if (n_ims % 50) == 0:\\n print(n_ims)\\n\\n # make sure we don't have a tiny image on the edge\\n if y0+sliceHeight > image0.shape[0]:\\n y = image0.shape[0] - sliceHeight\\n else:\\n y = y0\\n if x0+sliceWidth > image0.shape[1]:\\n x = image0.shape[1] - sliceWidth\\n else:\\n x = x0\\n\\n # extract image\\n window_c = image0[y:y + sliceHeight, x:x + sliceWidth]\\n # get black and white image\\n if use_cv2:\\n window = cv2.cvtColor(window_c, cv2.COLOR_BGR2GRAY)\\n else:\\n window = cv2.cvtColor(window_c, cv2.COLOR_RGB2GRAY)\\n\\n # find threshold that's not black\\n # https://opencv-python-tutroals.readthedocs.org/en/latest/py_tutorials/py_imgproc/py_thresholding/py_thresholding.html?highlight=threshold\\n ret, thresh1 = cv2.threshold(window, 2, 255, cv2.THRESH_BINARY)\\n non_zero_counts = cv2.countNonZero(thresh1)\\n zero_counts = win_size - non_zero_counts\\n zero_frac = float(zero_counts) / win_size\\n # print \\\"zero_frac\\\", zero_fra\\n # skip if image is mostly empty\\n if zero_frac >= zero_frac_thresh:\\n if verbose:\\n print(\\\"Zero frac too high at:\\\", zero_frac)\\n continue\\n # else save\\n else:\\n # outpath = os.path.join(out_dir, out_name + \\\\\\n # '|' + str(y) + '_' + str(x) + '_' + str(sliceHeight) + '_' + str(sliceWidth) +\\\\\\n # '_' + str(pad) + ext)\\n outpath = os.path.join(\\n out_dir,\\n out_name + slice_sep + str(y) + '_' + str(x) + '_'\\n + str(sliceHeight) + '_' + str(sliceWidth)\\n + '_' + str(pad) + '_' + str(win_w) + '_' + str(win_h)\\n + ext)\\n\\n # outpath = os.path.join(out_dir, 'slice_' + out_name + \\\\\\n # '_' + str(y) + '_' + str(x) + '_' + str(sliceHeight) + '_' + str(sliceWidth) +\\\\\\n # '_' + str(pad) + '.jpg')\\n if verbose:\\n print(\\\"outpath:\\\", outpath)\\n # if large image, convert to bgr prior to saving\\n if not use_cv2:\\n skimage.io.imsave(outpath, window_c)\\n else:\\n cv2.imwrite(outpath, window_c)\\n n_ims_nonull += 1\\n\\n print(\\\"Num slices:\\\", n_ims, \\\"Num non-null slices:\\\", n_ims_nonull,\\n \\\"sliceHeight\\\", sliceHeight, \\\"sliceWidth\\\", sliceWidth)\\n print(\\\"Time to slice\\\", image_path, time.time()-t0, \\\"seconds\\\")\\n\\n return\",\n \"def problem1():\\n\\n img = load_image(\\\"data/a1p1.png\\\")\\n display_image(img)\\n\\n save_as_npy(\\\"a1p1.npy\\\", img)\\n\\n img1 = load_npy(\\\"a1p1.npy\\\")\\n display_image(img1)\\n\\n img2 = mirror_horizontal(img1)\\n display_image(img2)\\n\\n display_images(img1, img2)\",\n \"def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\\n # create binary mask\\n mask = np.zeros(img_slice.shape)\\n mask[min_x:max_x, min_y:max_y] = 1\\n # keep a copy of original to have background later \\n img_orig = np.copy(img_slice)\\n mask_binary = np.copy(mask)\\n\\n # rotate image if coronal\\n if views=='coronal':\\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\\n mask = np.rot90(mask, axes=(1, 0))\\n \\n # prepare binary mask for net\\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask = torch.Tensor(mask) # gives dtype float32\\n mask = mask.unsqueeze(0)\\n mask = mask.unsqueeze(0)\\n\\n # prepare seg mask for net\\n mask_slice[mask_slice==self.vertebra_id] = 0\\n # resize to network size\\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\\n\\n mask_seg = self.map_vert_to_class(mask_seg)\\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n\\n # prepare img for net \\n img_slice = cv2.resize(img_slice, self.resize_size)\\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \\n img_slice = img_slice[:,:, None]\\n img_slice = self.toTensor(img_slice)\\n img_slice = img_slice.unsqueeze(0)\\n corrupt_img = (1-mask)*img_slice\\n\\n if self.use_cuda:\\n mask = mask.cuda()\\n mask_seg = mask_seg.cuda()\\n corrupt_img = corrupt_img.cuda() \\n\\n # inpaint\\n if views=='lateral':\\n netG = self.netGlat\\n elif views=='coronal':\\n netG = self.netGcor\\n\\n # get prediction\\n with torch.no_grad():\\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\\n inpainted_mask = self.softmax(inpainted_mask)\\n\\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\\n\\n # set img back to how it was\\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \\n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\\n # set mask back\\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\\n for i in range(6):\\n if views=='coronal':\\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\\n else:\\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\\n inpainted_mask = inpainted_mask_resized\\n \\n if views=='coronal':\\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\\n\\n return inpainted_img, inpainted_mask, mask_binary\",\n \"def splitMerge(self):\\n\\t\\tpath_merge = self.aug_merge_path\\n\\t\\tpath_train = self.aug_train_path\\n\\t\\tpath_label = self.aug_label_path\\n\\t\\tfor i in range(self.slices):\\n\\t\\t\\tpath = path_merge + \\\"/\\\" + str(i)\\n\\t\\t\\t# print(path)\\n\\t\\t\\ttrain_imgs = glob.glob(path+\\\"/*.\\\"+self.img_type)\\n\\t\\t\\t# print(len(train_imgs))\\n\\t\\t\\t# break\\n\\t\\t\\tfor imgname in train_imgs:\\n\\t\\t\\t\\tmidname = imgname[imgname.rindex(\\\"/\\\")+1:imgname.rindex(\\\".\\\"+self.img_type)]\\n\\t\\t\\t\\timg = cv2.imread(imgname)\\n\\t\\t\\t\\timg_train = img[:,:,2]#cv2 read image rgb->bgr\\n\\t\\t\\t\\timg_label = img[:,:,0]\\n\\t\\t\\t\\tcv2.imwrite(path_train+\\\"/\\\"+midname+\\\".\\\"+self.img_type,img_train)\\n\\t\\t\\t\\tcv2.imwrite(path_label+\\\"/\\\"+midname+\\\".\\\"+self.img_type,img_label)\",\n \"def stitch(dir_path, in_canels=1, choice=0):\\n directory = dir_path\\n array = [] # array used to create matrix\\n\\n p = re.compile(tiles_xy_re)\\n q = re.compile(original_img_xy_re)\\n\\n sum_of_files = len(os.listdir(directory))\\n tiles_horizontal_num = 0\\n\\n first = os.listdir(directory)[0] # we take a sample to extract\\n # original image information such as height, width, type\\n\\n original = q.match(first)\\n Original_width, Original_height = int(original.group(1)), int(\\n original.group(2))\\n im = Image.open(dir_path + '\\\\\\\\' + first)\\n\\n tile_h = np.array(im).shape[0]\\n tile_w= np.array(im).shape[1]\\n file_type = first.split(\\\".\\\")[-1]\\n\\n # creating array to merge all tiles to\\n if choice == 2: # if we choose and\\n output_array = np.ones((Original_height, Original_width, in_canels))\\n else:\\n output_array = np.zeros((Original_height, Original_width, in_canels))\\n\\n for filename in os.listdir(directory):\\n\\n xy = p.match(filename)\\n x, y = int(xy.group(1)), int(xy.group(2)) # extracting x,y relative\\n # to original img\\n\\n im = Image.open(dir_path + '\\\\\\\\' + filename)\\n if choice == 0:\\n output_array[y:y + tile_h, x:x + tile_w, :] = np.array(im)\\n elif choice == 1:\\n output_array[y:y + tile_h, x:x + tile_w, :] = np.logical_or(\\n output_array[y:y + tile_h, x:x + tile_w, :], np.array(im))\\n elif choice == 2:\\n output_array[y:y + tile_h, x:x + tile_w, :] = np.logical_and(\\n output_array[y:y + tile_h, x:x + tile_w, :], np.array(im))\\n\\n output_array[y:y + tile_h, x:x + tile_w, :] = np.array(im)\\n\\n array.append([x, y])\\n\\n if int(xy.group(1)) == 0:\\n tiles_horizontal_num = tiles_horizontal_num + 1\\n\\n # converting array to image and saving image\\n output_im = Image.fromarray(output_array.astype(np.uint8))\\n file_name = \\\"original.\\\" + file_type\\n path = dir_path + '\\\\\\\\' + file_name\\n output_im.save(path)\\n\\n # array = sorted(array, key=lambda k: [k[0], k[1]])\\n # numpy_array = np.array(array)\\n # matrix = numpy_array.reshape(sum_of_files // tiles_horizontal_num,\\n # tiles_horizontal_num, 2)\",\n \"def show_slices(slices):\\n fig, axes = plt.subplots(1, len(slices))\\n for i, slice in enumerate(slices):\\n axes[i].imshow(slice.T, cmap=\\\"gray\\\", origin=\\\"lower\\\")\",\n \"def print_image_slice_3d(input, num=0,direction=\\\"z\\\"):\\n\\t#print \\\"print slice at 3 directions\\\"\\n\\timage=get_image(input)\\n\\tnx = image.get_xsize()\\n\\tny = image.get_ysize()\\n\\tnz = image.get_zsize()\\n\\tif(direction==\\\"x\\\"):\\n\\t\\t#print \\\"xxxxx\\\"\\n\\t\\tix=num\\n\\t\\tprint \\\"(x = %d slice)\\\" % (ix)\\n\\t\\tline = []\\n\\t\\tfor iz in xrange(nz-1,-1,-1):\\n\\t\\t\\tline.append(\\\"Z \\\")\\n\\t\\t\\tline.append(\\\"%4i \\\" % iz)\\n\\t\\t\\tfor iy in xrange(ny):\\n\\t\\t\\t\\tline.append(\\\"%12.5g \\\" % (image.get_value_at(ix,iy,iz)))\\n\\t\\t\\t\\tif ((iy + 1) % 5 == 0): \\n\\t\\t\\t\\t\\tline.append(\\\"\\\\n \\\")\\n\\t\\t\\t\\t\\tline.append(\\\" \\\")\\n\\t \\t\\tline.append(\\\"\\\\n\\\")\\n\\t \\t\\tif(ny%5 != 0): line.append(\\\"\\\\n\\\")\\n\\t\\tprint \\\"\\\".join(line)\\n\\telif(direction==\\\"y\\\"):\\n\\t\\t#print \\\"yyy\\\"\\n\\t\\tiy=num\\n\\t\\tprint \\\"(y = %d slice)\\\" % (iy)\\n\\t\\tline = []\\n\\t\\tfor iz in xrange(nz-1,-1,-1):\\n\\t\\t\\tline.append(\\\"Z \\\")\\n\\t\\t\\tline.append(\\\"%4i \\\" % iz)\\n\\t\\t\\tfor ix in xrange(nx):\\n\\t\\t\\t\\tline.append(\\\"%12.5g \\\" % (image.get_value_at(ix,iy,iz)))\\n\\t\\t\\t\\tif ((ix + 1) % 5 == 0): \\n\\t\\t\\t\\t\\tline.append(\\\"\\\\n \\\")\\n\\t\\t\\t\\t\\tline.append(\\\" \\\")\\n\\t \\t\\tline.append(\\\"\\\\n\\\")\\n\\t \\t\\tif(nx%5 != 0): line.append(\\\"\\\\n\\\")\\n\\t\\tprint \\\"\\\".join(line)\\n\\telse:\\n\\t\\t#print \\\"zzzz\\\"\\n\\t\\tiz=num\\n\\t\\tprint \\\"(z = %d slice)\\\" % (iz)\\n\\t\\tline = []\\n\\t\\tfor iy in xrange(ny-1,-1,-1):\\n\\t\\t\\tline.append(\\\"Row \\\")\\n\\t\\t\\tline.append(\\\"%4i \\\" % iy)\\n\\t\\t\\tfor ix in xrange(nx):\\n\\t\\t\\t\\tline.append(\\\"%12.5g \\\" % (image.get_value_at(ix,iy,iz)))\\n\\t\\t\\t\\tif ((ix + 1) % 5 == 0): \\n\\t\\t\\t\\t\\tline.append(\\\"\\\\n \\\")\\n\\t\\t\\t\\t\\tline.append(\\\" \\\")\\n\\t \\t\\tline.append(\\\"\\\\n\\\")\\n\\t \\t\\tif(nx%5 != 0): line.append(\\\"\\\\n\\\")\\n\\t\\tprint \\\"\\\".join(line)\",\n \"def show_slices(self, slices):\\n fig, axes = plt.subplots(1, len(slices))\\n for i, slice in enumerate(slices):\\n axes[i].imshow(slice.T, cmap=\\\"gray\\\", origin=\\\"lower\\\")\",\n \"def preprocess_img(image, number_slices):\\n images = [[] for i in range(np.array(image).shape[0])]\\n\\n if number_slices > 2:\\n for j in range(np.array(image).shape[0]):\\n if type(image) is not np.ndarray:\\n for i in range(number_slices):\\n images[j].append(np.array(scipy.io.loadmat(image[0][i])['section'], dtype=np.float32))\\n else:\\n img = image\\n else:\\n for j in range(np.array(image).shape[0]):\\n for i in range(3):\\n images[j].append(np.array(scipy.io.loadmat(image[0][0])['section'], dtype=np.float32))\\n in_ = np.array(images[0])\\n in_ = in_.transpose((1, 2, 0))\\n in_ = np.expand_dims(in_, axis=0)\\n return in_\",\n \"def show_slices(slices):\\n fig, axes = plt.subplots(1, len(slices))\\n for i, slice in enumerate(slices):\\n axes[i].imshow(slice.T, cmap=\\\"gray\\\", origin=\\\"lower\\\")\",\n \"def concat_3dimages_corners(imga, imgb, xoffset=0, yoffset=0, zoffset=0,\\n transpose=True, ontop=True, center_offset=True,\\n adjust_z=(0, 1)):\\n print(\\\"Concating images with reference point being the lower left corner\\\")\\n if transpose:\\n print(\\\"Transpose images\\\")\\n imga = np.transpose(imga, axes=(0, 2, 1))\\n imgb = np.transpose(imgb, axes=(0, 2, 1))\\n\\n offset = (abs(zoffset), abs(yoffset), abs(xoffset))\\n max_dim = np.maximum.reduce([imga.shape, np.add(imgb.shape, offset)])\\n\\n # center_a = np.array(np.divide(imga.shape, 2), dtype=int)\\n # center_b = np.array(np.divide(imgb.shape, 2), dtype=int)\\n\\n # if (max_dim == imgb.shape).all():\\n # tmp = np.copy(imgb)\\n # imgb = np.copy(imga)\\n # imga = np.copy(tmp)\\n # ontop = toggle(ontop)\\n # xoffset *= -1\\n # yoffset *= -1\\n # zoffset *= -1\\n\\n # tmp_offset = np.array(offset)\\n # tmp_offset[tmp_offset > 0] = 0\\n # new_img = np.full(np.add(max_dim, np.abs(offset)), np.nan)\\n new_img = np.full(max_dim, np.nan)\\n\\n Sa0 = slice(0, imga.shape[0])\\n Sa1 = slice(0, imga.shape[1])\\n Sa2 = slice(0, imga.shape[2])\\n Sb0 = slice(abs(zoffset), abs(zoffset) + imgb.shape[0])\\n Sb1 = slice(abs(yoffset), abs(yoffset) + imgb.shape[1])\\n Sb2 = slice(abs(xoffset), abs(xoffset) + imgb.shape[2])\\n\\n xdir = np.sign(xoffset)\\n ydir = np.sign(yoffset)\\n zdir = np.sign(zoffset)\\n\\n if ydir == 0:\\n ydir = 1\\n if xdir == 0:\\n xdir = 1\\n if zdir == 0:\\n zdir = 1\\n\\n imga = imga[::zdir, ::ydir, ::xdir]\\n imgb = imgb[::zdir, ::ydir, ::xdir]\\n\\n if adjust_z:\\n for ix in adjust_z:\\n top_img = 1 * new_img[ix]\\n top_img[Sa1, Sa2] = imga[ix]\\n top_img[Sb1, Sb2] = imgb[ix]\\n low_img = 1 * new_img[ix]\\n low_img[Sb1, Sb2] = imgb[ix]\\n low_img[Sa1, Sa2] = imga[ix]\\n\\n diff = top_img - low_img\\n m = np.nanmean(diff)\\n s = np.nanstd(diff)\\n mask = np.abs(diff) < m + s\\n diff[mask] = np.nan\\n add = np.nanmean(diff)\\n\\n print(add)\\n\\n imgb[ix] -= add\\n\\n print(\\\"new_img shape: \\\", new_img.shape)\\n\\n if ontop:\\n new_img[Sa0, Sa1, Sa2] = imga\\n new_img[Sb0, Sb1, Sb2] = imgb\\n else:\\n new_img[Sb0, Sb1, Sb2] = imgb\\n new_img[Sa0, Sa1, Sa2] = imga\\n\\n new_img\\n\\n if transpose:\\n print(\\\"Transpose back\\\")\\n return np.transpose(new_img[::zdir, ::ydir, ::xdir], axes=(0, 2, 1))\\n else:\\n return new_img[::zdir, ::ydir, ::xdir]\",\n \"def take_slice(img_3D, view):\\n input_type = isinstance(img_3D, np.ndarray)\\n if input_type:\\n img_3D = [img_3D]\\n img_shape = img_3D[0].shape\\n if view == \\\"sag\\\":\\n slice_pos = np.random.randint(int(0.2 * img_shape[0]), int(0.8 * img_shape[0]))\\n imgs_2D = [imgg_3D[slice_pos, :, :] for imgg_3D in img_3D]\\n elif view == \\\"cor\\\":\\n slice_pos = np.random.randint(int(0.2 * img_shape[1]), int(0.8 * img_shape[1]))\\n imgs_2D = [imgg_3D[:, slice_pos, :] for imgg_3D in img_3D]\\n else:\\n slice_pos = np.random.randint(int(0.2 * img_shape[2]), int(0.8 * img_shape[2]))\\n imgs_2D = [imgg_3D[:, :, slice_pos] for imgg_3D in img_3D]\\n # img_2D = np.expand_dims(img_2D, 2)\\n if input_type:\\n return imgs_2D[0]\\n return imgs_2D\",\n \"def extract_input_slices(self,slices):\\n\\n cmds = []\\n for chunk in slices:\\n if ':' in chunk:\\n ini,fin = map(int,chunk.split(':'))\\n else:\\n ini = int(chunk)\\n fin = ini+1\\n cmds.append(self.shell.input_hist[ini:fin])\\n return cmds\",\n \"def load_prep_img(data_dir, imname, slice_intv,im_scale, num_slice):\\n ig = load_multislice_img_16bit_png(data_dir, imname, slice_intv, num_slice)\\n #ig = windowing(ig, [-1024,3072])\\n #ig1 = windowing(ig, [-173,275])\\n #ig2 = windowing(ig, [-1495,485])\\n #ig3 = windowing(ig, [-534,1426])\\n ig1 = windowing(ig, [-600,1400])\\n ig2 = windowing(ig, [-125,225])\\n ig3 = windowing(ig, [-45,105])\\n ig4 = windowing(ig, [-1350,150])\\n ig5 = windowing(ig, [-150,250])\\n \\n ig = np.concatenate([ig1,ig2,ig3,ig4,ig5], axis = 2)\\n ig = cv2.resize(ig, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\\n #ig = ig.astype('uint8')\\n #print('shape for ig1 ang ig',ig1.shape,ig.shape)\\n return ig\",\n \"def crop_images_color(dataset_dir, is_mask=True):\\n data = []\\n for folder in os.listdir(dataset_dir):\\n path = os.path.join(dataset_dir, folder, \\\"*_labelIds.png\\\")\\n data.extend(glob(path))\\n\\n for index, filePath in enumerate(data):\\n print ('{}/{}'.format(index, len(data)))\\n\\n img = scipy.misc.imread(filePath).astype(np.uint8)\\n img = scipy.misc.imresize(img, 0.25, interp='bilinear', mode=None)\\n if is_mask:\\n mask = np.ones((img.shape[0], img.shape[1]), dtype=np.uint8) * 255\\n\\n idx_person = np.where(np.all(img == [220, 20, 60, 255], axis=-1))\\n #idx_rider = np.where(np.all(img == [255, 0, 0, 255], axis=-1))\\n #idx_void = np.where(np.all(img == [0, 0, 0, 255], axis=-1))\\n\\n #indices = np.concatenate((idx_person, idx_rider, idx_void), axis=1)\\n indices = idx_person\\n # mask[indices[0], indices[1], :] = (0, 0, 0, 255)\\n mask[indices[0], indices[1]] = 0\\n mask = np.reshape(mask, (256, 512))\\n\\n #scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/CITYSCAPES_crop_random/' + filePath.split('/')[-1],\\n # img[offs_h[index]:offs_h_end[index], offs_w[index]:offs_w_end[index] :])\\n scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/for_wonderful_chou/image/' + filePath.split('/')[-1],\\n img[0:192, :])\\n #break\",\n \"def preprocess_imgs(img, slice_ = None , color = False, resize = (50,37)):\\r\\n\\r\\n # compute the portion of the images to load to respect the slice_ parameter\\r\\n # given by the caller\\r\\n \\r\\n default_slice = (slice(0, 250), slice(0, 250))\\r\\n \\r\\n if slice_ is None:\\r\\n slice_ = default_slice\\r\\n else:\\r\\n slice_ = tuple(s or ds for s, ds in zip(slice_, default_slice))\\r\\n\\r\\n h_slice, w_slice = slice_\\r\\n h = (h_slice.stop - h_slice.start) // (h_slice.step or 1)\\r\\n w = (w_slice.stop - w_slice.start) // (w_slice.step or 1)\\r\\n\\r\\n # allocate some contiguous memory to host the decoded image slices\\r\\n if not color:\\r\\n face = np.zeros((1, h, w), dtype=np.float32)\\r\\n else:\\r\\n face = np.zeros((1, h, w, 3), dtype=np.float32)\\r\\n\\r\\n # load the jpeg files as numpy arrays\\r\\n\\r\\n face = np.asarray(img[slice_], dtype=np.float32)\\r\\n face /= 255.0 # scale uint8 coded colors to the [0.0, 1.0] floats\\r\\n if resize is not None:\\r\\n face = imresize(face, resize)\\r\\n if not color:\\r\\n # average the color channels to compute a gray levels\\r\\n # representaion\\r\\n face = face.mean(axis=2)\\r\\n\\r\\n return face.reshape(1,-1)\",\n \"def main():\\n\\n # Just grab all files - we'll use try/except to filter\\n images = glob.glob(os.path.join(args.input_dir, '*.*'))\\n if not os.path.exists(args.output_dir):\\n os.makedirs(args.output_dir)\\n for img_file in images:\\n print(img_file)\\n try:\\n np_img = plt.imread(img_file)\\n print(np_img.shape)\\n img_name = img_file.split(os.sep)[-1]\\n new_img_file = os.path.join(args.output_dir, img_name)\\n pad_image(np_img, new_img_file)\\n except Exception as e:\\n print('Warning: {}. Skpping file.'.format(e))\\n continue\",\n \"def load_dataset(image_home, mask_home, patient_list, \\n size = 512, \\n downsample = 0.5, \\n overlap = 1.5, \\n verbose=False):\\n\\n image_list = np.concatenate([sorted(glob.glob(f'{image_home}/{p}/*')) for p in patient_list])\\n mask_list = np.concatenate([sorted(glob.glob(f'{mask_home}/{p}/*')) for p in patient_list])\\n\\n if verbose:\\n for i, (im, m) in enumerate(zip(image_list, mask_list)):\\n print(i, im, m)\\n\\n x = []\\n y = [] \\n\\n for im, m in zip(image_list, mask_list):\\n image = cv2.imread(im)[:,:,::-1]\\n mask = cv2.imread(m, -1)\\n mask = squash_labels(mask)\\n \\n image = cv2.resize(image, dsize=(0,0), fx=downsample, fy=downsample)\\n mask = cv2.resize(mask, dsize=(0,0), fx=downsample, fy=downsample,\\n interpolation=cv2.INTER_NEAREST)\\n\\n # assert (image.shape == mask.shape).all()\\n split_x , split_y = split(image, mask, int(size * downsample), overlap)\\n\\n x.append(split_x)\\n y.append(split_y)\\n\\n\\n x = np.concatenate(x, axis=0)\\n y = np.concatenate(y, axis=0)\\n y = np.eye(N=y.shape[0], M=4)[y]\\n\\n shuffle = np.arange(x.shape[0]).astype(np.int)\\n np.random.shuffle(shuffle)\\n x = x[shuffle, :]\\n y = y[shuffle, :]\\n\\n x = (x / 255.).astype(np.float32)\\n\\n print('split_datasets returning x:', x.shape, x.dtype, x.min(), x.max())\\n print('split_datasets returning y:', y.shape, y.dtype)\\n return x, y\",\n \"def animate_multislices(field=['uu1'], datadir='data/', proc=-1,\\n extension='xz', format='native', tmin=0., tmax=1.e38,\\n amin=0., amax=1., transform='plane[0]',\\n oldfile=False, outfile=\\\"\\\"):\\n\\n import pylab as plt\\n\\n datadir = os.path.expanduser(datadir)\\n if outfile != \\\"\\\":\\n outslice = open(outfile, \\\"w\\\")\\n filename = []\\n if proc < 0:\\n for i in field:\\n filename += [datadir + '/slice_' + i + '.' + extension]\\n else:\\n for i in field:\\n filename += [datadir + '/proc' +\\n str(proc) + '/slice_' + i + '.' + extension]\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane = []\\n infile = []\\n for i in filename:\\n plane += [np.zeros((vsize, hsize), dtype=precision)]\\n\\n infile += [npfile(i, endian=format)]\\n\\n ax = plt.axes()\\n ax.set_xlabel('x')\\n ax.set_ylabel('y')\\n ax.set_ylim\\n\\n exec('plotplane =' + transform)\\n image = plt.imshow(plotplane, vmin=amin, vmax=amax)\\n\\n # Get the figure manager for real-time image display.\\n manager = plt.get_current_fig_manager()\\n manager.show()\\n\\n ifirst = True\\n islice = 0\\n while True:\\n try:\\n raw_data = []\\n for i in infile:\\n raw_data += [i.fort_read(precision)]\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[0][-1]\\n for i in range(len(raw_data)):\\n plane[i] = raw_data[i][:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[0][-2]\\n for i in range(len(raw_data)):\\n plane[i] = raw_data[i][:-2].reshape(vsize, hsize)\\n\\n exec('plotplane =' + transform)\\n\\n if t > tmin and t < tmax:\\n title = 't = %11.3e' % t\\n ax.set_title(title)\\n image.set_data(plotplane)\\n manager.canvas.draw()\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % \\\\ # Python 2\\n #(islice, t, plotplane.min(), plotplane.max(), # Python 2\\n #plotplane.max() - plotplane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plotplane.min(), plotplane.max(),\\n plotplane.max() - plotplane.min()))\\n if outfile != \\\"\\\":\\n #outslice.write(\\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % # Python 2\\n #(islice, t, plotplane.min(), plotplane.max(), # Python 2\\n #plotplane.max() - plotplane.min())) # Python 2\\n outslice.write(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, plotplane.min(), plotplane.max(), plotplane.max() - plotplane.min()))\\n outslice.write(\\\"\\\\n\\\")\\n\\n ifirst = False\\n islice += 1\\n\\n for i in infile:\\n i.close()\\n if outfile != \\\"\\\":\\n outslice.close()\",\n \"def generate_images_pred(self, inputs, outputs):\\n for scale in self.scales:\\n disp = outputs[(\\\"disp\\\", scale)]\\n disp = F.interpolate(\\n disp, [self.height, self.width], mode=\\\"bilinear\\\", align_corners=False)\\n source_scale = 0\\n\\n _, depth = disp_to_depth(disp, self.min_depth, self.max_depth)\\n\\n outputs[(\\\"depth\\\", 0, scale)] = depth\\n\\n for i, frame_id in enumerate(self.frame_ids[1:]):\\n\\n T = outputs[(\\\"cam_T_cam\\\", 0, frame_id)]\\n\\n # from the authors of https://arxiv.org/abs/1712.00175\\n # mean-normalized inverse depth from [62] to discourage shrinking of the estimated depth\\n\\n axisangle = outputs[(\\\"axisangle\\\", 0, frame_id)]\\n translation = outputs[(\\\"translation\\\", 0, frame_id)]\\n\\n inv_depth = 1 / depth\\n mean_inv_depth = inv_depth.mean(3, True).mean(2, True)\\n\\n T = transformation_from_parameters(\\n axisangle[:, 0], translation[:, 0] * mean_inv_depth[:, 0], frame_id < 0)\\n\\n cam_points = self.backproject_depth[source_scale](\\n depth, inputs[(\\\"inv_K\\\", source_scale)])\\n pix_coords = self.project_3d[source_scale](\\n cam_points, inputs[(\\\"K\\\", source_scale)], T)\\n\\n outputs[(\\\"sample\\\", frame_id, scale)] = pix_coords\\n\\n outputs[(\\\"color\\\", frame_id, scale)] = F.grid_sample(\\n inputs[(\\\"color\\\", frame_id, source_scale)],\\n outputs[(\\\"sample\\\", frame_id, scale)],\\n padding_mode=\\\"border\\\")\\n\\n outputs[(\\\"color_identity\\\", frame_id, scale)] = \\\\\\n inputs[(\\\"color\\\", frame_id, source_scale)]\",\n \"def crop_images_to_galaxy(self):\\r\\n\\r\\n left, right, top, bottom = 0, 0, 0, 0\\r\\n \\r\\n for _, img in self.images():\\r\\n seg_img = load_gals.get_seg_img(img)\\r\\n gal_val = seg_img[int(seg_img.shape[0] / 2), int(seg_img.shape[1] / 2)]\\r\\n inds = np.argwhere(seg_img == gal_val)\\r\\n x_inds, y_inds = inds[:,1], inds[:,0]\\r\\n left += np.min(x_inds); right += np.max(x_inds)\\r\\n top += np.min(y_inds); bottom += np.max(y_inds)\\r\\n \\r\\n left /= float(self.num_wb); right /= float(self.num_wb)\\r\\n top /= float(self.num_wb); bottom /= float(self.num_wb)\\r\\n\\r\\n center_x, center_y = self.width / 2, self.height / 2\\r\\n size = int(max(center_x - left, right - center_x, center_y - top, bottom - center_y)) + 2\\r\\n left, right = int(center_x - size), int(center_x + size)\\r\\n top, bottom = int(center_y - size), int(center_y + size)\\r\\n\\r\\n # make sure the values found are valid\\r\\n try:\\r\\n assert top >= 0; assert left >= 0; \\r\\n assert bottom <= self.height; assert right <= self.width\\r\\n except AssertionError:\\r\\n size -= 2\\r\\n left, right = int(center_x - size), int(center_x + size)\\r\\n top, bottom = int(center_y - size), int(center_y + size)\\r\\n if top < 0 or left < 0 or bottom > self.height or right > self.width:\\r\\n raise CroppingError\\r\\n\\r\\n # crop the images\\r\\n for c in self.gal_dict.keys():\\r\\n self.gal_dict[c][0].data = self.gal_dict[c][0].data[top:bottom, left:right]\\r\\n \\r\\n return left, right, top, bottom\",\n \"def combine_pictures(images):\\n widths, heights = zip(*(i.size for i in images))\\n\\n total_width = sum(widths)\\n max_height = max(heights)\\n\\n new_im = Image.new('RGB', (total_width, max_height))\\n\\n x_offset = 0\\n for im in images:\\n new_im.paste(im, (x_offset, 0))\\n x_offset += im.size[0]\\n\\n new_im.save('test.jpg')\\n\\n return True\",\n \"def montage(images, w_sub, h_sub, step):\\n target = Image.new('RGB', (w_sub*step, h_sub*step))\\n left = 0\\n right = w_sub\\n for i in range(len(images)):\\n top=(i//step)*h_sub\\n target.paste(images[i], (left, top, right, top+h_sub))\\n if(i//step < (i+1)//step):#Check if this row is done\\n left = 0#Reset the position in a row\\n right = w_sub\\n else: #Next picture\\n left += w_sub\\n right += w_sub\\n quality_value = 100\\n return target\",\n \"def call(self, inputs):\\r\\n outputs = K.spatial_2d_padding(inputs,\\r\\n padding=self.padding,\\r\\n data_format=self.data_format)\\r\\n\\r\\n p00, p01 = self.padding[0][0], self.padding[0][1]\\r\\n p10, p11 = self.padding[1][0], self.padding[1][1]\\r\\n if self.data_format == \\\"channels_last\\\":\\r\\n\\r\\n row0 = K.concatenate([inputs[:, p00:0:-1, p10:0:-1, :],\\r\\n inputs[:, p00:0:-1, :, :],\\r\\n inputs[:, p00:0:-1, -2:-2-p11:-1, :]],\\r\\n axis=2)\\r\\n row1 = K.concatenate([inputs[:, :, p10:0:-1, :],\\r\\n inputs,\\r\\n inputs[:, :, -2:-2-p11:-1, :]],\\r\\n axis=2)\\r\\n row2 = K.concatenate([inputs[:, -2:-2-p01:-1, p10:0:-1, :],\\r\\n inputs[:, -2:-2-p01:-1, :, :],\\r\\n inputs[:, -2:-2-p01:-1, -2:-2-p11:-1, :]],\\r\\n axis=2)\\r\\n\\r\\n outputs = K.concatenate([row0, row1, row2], axis=1)\\r\\n\\r\\n else: # self.data_format == \\\"channels_first\\\"\\r\\n\\r\\n row0 = K.concatenate([inputs[:, :, p00:0:-1, p10:0:-1],\\r\\n inputs[:, :, p00:0:-1, :],\\r\\n inputs[:, :, p00:0:-1, -2:-2-p11:-1]],\\r\\n axis=3)\\r\\n row1 = K.concatenate([inputs[:, :, :, p10:0:-1],\\r\\n inputs,\\r\\n inputs[:, :, :, -2:-2-p11:-1]],\\r\\n axis=3)\\r\\n row2 = K.concatenate([inputs[:, :, -2:-2-p01:-1, p10:0:-1],\\r\\n inputs[:, :, -2:-2-p01:-1, :],\\r\\n inputs[:, :, -2:-2-p01:-1, -2:-2-p11:-1]],\\r\\n axis=3)\\r\\n\\r\\n outputs = K.concatenate([row0, row1, row2], axis=2)\\r\\n\\r\\n return outputs\",\n \"def _plot_imgs_and_ctrs_np(self, config) -> None:\\n imgs = config['imgs']\\n ctrs = config['ctrs']\\n orig_slices = config['slices']\\n plane = config['plane']\\n title = config['title']\\n draw_only_ctrs = config['draw_only_ctrs']\\n file_name_prefix = config['file_name_prefix']\\n labels = config['labels']\\n\\n create_folder(self._output_folder)\\n if plane != PlaneTypes.ALL: # Draw single plane\\n # This should plot a single image with all the contours overlayed\\n first_img_shape = imgs[0].shape\\n # Validate the size of the images\\n for c_img in imgs:\\n if c_img.shape != first_img_shape:\\n raise Exception('The shape of the images must be the same')\\n\\n slices = get_slices(orig_slices, imgs[0], plane)\\n for c_slice in slices:\\n draw_slice = should_display_slice(ctrs, c_slice, plane, draw_only_ctrs)\\n if draw_slice:\\n fig, ax = plt.subplots(1, len(imgs), squeeze=True, figsize=(8, 8))\\n for img_idx, c_img in enumerate(imgs):\\n img_slice = get_proper_plane(c_img, plane, c_slice)\\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\\n if len(imgs) > 1:\\n plot_slice(img_slice, ctrs_slice, ax[img_idx], labels)\\n else:\\n plot_slice(img_slice, ctrs_slice, ax, labels)\\n c_title = F'{title} {plane.value} {c_slice:04d}'\\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\\n plt.title(c_title, fontsize=20)\\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\\n else:\\n if len(imgs) != 1:\\n raise Exception('The number of image allowed for Plane type ALL must be 1')\\n # In this case it should plot 3 images, one for each plane. Here we force it to plot\\n # only the middle slice\\n c_img = imgs[0]\\n plt.subplots(1, 3, squeeze=True, figsize=(8 * 3, 8))\\n for id_plane, plane in enumerate([PlaneTypes.AXIAL, PlaneTypes.SAGITTAL, PlaneTypes.CORONAL]):\\n ax = plt.subplot(1, 3, id_plane + 1)\\n c_slice = get_slices(SliceMode.MIDDLE, c_img, plane)[0]\\n img_slice = get_proper_plane(c_img, plane, c_slice)\\n ctrs_slice = [get_proper_plane(np_ctr, plane, c_slice) for np_ctr in ctrs]\\n plot_slice(img_slice, ctrs_slice, ax, labels)\\n c_title = F'{title} ALL {c_slice:04d}'\\n plt.title(c_title, fontsize=20)\\n\\n file_name = F'{file_name_prefix}_{plane.value}_{c_slice:04d}'\\n pylab.savefig(join(self._output_folder, F'{file_name}.jpg'), bbox_inches='tight')\\n\\n self._close_figure()\",\n \"def augment():\\n print(\\\"augmenting......\\\")\\n path1 = '../trainp1/'\\n path2 = '../trainp2/'\\n # path of pair1 and pair2 similar to img & mask task for segmentation\\n p = Augmentor.Pipeline(path1) # pair1\\n p.ground_truth(path2) # pair2\\n p.rotate(probability=0.3, max_left_rotation=3, max_right_rotation=3) \\n p.flip_left_right(probability=0.2) \\n p.random_distortion(0.5, 2, 2, 2)\\n p.zoom(probability=0.5, min_factor=0.95, max_factor=1.05)\\n p.process()\",\n \"def visualize_reconstruction(maps_filename, timecourses_filename, data_filename, out_filename, mask_nib, hgap=20, vgap=20, nsamples=10):\\n\\n\\tmaps = np.load(maps_filename)\\n\\ttimecourses = np.load(timecourses_filename)\\n\\tsubject_data = np.load(data_filename)\\n\\n\\t(nframes, nvoxels) = subject_data.shape\\n\\n\\trecon = timecourses.dot(maps)\\n\\n\\tsamples = range(0, 1028, int(math.ceil(nframes / float(nsamples))))\\n\\n\\t# draw the maps and timecourses into temporary files\\n\\tdata_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\trecon_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(nsamples)]\\n\\n\\tfor i in range(nsamples):\\n\\t\\tplot_map(subject_data[samples[i],:], mask_nib, data_image_files[i])\\n\\t\\tplot_map(recon[samples[i],:], mask_nib, recon_image_files[i])\\n\\n\\tdata_images = [Image.open(fname) for fname in data_image_files]\\n\\trecon_images = [Image.open(fname) for fname in recon_image_files]\\n\\n\\tim_width = data_images[0].size[0]\\n\\tim_height = data_images[0].size[1]\\n\\n\\tresult_width = 2*im_width + hgap \\n\\tresult_height = nsamples * (im_height + vgap)\\n\\n\\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\\n\\ty = 0\\n\\tfor (recon_image, data_image) in zip(recon_images, data_images):\\n\\t\\tresult.paste(im=recon_image, box=(0, y))\\n\\t\\tresult.paste(im=data_image, box=(im_width+hgap, y))\\n\\t\\ty += im_height + vgap\\n\\n\\tresult.save(out_filename)\\n\\n\\tfor i in range(nsamples):\\n\\t\\tos.remove(data_image_files[i])\\n\\t\\tos.remove(recon_image_files[i])\",\n \"def load_slices(self, dataset_dir, n_images, n_patches, channels = [\\\"base\\\"]):\\n \\n # add classes to be trained on\\n \\n self.add_class(\\\"slices\\\", 1, \\\"tissue\\\")\\n self.add_class(\\\"slices\\\", 2, \\\"mag\\\")\\n \\n # collect image list and initialize counter\\n \\n image_list = os.listdir(dataset_dir)\\n image_counter = 0\\n patch_counter = 0\\n \\n # cycle over images and save patches to database.\\n \\n for i in range(n_images):\\n \\n image_path = os.path.join(dataset_dir,image_list[i])\\n patch_list = os.listdir(image_path)\\n \\n print(f\\\"processing: image {i}\\\") \\n \\n for j in range(n_patches):\\n \\n patch_path = os.path.join(image_path, patch_list[j])\\n \\n patch_image_path = os.path.join(patch_path,\\\"images\\\")\\n \\n file_list = os.listdir(patch_image_path)\\n \\n image_file_path = os.path.join(patch_image_path,file_list[0])\\n \\n image = skimage.io.imread(image_file_path)\\n \\n height, width = image.shape\\n \\n self.add_image(\\n \\\"slices\\\",\\n image_id = patch_counter,\\n path = patch_path,\\n width = width, height = height,\\n channels = channels,\\n )\\n patch_counter += 1\",\n \"def data_assemble(self, x,y, r_cut, add_mask=5, pick_choice=False):\\n #segmentation components\\n obj_masks,center_mask_info, segments_deblend_list = self._seg_image(x, y, r_cut=r_cut)\\n data_masks_center, _, xcenter, ycenter, c_index = center_mask_info\\n image = self.cut_image(x,y,r_cut)\\n self.raw_image = image\\n src_mask = np.zeros_like(image)\\n lens_mask = np.zeros_like(image)\\n plu_mask = np.zeros_like(image)\\n lenslight_mask_index = []\\n if self.segmap is not None and self.interaction:\\n segmap=self.segmap[0].data\\n segdata = segmap[x - r_cut:x + r_cut + 1, y - r_cut:y + r_cut + 1]\\n plt.imshow(segdata, origin='lower')\\n nlabel = np.unique(segdata)\\n for i in range(nlabel.shape[0] - 1):\\n ax = (int((np.where(segdata == nlabel[i + 1])[0].max() - np.where(segdata == nlabel[i + 1])[0].min()) / 2 +\\n np.where(segdata == nlabel[i + 1])[0].min()))\\n ay = (int((np.where(segdata == nlabel[i + 1])[1].max() - np.where(segdata == nlabel[i + 1])[1].min()) / 3 +\\n np.where(segdata == nlabel[i + 1])[1].min()))\\n plt.text(ay, ax, repr(nlabel[i + 1]), color='r', fontsize=15)\\n plt.title('Input segmentation map')\\n plt.show()\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + segdata*(segdata==i*1)\\n # lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + segdata*(segdata==i*1))\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + segdata*(segdata==i*1))\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n\\n\\n\\n if self.segmap is None and self.interaction:\\n self.plot_segmentation(image, segments_deblend_list, xcenter, ycenter, c_index)\\n #source light\\n if pick_choice:\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + obj_masks[i]\\n #lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + obj_masks[i])\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + obj_masks[i])\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n else:\\n src_mask = data_masks_center\\n\\n\\n #adding pixels around the selected masks\\n selem = np.ones((add_mask, add_mask))\\n src_mask = ndimage.binary_dilation(src_mask.astype(np.bool), selem)\\n plu_mask_out = ndimage.binary_dilation(plu_mask.astype(np.bool), selem)\\n plu_mask_out = (plu_mask_out - 1)*-1\\n\\n #select source region to fit, or to use whole observation to fit\\n ##1.select source region to fit\\n snr = self.snr\\n source_mask = image * src_mask\\n #create background image for picked\\n if self.background_rms is None:\\n _, _, std = sigma_clipped_stats(image, sigma=snr, mask=source_mask)\\n tshape = image.shape\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n else:\\n tshape = image.shape\\n std=np.mean(self.background_rms)\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n\\n no_source_mask = (src_mask * -1 + 1) * img_bkg\\n picked_data = source_mask + no_source_mask\\n\\n ##2.use whole observation to fit while mask out the contamination\\n maskedimg = image * plu_mask_out\\n\\n ##orginize the output 'kwargs_data'\\n kwargs_data = {}\\n if pick_choice:\\n kwargs_data['image_data'] = picked_data#select source region to fit\\n else:\\n kwargs_data['image_data'] = maskedimg#use whole observation to fit while mask out the contamination\\n\\n if self.background_rms is None:\\n kwargs_data['background_rms'] = std\\n self.background_rms = std\\n else:\\n kwargs_data['background_rms'] = np.mean(self.background_rms)\\n kwargs_data['exposure_time'] = self.exp_time\\n kwargs_data['transform_pix2angle'] = np.array([[1, 0], [0, 1]]) * self.deltaPix\\n ra_at_xy_0 = (y - r_cut) * self.deltaPix # (ra,dec) is (y_img,x_img)\\n dec_at_xy_0 = (x - r_cut) * self.deltaPix\\n kwargs_data['ra_at_xy_0'] = ra_at_xy_0\\n kwargs_data['dec_at_xy_0'] = dec_at_xy_0\\n\\n #coordinate of the lens light\\n xlenlight, ylenlight = [], []\\n if lenslight_mask_index !=[]:\\n for i in lenslight_mask_index:\\n xlenlight.append(ra_at_xy_0 + int(xcenter[i]) * self.deltaPix )\\n ylenlight.append(dec_at_xy_0 + int(ycenter[i])* self.deltaPix )\\n\\n #for output\\n self.data = kwargs_data['image_data']\\n self.kwargs_data = kwargs_data\\n self.data_mask = src_mask\\n self.lens_mask = lens_mask\\n self.plu_mask = plu_mask_out\\n self.obj_masks = obj_masks\\n imageData = ImageData(**kwargs_data)\\n self.imageData = imageData\\n kwargs_seg = [segments_deblend_list, xcenter, ycenter, c_index]\\n\\n return kwargs_data, kwargs_seg, [xlenlight, ylenlight]\",\n \"def _stack_images_masks_flair(self, pth, patient_id, img_cnt):\\n\\n img_stack, msk_stack = [], []\\n img_file_name = \\\"{patient}_{id}.tif\\\"\\n msk_file_name = \\\"{patient}_{id}_mask.tif\\\"\\n for i in range(1, img_cnt + 1):\\n img = cv2.imread(os.path.join(pth, img_file_name.format(patient=patient_id, id=i)))\\n mask = cv2.imread(os.path.join(pth, msk_file_name.format(patient=patient_id, id=i)))\\n img_stack.append(img)\\n msk_stack.append(mask)\\n img_stack, msk_stack = np.array(img_stack), np.array(msk_stack)\\n return img_stack, msk_stack\",\n \"def img_to_slices(img):\\n res = []\\n\\n for i, slice_img in enumerate(img):\\n res.append(slice_img)\\n return res\",\n \"def merge_images(images, axis=0):\\n assert axis in [0, 1]\\n total_len = sum(map(lambda i: i.size[axis], images))\\n if axis == 0:\\n new_shape = (total_len, images[0].size[1])\\n step = images[0].size[0]\\n else:\\n new_shape = (images[0].size[0], total_len)\\n step = images[0].size[1]\\n\\n canvas = Image.new('RGB', new_shape)\\n\\n shift = 0\\n for image in images:\\n if axis == 0:\\n canvas.paste(image, (shift, 0))\\n else:\\n canvas.paste(image, (0, shift))\\n \\n shift += image.size[axis]\\n\\n return canvas\",\n \"def concat_images(imga, imgb, xoffset=0, yoffset=0, direction='horizontal',\\n ontop=True, adjust_z=False, center_offset=True):\\n if direction == 'horizontal':\\n max_dim = np.maximum.reduce([imga.shape, imgb.shape])\\n\\n center_a = np.array(np.divide(imga.shape, 2), dtype=int)\\n center_b = np.array(np.divide(imgb.shape, 2), dtype=int)\\n offset = (abs(yoffset), abs(xoffset))\\n\\n if center_offset:\\n new_offset = np.subtract(center_a, np.add(center_b, offset))\\n\\n if (max_dim == imgb.shape).all():\\n tmp = np.copy(imgb)\\n imgb = np.copy(imga)\\n imga = np.copy(tmp)\\n ontop = toggle(ontop)\\n xoffset *= -1\\n yoffset *= -1\\n\\n # elif not (max_dim == imga.shape).all():\\n # for i, m in enumerate(max_dim):\\n # if m not in imga.shape:\\n # new_offset[i] = center_a[i] - (center_b[i] + offset[i])\\n # else:\\n # new_offset[i] = center_a[i] + offset[i] - center_b[i]\\n\\n new_offset[new_offset > 0] = 0\\n center_new = np.array(np.divide(max_dim, 2), dtype=int)\\n new_img = np.full(np.add(max_dim, np.abs(new_offset)), np.nan)\\n\\n Sa0 = slice(int(center_new[0] - imga.shape[0]/2 + 0.5),\\n int(center_new[0] + imga.shape[0]/2 + 0.5))\\n Sa1 = slice(int(center_new[1] - imga.shape[1]/2 + 0.5),\\n int(center_new[1] + imga.shape[1]/2 + 0.5))\\n Sb0 = slice(int(center_new[0] + abs(yoffset) - imgb.shape[0]/2 + 0.5),\\n int(center_new[0] + abs(yoffset) + imgb.shape[0]/2 + 0.5))\\n Sb1 = slice(int(center_new[1] + abs(xoffset) - imgb.shape[1]/2 + 0.5),\\n int(center_new[1] + abs(xoffset) + imgb.shape[1]/2 + 0.5))\\n\\n xdir = np.sign(xoffset)\\n ydir = np.sign(yoffset)\\n\\n if ydir == 0:\\n ydir = 1\\n if xdir == 0:\\n xdir = 1\\n\\n imga = imga[::ydir, ::xdir]\\n imgb = imgb[::ydir, ::xdir]\\n\\n if adjust_z:\\n top_img = 1 * new_img\\n top_img[Sa0, Sa1] = imga\\n top_img[Sb0, Sb1] = imgb\\n low_img = 1 * new_img\\n low_img[Sb0, Sb1] = imgb\\n low_img[Sa0, Sa1] = imga\\n\\n diff = top_img - low_img\\n m = np.nanmean(diff)\\n s = np.nanstd(diff)\\n mask = np.abs(diff) < m + s\\n diff[mask] = np.nan\\n add = np.nanmean(diff)\\n\\n print(add)\\n\\n imgb -= add\\n\\n if ontop:\\n new_img[Sa0, Sa1] = imga\\n new_img[Sb0, Sb1] = imgb\\n else:\\n new_img[Sb0, Sb1] = imgb\\n new_img[Sa0, Sa1] = imga\\n\\n return new_img[::ydir, ::xdir]\",\n \"def mask_the_images(working_path,set_name):\\n\\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\\n out_images = [] #final set of images for all patients\\n for fname in file_list:\\n out_images_per_patient = []\\n print (\\\"working on file \\\", fname)\\n imgs_to_process = np.load(fname.replace(\\\"lungmask\\\",\\\"images\\\")) # images of one patient\\n masks = np.load(fname)\\n for i in range(len(imgs_to_process)):\\n mask = masks[i]\\n img = imgs_to_process[i]\\n new_size = [512,512] # we're scaling back up to the original size of the image\\n img= mask*img # apply lung mask\\n #\\n # renormalizing the masked image (in the mask region)\\n #\\n new_mean = np.mean(img[mask>0])\\n new_std = np.std(img[mask>0])\\n #\\n # Pulling the background color up to the lower end\\n # of the pixel range for the lungs\\n #\\n old_min = np.min(img) # background color\\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\\n img = img-new_mean\\n img = img/new_std\\n #make image bounding box (min row, min col, max row, max col)\\n labels = measure.label(mask)\\n regions = measure.regionprops(labels)\\n #\\n # Finding the global min and max row over all regions\\n #\\n min_row = 512\\n max_row = 0\\n min_col = 512\\n max_col = 0\\n for prop in regions:\\n B = prop.bbox\\n if min_row > B[0]:\\n min_row = B[0]\\n if min_col > B[1]:\\n min_col = B[1]\\n if max_row < B[2]:\\n max_row = B[2]\\n if max_col < B[3]:\\n max_col = B[3]\\n width = max_col-min_col\\n height = max_row - min_row\\n if width > height:\\n max_row=min_row+width\\n else:\\n max_col = min_col+height\\n #\\n # cropping the image down to the bounding box for all regions\\n # (there's probably an skimage command that can do this in one line)\\n #\\n img = img[min_row:max_row,min_col:max_col]\\n mask = mask[min_row:max_row,min_col:max_col]\\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\\n pass\\n else:\\n # moving range to -1 to 1 to accomodate the resize function\\n mean = np.mean(img)\\n img = img - mean\\n min = np.min(img)\\n max = np.max(img)\\n img = img/(max-min)\\n new_img = resize(img,[512,512], mode='constant')\\n out_images_per_patient.append(new_img)\\n\\n id = re.sub(r'.*_images_(.*)\\\\.npy',r'\\\\1',fname)\\n patient_images_and_id = (out_images_per_patient,id)\\n out_images.append(patient_images_and_id)\\n print (\\\"Delete files: {} \\\\n\\\\t {} \\\".format(fname,re.sub(\\\"lungmask\\\",\\\"images\\\",fname)))\\n os.remove(fname)\\n os.remove(fname.replace(\\\"images\\\",\\\"lungmask\\\")) # images of one patient\\n\\n\\n np.save(working_path+\\\"{}Images.npy\\\".format(set_name),out_images)\",\n \"def get_pca_images(self):\\n mean_vector, principal_components, variances = self.pca()\\n shape = self.image_shape + (principal_components.shape[1],)\\n principal_component_images = principal_components.reshape(shape)\\n principal_component_images = np.moveaxis(\\n principal_component_images, -1, 0)\\n mean_beam = mean_vector.reshape(self.image_shape)\\n mask = self.mask.reshape(self.image_shape)\\n return mean_beam, mask, principal_component_images, variances\",\n \"def merge(images, size, c_dim):\\n h, w = images.shape[1], images.shape[2]\\n \\n img = np.zeros((h*size[0], w*size[1], c_dim))\\n for idx, image in enumerate(images):\\n i = idx % size[1]\\n j = idx // size[1]\\n img[j * h : j * h + h,i * w : i * w + w, :] = image\\n #cv2.imshow(\\\"srimg\\\",img)\\n #cv2.waitKey(0)\\n \\n return img\",\n \"def process_im_multipe_crops_ordered_for_network(im_whole, boxes, w, h, preprocessor):\\n\\n\\tbox = boxes[-1,:]\\n\\n\\toffset_x1, offset_y1 = 0, 0\\n\\tim_padded = im_whole\\n\\n\\tif box[0] < 1 or box[1] < 1 or box[2] > im_whole.width or box[3] > im_whole.height:\\n\\t\\toffset_x1 = max(1-box[0], 0)\\n\\t\\toffset_y1 = max(1-box[1], 0)\\n\\t\\toffset_x2 = max(box[2]-im_whole.width, 0)\\n\\t\\toffset_y2 = max(box[3]-im_whole.height, 0)\\n\\n\\t\\tim_padded = Image.new('RGB', (int(im_whole.width+offset_x1+offset_x2), int(im_whole.height+offset_y1+offset_y2)))\\n\\t\\tim_padded.paste(im_whole,(int(offset_x1), int(offset_y1))) # (x,y)\\n\\n\\n\\tprobes_tensor = torch.FloatTensor(boxes.shape[0],3,h,w)\\n\\n\\tfor i in range(boxes.shape[0]):\\n\\t\\tim_crop = im_padded.crop((boxes[i,0]-1+offset_x1, boxes[i,1]-1+offset_y1, boxes[i,2]-1+offset_x1, boxes[i,3]-1+offset_y1))\\n\\t\\tprobes_tensor[i,:,:,:] = preprocessor(im_crop.resize((w,h))).clone()\\n\\n\\n\\treturn probes_tensor\",\n \"def input_setup_PAN(sess,config,data_dir,index=0):\\n if config.is_train:\\n data = prepare_data(sess, dataset=data_dir)\\n\\n sub_input_sequence = []\\n padding = 0 \\n if config.is_train:\\n for i in xrange(len(data)):\\n input_=(imread(data[i])-127.5)/127.5\\n\\n if len(input_.shape) == 3:\\n h, w, _ = input_.shape\\n else:\\n h, w = input_.shape\\n for x in range(0, h-config.image_size_PAN+1, config.stride_PAN):\\n for y in range(0, w-config.image_size_PAN+1, config.stride_PAN):\\n sub_input = input_[x:x+config.image_size_PAN, y:y+config.image_size_PAN] \\n # Make channel value\\n if data_dir == \\\"Train\\\":\\n sub_input=cv2.resize(sub_input, (config.image_size_PAN/4,config.image_size_PAN/4),interpolation=cv2.INTER_CUBIC)\\n sub_input = sub_input.reshape([config.image_size_PAN/4, config.image_size_PAN/4, 1])\\n print('error')\\n else:\\n sub_input = sub_input.reshape([config.image_size_PAN, config.image_size_PAN, 1]) \\n sub_input_sequence.append(sub_input)\\n arrdata = np.asarray(sub_input_sequence) \\n print(arrdata.shape)\\n make_data(sess, arrdata, data_dir)\\n\\n\\n if not config.is_train:\\n print(nx,ny)\\n print(h_real,w_real)\\n return nx, ny,h_real,w_real\",\n \"def show_slices(slices,clims=[0.0,0.0]):\\n fig, axes = plt.subplots(1,len(slices))\\n for i, slice in enumerate(slices):\\n if clims==[0.0,0.0]:\\n axes[i].imshow(slice.T, cmap='gray', origin=\\\"lower\\\")\\n else:\\n axes[i].imshow(slice.T, cmap='gray', origin=\\\"lower\\\", clim=clims)\",\n \"def _generate_source_slices(self):\\n\\n self._logger.info(\\\"Performing source slice generation.\\\")\\n\\n # The array collecting all the individual command into a commands\\n # batch.\\n commands = []\\n\\n # Iterate over all the slices and prepare aproperiate slice preparation\\n # commands.\\n for slice_number in self.options.slice_range:\\n command = pos_wrappers.alignment_preprocessor_wrapper(\\n input_image=self.f['raw_image'](idx=slice_number),\\n grayscale_output_image=self.f['src_gray'](idx=slice_number),\\n color_output_image=self.f['src_color'](idx=slice_number),\\n registration_roi=self.options.registrationROI,\\n registration_resize=self.options.registrationResize,\\n registration_color=self.options.registrationColor,\\n median_filter_radius=self.options.medianFilterRadius,\\n invert_grayscale=self.options.invertMultichannel,\\n invert_multichannel=self.options.invertMultichannel)\\n commands.append(copy.deepcopy(command))\\n\\n self._logger.info(\\\"Executing the source slice generation commands.\\\")\\n # Execute the commands in a batch.\\n self.execute(commands)\\n\\n self._logger.info(\\\"Source slice generation is completed.\\\")\",\n \"def process_patients(self):\\n if not os.path.exists(self.out_dir):\\n os.makedirs(self.out_dir)\\n\\n for patient in os.listdir(self.root_dir):\\n if \\\".csv\\\" in patient or \\\".md\\\" in patient:\\n continue\\n patient_pth = os.path.join(self.root_dir, patient)\\n out_patient_pth = os.path.join(self.out_dir, patient)\\n num_imgs = len(os.listdir(patient_pth)) // 2 # Half the length to exclude mask counts\\n img_stack, msk_stack = self._stack_images_masks_flair(patient_pth, patient, num_imgs)\\n if not os.path.exists(out_patient_pth):\\n os.mkdir(out_patient_pth)\\n self._make_slices(img_stack, msk_stack, patient, out_patient_pth)\",\n \"def copy_cityscapes(src_dir: Path, datasets: Dict[str, Path], subsets: List[str], dst_dir: Path):\\n assert 'l_img' in datasets\\n\\n print(\\\"Copying\\\", datasets.keys(), \\\"from\\\", src_dir, \\\"to\\\", dst_dir)\\n\\n regex_map = {\\n 'l_img' : ['leftImg8bit', 'leftImg8bit'],\\n 'r_img' : ['leftImg8bit', 'rightImg8bit'],\\n 'seg' : ['leftImg8bit', 'gtFine_labelIds'],\\n 'inst' : ['leftImg8bit', 'gtFine_instanceIds'],\\n 'bbox' : ['leftImg8bit.png', 'gtFine_bbox.json'],\\n 'disp' : ['leftImg8bit', 'disparity'],\\n 'l_seq' : ['leftImg8bit', 'leftImg8bit'],\\n 'r_seq' : ['leftImg8bit', 'rightImg8bit'],\\n 'cam' : ['leftImg8bit.png', 'camera.json'],\\n 'pose' : ['leftImg8bit.png', 'vehicle.json']\\n }\\n\\n for subset in subsets:\\n for dirpath, _, filenames in os.walk(os.path.join(src_dir, datasets['l_img'], subset)):\\n for filename in filenames:\\n if not filename.endswith(IMG_EXT):\\n continue\\n\\n l_imgpath = os.path.join(dirpath, filename)\\n foldername = os.path.basename(os.path.dirname(l_imgpath))\\n\\n for datatype, directory in datasets.items():\\n if datatype in ['l_seq', 'r_seq']:\\n frame_n = int(re.split(\\\"_\\\", filename)[2])\\n img_name = filename.replace(\\n str(frame_n).zfill(6)+\\\"_\\\"+regex_map[datatype][0],\\n str(frame_n+1).zfill(6)+\\\"_\\\"+regex_map[datatype][1])\\n else:\\n img_name = filename.replace(\\n regex_map[datatype][0], regex_map[datatype][1])\\n\\n src_path = os.path.join(src_dir, directory, subset, foldername, img_name)\\n dst_path = os.path.join(dst_dir, directory, subset, foldername, img_name)\\n\\n if not os.path.isfile(src_path):\\n print(\\\"Error finding corresponding data to \\\", l_imgpath)\\n continue\\n if os.path.isfile(dst_path):\\n continue\\n\\n os.makedirs(os.path.dirname(dst_path), exist_ok=True)\\n copy(src_path, dst_path)\\n\\n print(\\\"success copying: \\\", datasets.keys())\",\n \"def data_augmentation(image_data, mask_data, rotate=False, vertical_flip=False, horizontal_flip=False):\\n aug_images = []\\n aug_masks = []\\n\\n for _ in range(len(image_data)):\\n if rotate:\\n rotation = A.RandomRotate90(p=1)\\n rotated_data = rotation(image=image_data[_], mask=mask_data[_])\\n rotated_image = rotated_data['image']\\n rotated_mask = rotated_data['mask']\\n aug_images.append(rotated_image)\\n aug_masks.append(rotated_mask)\\n\\n if vertical_flip:\\n flip_v = A.VerticalFlip(p=1)\\n vertical_data = flip_v(image=image_data[_], mask=mask_data[_])\\n vertical_image = vertical_data['image']\\n vertical_mask = vertical_data['mask']\\n aug_images.append(vertical_image)\\n aug_masks.append(vertical_mask)\\n\\n if horizontal_flip:\\n flip_h = A.HorizontalFlip(p=1)\\n horizontal_data = flip_h(image=image_data[_], mask=mask_data[_])\\n horizontal_image = horizontal_data['image']\\n horizontal_mask = horizontal_data['mask']\\n aug_images.append(horizontal_image)\\n aug_masks.append(horizontal_mask)\\n\\n nd_images = make_ndarray(aug_images)\\n nd_masks = make_ndarray(aug_masks)\\n #nd_images = np.zeros((len(aug_images), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.float32)\\n #nd_masks = np.zeros((len(aug_masks), IMG_HEIGHT, IMG_WIDTH), dtype=np.float32)\\n\\n #for _ in range(len(aug_images)): # Load into ndarray\\n # nd_images[_] = aug_images[_]\\n # nd_masks[_] = aug_masks[_] # load mask without channel variable\\n\\n return nd_images, nd_masks\",\n \"def load_datasets(filepath, sample_list, label_list, mark, a4c_or_a2c, m):\\n # here can adjust n to apply your datasets\\n if mark:\\n n = 4000\\n else:\\n n = 4000\\n dst_pair1 = np.zeros(shape=(n, m, m, 1), dtype=np.float32)\\n dst_pair2 = np.zeros(shape=(n, m, m, 1), dtype=np.float32)\\n dst_label = np.zeros(shape=(n,), dtype=np.int32)\\n k = 0\\n label_list_copy = copy.deepcopy(label_list)\\n for number in range(len(sample_list)):\\n label = label_list_copy[sample_list[number]-1] # o--->up 1--->down\\n start_mark = label.pop()\\n for i in (label):\\n position = label.index(i)\\n if position == len(label)-1:\\n break\\n j = label[position+1]\\n for t in range(i,j):\\n # load imgs: from number i to number j-1-->pair1\\n # i+1 j-->pair2\\n img_p1 = cv2.imread(filepath+\\\"Patient\\\"+(\\\"000\\\"+str(sample_list[number]))[-4:] +\\n \\\"\\\\\\\\a\\\"+str(a4c_or_a2c)+\\\"c\\\\\\\\\\\"+str(t)+'.png', 0)\\n img_p2 = cv2.imread(filepath+\\\"Patient\\\"+(\\\"000\\\"+str(sample_list[number]))[-4:] +\\n \\\"\\\\\\\\a\\\"+str(a4c_or_a2c)+\\\"c\\\\\\\\\\\"+str(t+1)+'.png', 0)\\n # cut and unsamping use cv2.resize\\n # original 600*800--cut-->512*512--->resize by cv2 ---> m*m\\n dst_pair1[k, :, :, 0] = cv2.resize(img_p1[80:592, 176:688].reshape(512, -1, 1), (m, m))/255.0\\n dst_pair2[k, :, :, 0] = cv2.resize(img_p2[80:592, 176:688].reshape(512, -1, 1), (m, m))/255.0\\n if start_mark == 0: # up\\n dst_label[k] = 0 \\n else:\\n dst_label[k] = 1 \\n k += 1\\n if start_mark == 0:\\n start_mark = 1\\n else:\\n start_mark = 0\\n if mark == 1:\\n pathname = 'train'\\n elif mark == 0:\\n pathname = 'test'\\n else:\\n pathname = \\\"val\\\"\\n # save the imgs for augmentation before training.\\n os.mkdir('../'+pathname+'p1/') \\n os.mkdir('../'+pathname+'p2/')\\n K = 0\\n for i in (dst_pair1[:k]):\\n preprocessing.image.save_img('../'+pathname+'p1/'+str(K)+'.png', i)\\n K += 1\\n K = 0\\n for i in (dst_pair2[:k]):\\n preprocessing.image.save_img('../'+pathname+'p2/'+str(K)+'.png', i)\\n K += 1\\n return dst_pair1[:k], dst_pair2[:k], dst_label[:k]\",\n \"def load_source_png_images(self, num_slice):\\n if self.subject is None:\\n print Console.WARNING + 'You need to specify a subject first' + Console.ENDC\\n return\\n data = [] \\n for l in self.locations.LABELS:\\n slice_file = self.locations.SOURCE_PNG % (l, num_slice)\\n \\n #print 'Loading Input Image \\\\t\\\\t%s'%slice_file \\n slice_data = misc.imread(slice_file) \\n data.append(slice_data)\\n \\n return data #images in the same order as labels\",\n \"def setup(self, bottom, top): \\n conv_rois = bottom[1].data\\n n_roi, c, h, w = conv_rois.shape\\n #print 'MaskPooling, conv_rois.shape: {}'.format(conv_rois.shape)\\n top[0].reshape(n_roi, c, h, w)\",\n \"def problem2():\\n \\n pts_array, feats_array = p2.load_pts_features('data/pts_feats.npz')\\n\\n # points and features for image1 and image2\\n pts1, pts2 = pts_array\\n fts1, fts2 = feats_array\\n\\n # Loading images\\n img1 = Image.open('data/img1.png')\\n img2 = Image.open('data/img2.png')\\n\\n im1 = np.array(img1)\\n im2 = np.array(img2)\\n\\n plt.figure(1)\\n plt.subplot(1, 2, 1)\\n plt.imshow(im1)\\n plt.plot(pts1[:, 0], pts1[:, 1], 'ro', markersize=1.3)\\n plt.subplot(1, 2, 2)\\n plt.imshow(im2)\\n plt.plot(pts2[:, 0], pts2[:, 1], 'ro', markersize=1.3)\\n\\n # display algined image\\n H, ix1, ix2 = p2.final_homography(pts1, pts2, feats_array[0],\\n feats_array[1])\\n\\n pts1 = pts1[ix1]\\n pts2 = pts2[ix2]\\n\\n plt.figure(2)\\n plt.subplot(1, 3, 1).set_title('Image 1')\\n plt.imshow(im1)\\n plt.plot(pts1[:, 0],\\n pts1[:, 1],\\n 'ro',\\n markersize=2.3,\\n markerfacecolor='none')\\n plt.subplot(1, 3, 2).set_title('Image 2')\\n plt.imshow(im2)\\n plt.plot(pts2[:, 0],\\n pts2[:, 1],\\n 'ro',\\n markersize=2.3,\\n markerfacecolor='none')\\n plt.subplot(1, 3, 3).set_title('Algined image 1')\\n\\n H_inv = np.linalg.inv(H)\\n H_inv /= H_inv[2, 2]\\n im3 = img1.transform(size=(im1.shape[1], im1.shape[0]),\\n method=Image.PERSPECTIVE,\\n data=H_inv.ravel(),\\n resample=Image.BICUBIC)\\n\\n plt.show()\",\n \"def _merge_many_MNIST(images, shift_pixels, rotation_range, use_shifting=True, rotate=True):\\n assert shift_pixels <= 8, \\\"Each MNIST image can be shifted a maximum of 8 pixels, since the input images are 28x28 and the output images are 36x36. You are requesting a shift of \\\" + (shift_pixels) + \\\" pixels.\\\"\\n\\n if rotate:\\n for i in range(0, images.__len__()):\\n rot_deg = randint(rotation_range[0], rotation_range[1])\\n images[i] = ndimage.rotate(images[i], rot_deg, reshape=False)\\n\\n if use_shifting:\\n canvas = np.zeros([36, 36])\\n\\n for i in range(0, images.__len__()):\\n shift_pixels = randint(0, shift_pixels)\\n print(shift_pixels)\\n canvas[shift_pixels:shift_pixels + 28, shift_pixels:shift_pixels + 28] += images[i]\\n canvas = np.clip(canvas, 0, 1)\\n else:\\n canvas = np.zeros([36, 36])\\n\\n for i in range(0, images.__len__()):\\n canvas[:28, :28] += images[i]\\n canvas = np.clip(canvas, 0, 1)\\n\\n return canvas\",\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 pad_images(_input_image_paths : list[str], _output_image_dir : str, \\\\\\n _pad_colour : tuple[int,int,int]) -> None:\\n for image in _input_image_paths:\\n with Image.open(image) as image_object:\\n\\n #Rotate the image based on the EXIF data's orientation tag.\\n #Ensures that images taller than they are wide are kept as such when padding\\n image_object = PIL.ImageOps.exif_transpose(image_object)\\n\\n old_x,old_y = image_object.size\\n bigger_dimension = max(old_x,old_y)\\n\\n #Figure out how much extra should be added to each of the four sides\\n x_additive = y_additive = 0\\n if old_x > old_y:\\n y_additive = (old_x - old_y)//2\\n\\n elif old_y > old_x:\\n x_additive = (old_y - old_x)//2\\n\\n #Create a new, larger image with the requested padding colour,\\n # and then paste the original image overtop in the correct position\\n new_canvas = Image.new(\\\"RGB\\\", (bigger_dimension,bigger_dimension), _pad_colour)\\n new_canvas.paste(image_object, (x_additive, y_additive))\\n new_canvas.save(_output_image_dir + os.path.basename(image))\",\n \"def get_crops(x_train, y_train, offset=4):\\n\\ttopleft = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(4 - offset, offset, offset, 4 - offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\ttopright = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(4 - offset, 4 - offset, offset, offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tbotleft = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(offset, offset, 4 - offset, 4 - offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tbotright = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(offset, 4 - offset, 4 - offset, offset)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\tcenter = iaa.Sequential([\\n\\t\\tiaa.Crop(px=(2, 2, 2, 2)),\\n\\t\\tiaa.Affine(scale=1.166666667)\\n\\t])\\n\\taugs = [topleft, topright, botleft, botright, center]\\n\\n\\taug_imgs = []\\n\\tfor aug in tqdm(augs):\\n\\t\\taug_imgs.append(aug.augment_images(x_train * 255))\\n\\n\\taug_x_train = [item for sublist in aug_imgs for item in sublist]\\n\\taug_y_train = y_train * 5\\n\\n\\treturn aug_x_train, aug_y_train\",\n \"def _reslice(self):\\n\\n # Reslicing grayscale images. Reslicing multichannel images. Collect\\n # all reslicing commands into an array and then execute the batch.\\n self._logger.info(\\\"Reslicing grayscale images.\\\")\\n commands = []\\n for slice_index in self.options.slice_range:\\n commands.append(self._reslice_grayscale(slice_index))\\n self.execute(commands)\\n\\n # Reslicing multichannel images. Again, collect all reslicing commands\\n # into an array and then execute the batch.\\n self._logger.info(\\\"Reslicing multichannel images.\\\")\\n commands = []\\n for slice_index in self.options.slice_range:\\n commands.append(self._reslice_color(slice_index))\\n self.execute(commands)\\n\\n # Yeap, it's done.\\n self._logger.info(\\\"Finished reslicing.\\\")\",\n \"def _build_augmentation_map(self, images):\\n aug_map = {}\\n img_shape = (images[0].x.shape[0], images[0].x.shape[1])\\n\\n vert_modes = [Crop.TOP, Crop.CENTER, Crop.BOTTOM]\\n horiz_modes = [Crop.LEFT, Crop.CENTER, Crop.RIGHT]\\n crop_modes = flatten_list([[CropMode(vert, horiz) for horiz in horiz_modes] for vert in vert_modes])\\n\\n labels_series = pd.Series([i.y for i in images])\\n labels_distribution = labels_series.value_counts(normalize=True).sort_values()\\n\\n min_distribution = labels_distribution.iloc[0] * len(crop_modes)\\n\\n for label, distribution in labels_distribution.iteritems():\\n aug_num = math.ceil(min_distribution / distribution)\\n #additional augmentation functions can be added here:\\n aug_map[label] = [self._build_crop_fn(img_shape, crop_modes[:aug_num])]\\n \\n return aug_map\",\n \"def __call__(self, results):\\n self._pad_img(results)\\n self._pad_masks(results)\\n self._pad_seg(results)\\n return results\",\n \"def long_slice(image_path, out_name, outdir, slice_size, net):\\n img = Image.open(image_path)\\n imgout = Image.open(image_path)\\n orw, orh = img.size\\n width, height = img.size\\n slicesh = int(math.ceil(height/slice_size))\\n slicesw = int(math.ceil(width/slice_size))\\n img = img.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\\n imgout = imgout.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\\n orw, orh = imgout.size\\n width, height = img.size\\n print(img.size)\\n r = 1\\n draw = ImageDraw.Draw(imgout)\\n\\n flag_continue = True\\n while flag_continue:\\n if os.path.exists(\\\"./testsliceimage/list.txt\\\"):\\n os.remove(\\\"./testsliceimage/list.txt\\\")\\n file = open(\\\"./testsliceimage/list.txt\\\", \\\"w+\\\")\\n for sliceh in range(slicesh*step):\\n for slicew in range(slicesw*step):\\n #set the bounding box! The important bit\\n bbox = (int(slicew*slice_size/step), int(sliceh*slice_size/step), int(slicew*slice_size/step)+slice_size, int(sliceh*slice_size/step)+slice_size)\\n working_slice = img.crop(bbox)\\n\\n working_slice.save(os.path.join(outdir, \\\"slice_\\\" + str(height) + \\\"_\\\" + str(width) + \\\"_\\\" + out_name + \\\"_\\\" + str(sliceh) + \\\"_\\\" + str(slicew) +\\\".png\\\"))\\n file.write(\\\"slice_\\\" + str(height) + \\\"_\\\" + str(width) + \\\"_\\\" + out_name + \\\"_\\\" + str(sliceh) + \\\"_\\\" + str(slicew) +\\\".png\\\\n\\\")\\n\\n if sliceh == 16 and slicew == 27 and width == 450 :\\n print (int(slicew*slice_size/step), int(sliceh*slice_size/step),int(slicew*slice_size/step)+slice_size,int(sliceh*slice_size/step)+slice_size)\\n\\n file.close()\\n transform_test = tf.Compose([tf.Grayscale(), tf.ToTensor(), tf.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\\n testset = UnknownDataset(\\\"./testsliceimage/\\\", \\\"./testsliceimage/list.txt\\\", transform=transform_test)\\n testloader = torch.utils.data.DataLoader(testset, batch_size=BATCH_SIZE,\\n shuffle=False, num_workers=WORKERS)\\n\\n with torch.no_grad():\\n N = 0\\n for data in testloader:\\n images, img_names = data['image'], data['image_name']\\n outputs = net(images.float())\\n _, predicted = torch.max(outputs.data, 1)\\n # print(predicted)\\n if max(predicted) == 1 :\\n ite = -1\\n for predic in predicted :\\n ite += 1\\n if predic == 1 and outputs[ite][1]-outputs[ite][0] > CONFIDENCE:\\n print(img_names[ite])\\n # print(outputs)\\n N += 1\\n #dessiner carre sur image\\n slh = int(img_names[ite].split('_')[4])\\n slw = int(img_names[ite].split('_')[5][:-4])\\n x1 = int(slh * slice_size / step)\\n x2 = x1 + slice_size\\n y1 = int(slw * slice_size / step)\\n y2 = y1 + slice_size\\n\\n if slh == 16 and slw == 27 and width ==450 :\\n print (x1, y1, x2, y2)\\n\\n print(r)\\n rh = orh / height\\n rw = orw / width\\n x1 = x1 * rh\\n x2 = x2 * rh\\n y1 = y1 * rw\\n y2 = y2 * rw\\n\\n draw.rectangle(((y1, x1), (y2, x2)), outline=\\\"red\\\")\\n # draw.text((y2,x2), img_names[0])\\n copyfile(\\\"./testsliceimage/\\\"+img_names[ite], \\\"./goodimage/\\\"+ img_names[ite])\\n\\n if width <= 200 or height <= 200:\\n flag_continue = False\\n else:\\n r = r * scale\\n width, height = int(width/scale), int(height/scale)\\n slicesh = int(math.ceil(height/slice_size))\\n slicesw = int(math.ceil(width/slice_size))\\n img = img.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\\n width, height = img.size\\n\\n # imgout = imgout.resize((slicesw*slice_size, slicesh*slice_size), PIL.Image.ANTIALIAS)\\n imgout.save(\\\"./rectangle/out\\\", \\\"PNG\\\")\",\n \"def load_images_from_folder(folder, n_cases,patch_size, mask_path, mask_type, mask_name,normalize=False, imrotate=False):\\n\\n# # Initialize the arrays:\\n# if imrotate: # number of images is 4 * n_im\\n# bigy = np.empty((n_im * 4, 64, 64))\\n# bigx = np.empty((n_im * 4, 64, 64, 2))\\n# else:\\n# bigy = np.empty((n_im, 64, 64))\\n# bigx = np.empty((n_im, 64, 64, 2))\\n\\n# im = 0 # image counter\\n bigy = []\\n filenames = os.listdir(folder)\\n\\n for filename in filenames[n_cases[0]:n_cases[1]]:\\n if not filename.startswith('.'):\\n temp = loadmat(os.path.join(folder, filename))['res']\\n print temp.shape\\n # Clean the STONE sense recon data\\n row, col = temp.shape\\n temp = np.reshape(temp, (row, col, -1))\\n #valid_mask = (np.abs(np.squeeze(temp[int(row/2), int(col/2), :])) != 0)\\n #final_images = temp[:,:,valid_mask]\\n final_images = temp\\n \\n# # Resize images\\n #final_images = np.abs(final_images)\\n final_images_resized = np.zeros((patch_size,patch_size,final_images.shape[2]))\\n for i in range(final_images.shape[2]):\\n final_images_resized[:,:,i] = cv2.resize(final_images[:,:,i], (patch_size,patch_size))\\n \\n# # Only take a small part of the data\\n# final_images = final_images[140:180,140:180,:]\\n \\n# # Convert to abs values\\n# final_images = np.abs(final_images)\\n# \\n# # Normalize based on single patient case\\n# final_images = (final_images - np.mean(final_images)) / np.std(final_images)\\n \\n# bigy_temp = cv2.imread(os.path.join(folder, filename),\\n# cv2.IMREAD_GRAYSCALE)\\n \\n \\n bigy.append(final_images_resized)\\n \\n bigy = np.asarray(bigy)\\n cases, row, col, imgs = bigy.shape\\n bigy = np.transpose(np.reshape(np.transpose(bigy, (1,2,3,0)), (row, col, -1)), (2,0,1))\\n \\n # convert to k-space\\n imgs, row, col = bigy.shape\\n bigx = np.empty((imgs, row, col, 2))\\n mask = read_mask(mask_path=mask_path,mask_type=mask_type,mask_name=mask_name,patch_size=patch_size,show_image=False)\\n for i in range(imgs):\\n bigx[i, :, :, :] = create_x(np.squeeze(bigy[i,:,:]),mask)\\n \\n # convert bigx from complex to abs values\\n bigy = np.abs(bigy)\\n \\n# im += 1\\n# if imrotate:\\n# for angle in [90, 180, 270]:\\n# bigy_rot = im_rotate(bigy_temp, angle)\\n# bigx_rot = create_x(bigy_rot, normalize)\\n# bigy[im, :, :] = bigy_rot\\n# bigx[im, :, :, :] = bigx_rot\\n# im += 1\\n\\n# if imrotate:\\n# if im > (n_im * 4 - 1): # how many images to load\\n# break\\n# else:\\n# if im > (n_im - 1): # how many images to load\\n# break\\n\\n# if normalize:\\n# bigx = (bigx - np.amin(bigx)) / (np.amax(bigx) - np.amin(bigx))\\n\\n return bigx, bigy\",\n \"def crop_images_same_dir(data_set_dir):\\n data = glob(os.path.join(data_set_dir, \\\"*.png\\\"))\\n\\n # data_length = len(data)\\n # high < 256 because want to cut the bottom\\n # offs_h = np.random.randint(low=0, high=200, size=data_length)\\n # offs_h_end = offs_h + 256\\n # offs_w = np.random.randint(low=0, high=512, size=data_length)\\n # offs_w_end = offs_w + 512\\n # print offs_h, offs_h_end\\n\\n for index, filePath in enumerate(data):\\n print ('%d/%d' % (index, len(data)))\\n\\n img = scipy.misc.imread(filePath).astype(np.float)\\n #img = scipy.misc.imresize(img, 0.25, interp='bilinear', mode=None)\\n #scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/CITYSCAPES_crop_random/' + filePath.split('/')[-1],\\n # img[offs_h[index]:offs_h_end[index], offs_w[index]:offs_w_end[index] :])\\n scipy.misc.imsave('/home/andy/dataset/CITYSCAPES/CITYSCAPES_crop_bottom_192/' + filePath.split('/')[-1],\\n img[0:192, :, :])\\n #break\",\n \"def single_channel_stacking(tifs):\\n template_ID=int(len(tifs)/2)\\n \\n template_raster=gdal_array.LoadFile(tifs[template_ID-1])\\n avg_raster=np.zeros_like(template_raster)\\n avg_raster=avg_raster+1\\n new_raster=np.copy(template_raster)\\n # ones=np.full(template_raster.shape, 1)\\n for i, tif in enumerate(tifs, start=1):\\n if i==template_ID: \\n continue\\n \\n tif_raster=gdal_array.LoadFile(tif)\\n # tif_raster=cut_transformed_array_borders(tif_raster)\\n result=ird.similarity(template_raster,tif_raster , numiter=1, order=1)\\n img_transformed= ird.transform_img(tif_raster, scale=result['scale'], angle=result['angle'], tvec=result['tvec'], mode='constant', bgval=0, order=2)\\n \\n img_transformed=cut_transformed_array_borders(img_transformed)\\n \\n # ones_transformed=ird.transform_img(ones, scale=result['scale'], angle=result['angle'], tvec=result['tvec'], mode='constant', bgval=0, order=1)\\n ones_transformed=np.zeros_like(template_raster)\\n ones_transformed[np.where(img_transformed>0)]=1\\n print(ones_transformed)\\n \\n print(np.mean(ones_transformed), np.max(ones_transformed), np.min(ones_transformed))\\n print(ones_transformed[np.where(ones_transformed>0)])\\n print(np.min(ones_transformed[np.where(ones_transformed>0)]))\\n print(np.max(ones_transformed[np.where(ones_transformed>0)]))\\n\\n plt.imshow(ones_transformed)\\n plt.show()\\n plt.close()\\n \\n # ones_transformed=cut_transformed_array_borders(ones_transformed)\\n \\n avg_raster=avg_raster+ones_transformed\\n # ird.imshow(template_raster, tif_raster, img_transformed)\\n \\n new_raster=new_raster+img_transformed\\n \\n # new_raster=new_raster+template_raster \\n # new_raster=new_raster/len(tifs)\\n\\n gtz=np.where(avg_raster>0)\\n \\n\\n \\n\\n \\n \\n plt.imshow(new_raster)\\n plt.show()\\n plt.close()\\n # gdal_array.SaveArray(new_raster, tifs[0][:-4]+\\\"_not_abvertaghe_stacked_.tiff\\\")\\n new_raster[gtz]=new_raster[gtz]/avg_raster[gtz] \\n gdal_array.SaveArray(new_raster, tifs[0][:-4]+\\\"_stacked_.tiff\\\")\\n plt.imshow(new_raster)\\n plt.savefig(\\\"test.tif\\\", dpi=800)\\n plt.show()\\n plt.close()\\n\\n def discrete_cmap(N, base_cmap=None):\\n \\\"\\\"\\\"Create an N-bin discrete colormap from the specified input map\\\"\\\"\\\"\\n \\n # Note that if base_cmap is a string or None, you can simply do\\n # return plt.cm.get_cmap(base_cmap, N)\\n # The following works for string, None, or a colormap instance:\\n \\n base = plt.cm.get_cmap(base_cmap)\\n color_list = base(np.linspace(0, 1, N))\\n cmap_name = base.name + str(N)\\n return base.from_list(cmap_name, color_list, N)\\n\\n cmap=discrete_cmap(int(avg_raster.max())+1, base_cmap=\\\"ocean\\\") \\n \\n norm=mpl.colors.BoundaryNorm(np.arange(-0.5,int(avg_raster.max()+1)), cmap.N)\\n fig=plt.figure()\\n fig.set_size_inches(5,4)\\n ax=fig.add_subplot(111)\\n data=ax.matshow(avg_raster, cmap=cmap, norm=norm)\\n fig.colorbar(data, ticks=np.linspace(0,int(avg_raster.max()),int(avg_raster.max()+1)), drawedges=True)\\n\\n plt.show()\\n plt.close()\\n\\n\\n # gdal_array.SaveArray(new_raster, tifs[0][:-4]+\\\"_stacked_.tiff\\\")\",\n \"def three_sample_images():\\n samples = samples_path()\\n _truck = np.array(Image.open(os.path.join(samples, \\\"truck.png\\\")))\\n _deer = np.array(Image.open(os.path.join(samples, \\\"deer.png\\\")))\\n _frog = np.array(Image.open(os.path.join(samples, \\\"frog.png\\\")))\\n truck = transforms.ToTensor()(_truck)\\n deer = transforms.ToTensor()(_deer)\\n frog = transforms.ToTensor()(_frog)\\n return torch.stack([truck, deer, frog])\",\n \"def quadriview_old(nifti_image, slice_sag, slice_orth,\\n slice_cor_1, slice_cor_2):\\n view_1 = nifti_image[slice_sag, :, :]\\n view_2 = nifti_image[:, slice_orth, :]\\n view_3 = nifti_image[:, :, slice_cor_1]\\n view_4 = nifti_image[:, :, slice_cor_2]\\n\\n pad_lign = max(view_1.shape[0] + view_2.shape[0], view_3.shape[0] + view_4.shape[0])\\n pad_col = max(view_1.shape[1] + view_3.shape[1], view_2.shape[1] + view_4.shape[1])\\n pad = np.zeros((pad_lign, pad_col), dtype=np.float64)\\n\\n pad[:view_1.shape[0], :view_1.shape[1]] = view_1\\n pad[-view_2.shape[0]:, :view_2.shape[1]] = view_2\\n pad[:view_3.shape[0], -view_3.shape[1]:] = view_3\\n pad[-view_4.shape[0]:, -view_4.shape[1]:] = view_4\\n\\n return pad\",\n \"def assemble_image_stack(image_stack, index_map):\\n # get boundary\\n index_max_x = np.max(index_map[:, :, :, 0])\\n index_max_y = np.max(index_map[:, :, :, 1])\\n # set holder\\n image = np.zeros((index_max_x, index_max_y))\\n # loop through the panels\\n for l in range(index_map.shape[0]):\\n image[index_map[l, :, :, :]] = image_stack[l, :, :]\\n\\n return image\",\n \"def split_combined_polys(polys, poly_lens, polys_per_mask):\\n mask_polys_list = []\\n for img_id in range(len(polys)):\\n polys_single = polys[img_id]\\n polys_lens_single = poly_lens[img_id].tolist()\\n polys_per_mask_single = polys_per_mask[img_id].tolist()\\n\\n split_polys = mmcv.slice_list(polys_single, polys_lens_single)\\n mask_polys = mmcv.slice_list(split_polys, polys_per_mask_single)\\n mask_polys_list.append(mask_polys)\\n return mask_polys_list\",\n \"def _crop_write_image(self, inroot, images, outroot):\\n for image in images:\\n inimage_path = osp.join(inroot, image)\\n cvimg = cv2.imread(inimage_path)\\n cvimg = cvimg[60:-30, 25:-25]\\n h, w, _ = cvimg.shape\\n assert h == w == 128\\n outimage_path = osp.join(outroot, image)\\n cv2.imwrite(outimage_path, cvimg)\\n print(outimage_path)\",\n \"def concatenate_datasets(filenames_list, img_rows=128, img_cols=128):\\n print('Concatenating the datasets created by data augmentation into a single one')\\n print('Using the following pairs of images / masks datasets: ')\\n print(filenames_list)\\n print('\\\\n')\\n\\n # total number of images\\n n_samples = 600 * len(filenames_list)\\n\\n # create np.ndarrays for the images and the targets: xCenter, yCenter, xOrientation, yOrientation\\n images_dataset = np.ndarray((n_samples, img_rows, img_cols), dtype=np.uint8)\\n targets_dataset = np.ndarray((n_samples, 4), dtype=np.float32)\\n\\n for ds, (img, mask) in enumerate(filenames_list):\\n print(\\\" Processing {}\\\".format(img))\\n images = np.load(\\\"output/augmented_data/{}.npy\\\".format(img))\\n masks = np.load(\\\"output/augmented_data/{}.npy\\\".format(mask))\\n\\n for idx, mat in enumerate(masks):\\n\\n # get the center coordinates of the left ventricle (on the resized image)\\n row, col = findCenter(img=mat, pixelvalue=1)\\n\\n # get the orientation of the left ventricle (on the resized image)\\n x_v1, y_v1 = findMainOrientation(img=mat, pixelvalue=1)\\n\\n # save the center coordinates & orientation to the y dataframe (which will be the output of the network)\\n targets_dataset[ds*600 + idx] = np.array([row, col, x_v1, y_v1])\\n\\n # save image in main dataset file\\n images_dataset[ds*600 + idx] = images[idx]\\n\\n print('Concatenated all datasets into one & created target values for (center, orientation)')\\n\\n print('Splitting the dataset into 70% training & 30% testing')\\n images_train, images_test, targets_train, targets_test = train_test_split(images_dataset, targets_dataset,\\n test_size=0.3,\\n random_state=42,\\n shuffle=True)\\n\\n # save all ndarrays to a .npy files (for faster loading later)\\n # Create directory to store files.\\n directory = os.path.join(os.getcwd(), 'output/processed_data/')\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # save training set to file\\n np.save('output/processed_data/images_train.npy', images_train)\\n np.save('output/processed_data/targets_train.npy', targets_train)\\n\\n # save testing set to file\\n np.save('output/processed_data/images_test.npy', images_test)\\n np.save('output/processed_data/targets_test.npy', targets_test)\\n print('Saving to .npy files done. See files: ')\\n print('output/processed_data/images_train.npy')\\n print('output/processed_data/targets_train.npy')\\n print('output/processed_data/images_test.npy')\\n print('output/processed_data/targets_test.npy')\",\n \"def pre_process_data(input_path: list, cuts: int, shape: int = 32, normalize: bool = True) -> list:\\n images = []\\n images_uncut = []\\n for files_path in input_path:\\n\\n files = os.listdir(files_path) # TODO paths\\n for f in files:\\n file_path = f'{files_path}/{f}'\\n im_uncut = cv2.imread(file_path)\\n im_uncut = cv2.cvtColor(im_uncut, cv2.COLOR_RGB2GRAY)\\n images_uncut.append(cv2.resize(im_uncut, (shape * cuts, shape * cuts)))\\n x = np.array(images_uncut)\\n\\n if normalize:\\n x_mean = np.mean(x, axis=(0, 1, 2))\\n x_std = np.std(x, axis=(0, 1, 2))\\n x = (x - x_mean) / (x_std + 1e-9)\\n\\n for im in x:\\n height = im.shape[0]\\n width = im.shape[1]\\n frac_h = height // cuts\\n frac_w = width // cuts\\n i = 0\\n image = []\\n for h in range(cuts):\\n for w in range(cuts):\\n crop = im[h * frac_h:(h + 1) * frac_h, w * frac_w:(w + 1) * frac_w]\\n crop_rehaped = cv2.resize(crop, (shape, shape))\\n image.append([crop_rehaped, i, number_to_angle(i, cuts), neighbours(i, cuts)])\\n i = i + 1\\n images.append(image)\\n # return np.array(images) # todo back to array\\n return images\",\n \"def __augmented_images(self, info, start):\\n count = start\\n final_img_to_save = []\\n for pair in info:\\n processedImage = self.__processImage(os.path.join(WORKING_DIR, pair[0]))\\n if processedImage == None:\\n continue\\n # translation is not that important since CNNs are resistant to image translations\\n rotatedImages = self.__applyRotations(processedImage)\\n\\n rotCount = 1\\n for img in rotatedImages:\\n filename = str(count) + \\\"_\\\" + str(rotCount) + \\\".jpg\\\"\\n # img.save(os.path.join(directory, filename))\\n final_img_to_save.append((img, pair[1], filename))\\n rotCount += 1\\n\\n print(\\\"Augmenting image: {:05}\\\".format(count))\\n count += 1\\n return final_img_to_save\",\n \"def beam_slices(map_file, fee_map, nside):\\n\\n t_name, r_name, _, _ = Path(map_file).stem.split(\\\"_\\\")\\n\\n pointings = [\\\"0\\\", \\\"2\\\", \\\"4\\\"]\\n\\n maps = []\\n\\n # load data from map .npz file\\n tile_map = np.load(map_file, allow_pickle=True)\\n fee_m = np.load(fee_map, allow_pickle=True)\\n\\n for p in pointings:\\n\\n tile = tile_map[p]\\n\\n if \\\"XX\\\" in t_name:\\n fee = fee_m[p][0]\\n else:\\n fee = fee_m[p][1]\\n\\n # rotate maps so slices can be taken\\n fee_r = rotate_map(nside, angle=-np.pi / 4, healpix_array=fee)\\n tile_r = rotate_map(nside, angle=-np.pi / 4, healpix_array=tile)\\n\\n # fee_r[PB_0] = np.nan\\n # tile_r[PB_0] = np.nan\\n\\n # slice the tile and fee maps along NS, EW\\n # zenith angle thresh of 70 to determine fit gain factor\\n NS_f, EW_f = healpix_cardinal_slices(nside, fee_r, 70)\\n NS_t, EW_t = map_slices(nside, tile_r, 70)\\n\\n gain_NS = chisq_fit_gain(data=NS_t[0], model=NS_f[0])\\n gain_EW = chisq_fit_gain(data=EW_t[0], model=EW_f[0])\\n\\n # slice the tile and fee maps along NS, EW.\\n # the above gain factor is applied to full beam slices\\n NS_fee, EW_fee = healpix_cardinal_slices(nside, fee_r, 85)\\n NS_tile, EW_tile = map_slices(nside, tile_r, 85)\\n\\n # Scale the data so that it best fits the beam slice\\n NS_tile_med = NS_tile[0] - gain_NS[0]\\n EW_tile_med = EW_tile[0] - gain_EW[0]\\n\\n # delta powers\\n del_NS = NS_tile_med - NS_fee[0]\\n del_EW = EW_tile_med - EW_fee[0]\\n\\n # 3rd order poly fits for residuals\\n fit_NS = poly_fit(NS_tile[2], del_NS, NS_tile[0], 3)\\n fit_EW = poly_fit(EW_tile[2], del_EW, EW_tile[0], 3)\\n\\n maps.append(\\n [\\n [NS_tile, NS_fee, NS_tile_med, del_NS, fit_NS],\\n [EW_tile, EW_fee, EW_tile_med, del_EW, fit_EW],\\n ]\\n )\\n\\n return maps\",\n \"def _augment_images(self, images, random_state, parents, hooks):\\n nb_images = len(images)\\n samples = self.p.draw_samples((nb_images,), random_state=random_state)\\n for i in sm.xrange(nb_images):\\n if samples[i] == 1:\\n if self.axis == 1:\\n images[i] = np.fliplr(images[i])\\n elif self.axis == 0:\\n images[i] = np.flipud(images[i])\\n self.samples = samples\\n return images\",\n \"def crops(fields, anchor, crop, pad, size):\\n ndim = len(size)\\n assert all(len(x) == ndim for x in [anchor, crop, pad, size]), 'inconsistent ndim'\\n new_fields = []\\n for x in fields: #loop over channel dim\\n ind = []\\n for d, (a, c, (p0, p1), s) in enumerate(zip(anchor, crop, pad, size)):\\n i = np.arange(a - p0, a + c + p1)\\n i %= s\\n i = i.reshape((-1,) + (1,) * (ndim - d - 1))\\n ind.append(i)\\n \\n x = x[tuple(ind)]\\n\\n new_fields.append(x)\\n return np.array(new_fields)\",\n \"def prepare_voxel_slice(self,slices,llc,urc,direction):\\n\\t\\tsize=urc-llc\\n\\t\\tres = float(size[direction] / slices)\\n\\t\\tdims=numpy.ceil(size/res)\\n\\t\\treturn numpy.zeros((dims[(direction+1) % 3],dims[(direction+2) % 3]),dtype='bool'), res\",\n \"def align_images(self, translation_only=False):\\n # Extract feature point locations and descriptors.\\n points_and_descriptors = []\\n for file in self.files:\\n image = sol4_utils.read_image(file, 1)\\n self.images.append(image)\\n self.h, self.w = image.shape\\n pyramid, _ = sol4_utils.build_gaussian_pyramid(image, 3, PYR_FLT_LEVEL)\\n points_and_descriptors.append(find_features(pyramid))\\n\\n # Compute homographies between successive pairs of images.\\n Hs = []\\n for i in range(len(points_and_descriptors) - 1):\\n points1, points2 = points_and_descriptors[i][0], points_and_descriptors[i + 1][0]\\n desc1, desc2 = points_and_descriptors[i][1], points_and_descriptors[i + 1][1]\\n\\n # Find matching feature points.\\n ind1, ind2 = match_features(desc1, desc2, MATCH_MIN_SCORE)\\n points1, points2 = points1[ind1, :], points2[ind2, :]\\n\\n # Compute homography using RANSAC.\\n H12, inliers = ransac_homography(points1, points2,\\n RANSAC_ITER_NUM, RANAC_ERR_TOL,\\n translation_only)\\n\\n # Uncomment for debugging: display inliers and outliers among matching points.\\n # In the submitted code this function should be commented out!\\n if(self.display_match):\\n display_matches(self.images[i], self.images[i+1], points1 , points2, inliers)\\n\\n Hs.append(H12)\\n\\n # Compute composite homographies from the central coordinate system.\\n accumulated_homographies = accumulate_homographies(Hs, (len(Hs) - 1) // 2)\\n self.homographies = np.stack(accumulated_homographies)\\n self.frames_for_panoramas = filter_homographies_with_translation(self.homographies, minimum_right_translation=5)\\n print((self.frames_for_panoramas.shape))\\n self.homographies = self.homographies[self.frames_for_panoramas]\",\n \"def concat_images_vert(imga, imgb):\\n ha,wa = imga.shape[:2]\\n hb,wb = imgb.shape[:2]\\n max_width = np.max([wa, wb])\\n total_height = ha+hb\\n new_img = np.zeros(shape=(total_height, max_width, 3), dtype=np.uint8)\\n new_img[:ha,:wa]=imga\\n #new_img[:hb,wa:wa+wb]=imgb\\n new_img[ha:ha+hb,:wb]=imgb\\n return new_img\",\n \"def _compute_ij_images_for_source_line(\\n src_j0: int,\\n src_x_image: np.ndarray,\\n src_y_image: np.ndarray,\\n src_i_min: int,\\n src_j_min: int,\\n dst_src_ij_images: np.ndarray,\\n dst_x_offset: float,\\n dst_y_offset: float,\\n dst_x_scale: float,\\n dst_y_scale: float,\\n uv_delta: float\\n):\\n src_width = src_x_image.shape[-1]\\n\\n dst_width = dst_src_ij_images.shape[-1]\\n dst_height = dst_src_ij_images.shape[-2]\\n\\n dst_px = np.zeros(4, dtype=src_x_image.dtype)\\n dst_py = np.zeros(4, dtype=src_y_image.dtype)\\n\\n u_min = v_min = -uv_delta\\n uv_max = 1.0 + 2 * uv_delta\\n\\n for src_i0 in range(src_width - 1):\\n src_i1 = src_i0 + 1\\n src_j1 = src_j0 + 1\\n\\n dst_px[0] = dst_p0x = src_x_image[src_j0, src_i0]\\n dst_px[1] = dst_p1x = src_x_image[src_j0, src_i1]\\n dst_px[2] = dst_p2x = src_x_image[src_j1, src_i0]\\n dst_px[3] = dst_p3x = src_x_image[src_j1, src_i1]\\n\\n dst_py[0] = dst_p0y = src_y_image[src_j0, src_i0]\\n dst_py[1] = dst_p1y = src_y_image[src_j0, src_i1]\\n dst_py[2] = dst_p2y = src_y_image[src_j1, src_i0]\\n dst_py[3] = dst_p3y = src_y_image[src_j1, src_i1]\\n\\n dst_pi = np.floor((dst_px - dst_x_offset)\\n / dst_x_scale).astype(np.int64)\\n dst_pj = np.floor((dst_py - dst_y_offset)\\n / dst_y_scale).astype(np.int64)\\n\\n dst_i_min = np.min(dst_pi)\\n dst_i_max = np.max(dst_pi)\\n dst_j_min = np.min(dst_pj)\\n dst_j_max = np.max(dst_pj)\\n\\n if dst_i_max < 0 \\\\\\n or dst_j_max < 0 \\\\\\n or dst_i_min >= dst_width \\\\\\n or dst_j_min >= dst_height:\\n continue\\n\\n if dst_i_min < 0:\\n dst_i_min = 0\\n\\n if dst_i_max >= dst_width:\\n dst_i_max = dst_width - 1\\n\\n if dst_j_min < 0:\\n dst_j_min = 0\\n\\n if dst_j_max >= dst_height:\\n dst_j_max = dst_height - 1\\n\\n # u from p0 right to p1, v from p0 down to p2\\n det_a = _fdet(dst_p0x, dst_p0y, dst_p1x, dst_p1y, dst_p2x, dst_p2y)\\n # u from p3 left to p2, v from p3 up to p1\\n det_b = _fdet(dst_p3x, dst_p3y, dst_p2x, dst_p2y, dst_p1x, dst_p1y)\\n\\n if np.isnan(det_a) or np.isnan(det_b):\\n # print('no plane at:', src_i0, src_j0)\\n continue\\n\\n for dst_j in range(dst_j_min, dst_j_max + 1):\\n dst_y = dst_y_offset + (dst_j + 0.5) * dst_y_scale\\n for dst_i in range(dst_i_min, dst_i_max + 1):\\n dst_x = dst_x_offset + (dst_i + 0.5) * dst_x_scale\\n\\n # TODO: use two other combinations,\\n # if one of the dst_px<n>,dst_py<n> pairs is missing.\\n\\n src_i = src_j = -1\\n\\n if det_a != 0.0:\\n u = _fu(dst_x, dst_y,\\n dst_p0x, dst_p0y, dst_p2x, dst_p2y) / det_a\\n v = _fv(dst_x, dst_y,\\n dst_p0x, dst_p0y, dst_p1x, dst_p1y) / det_a\\n if u >= u_min and v >= v_min and u + v <= uv_max:\\n src_i = src_i0 + _fclamp(u, 0.0, 1.0)\\n src_j = src_j0 + _fclamp(v, 0.0, 1.0)\\n if src_i == -1 and det_b != 0.0:\\n u = _fu(dst_x, dst_y,\\n dst_p3x, dst_p3y, dst_p1x, dst_p1y) / det_b\\n v = _fv(dst_x, dst_y,\\n dst_p3x, dst_p3y, dst_p2x, dst_p2y) / det_b\\n if u >= u_min and v >= v_min and u + v <= uv_max:\\n src_i = src_i1 - _fclamp(u, 0.0, 1.0)\\n src_j = src_j1 - _fclamp(v, 0.0, 1.0)\\n if src_i != -1:\\n dst_src_ij_images[0, dst_j, dst_i] = src_i_min + src_i\\n dst_src_ij_images[1, dst_j, dst_i] = src_j_min + src_j\",\n \"def extract(self, files):\\n for i in range(len(files)):\\n print(files[i])\\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\\n\\n \\\"\\\"\\\"\\n Find the indices of array elements that are non-zero, i.e,\\n find the pixels' positions that represents the respiratory\\n functions (pixels in the respiratory function are brighter).\\n \\\"\\\"\\\"\\n color_pts = np.argwhere(img > 70)\\n\\n \\\"\\\"\\\"\\n Sorts the pixels according to their x coordenate.\\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\\n the parameter of itemgetter is 1 (to get x coordinate)\\n \\\"\\\"\\\"\\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\\n\\n \\\"\\\"\\\"\\n If there is no pixel representing the respiratory function\\n (i.e., lighter pixel) it creates an empty image (without any\\n respiratory function)\\n \\\"\\\"\\\"\\n if len(lcolor_pts) == 0:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open(\\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], []))\\n # file.close()\\n\\n continue\\n\\n # Reverse the coordinates and store the result in lordered_pts list\\n lordered_pts = []\\n for j in range(len(lcolor_pts)):\\n lordered_pts.append(lcolor_pts[j][::-1])\\n\\n \\\"\\\"\\\"\\n Convert pixels coordinates into a tuples and check which column\\n has pixels that corresponding to diaphragmatic level\\n Obs. There are some columns that doesnt have any pixel that\\n correpond to diaphragmatic level.\\n \\\"\\\"\\\"\\n # Columns that have a pixel corresponding diaphragmatic level\\n lcolumn_available = []\\n for j in range(len(lordered_pts)):\\n lordered_pts[j] = tuple(lordered_pts[j])\\n lcolumn_available.append(lordered_pts[j][0])\\n lcolumn_available = list(set(lcolumn_available))\\n # print(\\\"Ordered points: \\\", lordered_pts)\\n # print(\\\"Columns available: \\\", lcolumn_available)\\n\\n \\\"\\\"\\\"\\n If there is not enough columns to build a respiratory pattern,\\n create a blank image\\n \\\"\\\"\\\"\\n if len(lcolumn_available) < 20:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n continue\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n first column, assign to it the value of the second y coordinate\\n \\\"\\\"\\\"\\n if lcolumn_available[0] is not 0:\\n y = max(\\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\\n key=itemgetter(1))[1]\\n lordered_pts.insert(0, (0, y))\\n lcolumn_available.insert(0, 0)\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n last column, assign to it the value of the penultimate y coordinate\\n available\\n \\\"\\\"\\\"\\n if lcolumn_available[-1] is not 49:\\n lordered_pts.append(\\n (49, lordered_pts[len(lcolumn_available)][1]))\\n lcolumn_available.append(49)\\n\\n \\\"\\\"\\\"\\n Get the biggest y value in each column that represents the\\n diaphragmatic level\\n \\\"\\\"\\\"\\n column = 0\\n lcolumn = []\\n ldiaphragm_pts = []\\n for j in range(50):\\n # Get the column's points\\n lcolumn = [x for x in lordered_pts if x[0] == column]\\n # print('{}: {}'.format(j, lcolumn))\\n\\n if len(lcolumn) > 0:\\n ldiaphragm_pts.append(\\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\\n else:\\n # Get the y value from the previous column\\n lcolumn_available.insert(column, column)\\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\\n column += 1\\n lcolumn = []\\n\\n # Draw diaphragmatic level\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n j = 0\\n while(j < len(lcolumn_available) - 1):\\n cv2.line(\\n diaphragmatic_lvl,\\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\\n (0, 0, 255), 1)\\n j = j + 1\\n\\n lcolumn_available = []\\n\\n print(\\\"Diaphragmatic's points: \\\", ldiaphragm_pts)\\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], ldiaphragm_pts))\\n # file.close()\\n\\n # return ldiaphragm_pts\",\n \"def data_augmenter(image, label, shift, rotate, scale, intensity, flip):\\n image2 = np.zeros(image.shape, dtype=np.float32)\\n label2 = np.zeros(label.shape, dtype=np.int32)\\n for i in range(image.shape[0]):\\n # For each image slice, generate random affine transformation parameters\\n # using the Gaussian distribution\\n shift_val = [np.clip(np.random.normal(), -3, 3) * shift,\\n np.clip(np.random.normal(), -3, 3) * shift]\\n rotate_val = np.clip(np.random.normal(), -3, 3) * rotate\\n scale_val = 1 + np.clip(np.random.normal(), -3, 3) * scale\\n intensity_val = 1 + np.clip(np.random.normal(), -3, 3) * intensity\\n\\n # Apply the affine transformation (rotation + scale + shift) to the image\\n row, col = image.shape[1:3]\\n M = cv2.getRotationMatrix2D((row / 2, col / 2), rotate_val, 1.0 / scale_val)\\n M[:, 2] += shift_val\\n for c in range(image.shape[3]):\\n image2[i, :, :, c] = ndimage.interpolation.affine_transform(image[i, :, :, c],\\n M[:, :2], M[:, 2], order=1)\\n\\n # Apply the affine transformation (rotation + scale + shift) to the label map\\n label2[i, :, :] = ndimage.interpolation.affine_transform(label[i, :, :],\\n M[:, :2], M[:, 2], order=0)\\n\\n # Apply intensity variation\\n image2[i] *= intensity_val\\n\\n # Apply random horizontal or vertical flipping\\n if flip:\\n if np.random.uniform() >= 0.5:\\n image2[i] = image2[i, ::-1, :, :]\\n label2[i] = label2[i, ::-1, :]\\n else:\\n image2[i] = image2[i, :, ::-1, :]\\n label2[i] = label2[i, :, ::-1]\\n return image2, label2\",\n \"def show_slices(slices, colour_map):\\n fig, axes = plt.subplots(1, len(slices))\\n for i, slice in enumerate(slices):\\n axes[i].imshow(slice.T, cmap=colour_map, origin=\\\"lower\\\")\\n plt.show()\",\n \"def load_images(input_dir=\\\"/tmp/mapswipe/project-1\\\", n_images=2000, seed=1):\\n class_map = {1: \\\"1\\\", 0: \\\"5\\\"}\\n output_dir = \\\"/Users/thead/git/dreamview/data/\\\"\\n\\n X_ = []\\n y_ = []\\n for new_klass in class_map:\\n images = []\\n for klass in class_map[new_klass]:\\n for img in glob.glob(input_dir + \\\"/%s/*/*/*/aerial.jpeg\\\" % klass):\\n if os.stat(img).st_size > 0:\\n images.append(img)\\n\\n images = shuffle(images, random_state=seed+42+new_klass)\\n images = images[:n_images]\\n X_ += images\\n y_ += [new_klass] * len(images)\\n\\n # XXX deduce array size from an actual image\\n X = np.zeros((2*n_images, 256*256), dtype=np.ubyte)\\n y = np.zeros(2*n_images, dtype=np.int)\\n\\n for n, (img_path, klass) in enumerate(zip(X_, y_)):\\n # the order of these OPs has been chosen on purpose, don't mess\\n # without checking what happens\\n img = imread(img_path)\\n img = equalize_adapthist(img)\\n img = rgb2grey(img)\\n img = img_as_ubyte(img)\\n\\n if not n % 10:\\n fname = os.path.split(img_path)[:-1]\\n fname = os.path.join(*fname, \\\"aerial-processed.jpeg\\\")\\n imsave(fname, img)\\n\\n X[n,:] = img.ravel()\\n y[n] = klass\\n\\n return X, y\",\n \"def long_slice(image_data):\\n\\n\\t# Process binary data and open.\\n\\tim = image_data.split('base64,')[1]\\n\\tim = base64.b64decode(im)\\n\\tim = io.BytesIO(im)\\n\\t\\n\\timg = Image.open(im)\\n\\twidth, height = img.size\\n\\tupper = 0\\n\\tleft = 0\\n\\t\\n\\t# Max height to fit pdf.\\n\\tmax_height_mm = 198\\n\\tmax_height = (max_height_mm * 96) / 25.4\\n\\n\\tslice_size = max_height\\n\\n\\tslices = int(math.ceil(height/slice_size))\\n\\tcount = 1\\n\\n\\tfinal_slices = []\\n\\tfor slice in range(slices):\\n\\t\\t# If no more slices needed, set the lower bound to bottom of image.\\n\\t\\tif count == slices:\\n\\t\\t\\tlower = height\\n\\t\\telse:\\n\\t\\t\\tlower = int(count * slice_size) \\n\\t\\t \\n\\t\\t# Set the bounding box. \\n\\t\\tbbox = (left, upper, width, lower)\\n\\t\\tworking_slice = img.crop(bbox)\\n\\n\\t\\t# Save png as bytes object.\\n\\t\\tbyte_io = io.BytesIO()\\n\\t\\tworking_slice.save(byte_io, 'png')\\n\\t\\t\\n\\t\\t# Convert bytes object to base64 string and save to list.\\n\\t\\timg_str = base64.b64encode(byte_io.getvalue())\\n\\t\\timg_str = 'data:image/png;base64,' + img_str.decode()\\n\\t\\tfinal_slices.append(img_str)\\n\\n\\t\\tupper = upper + slice_size\\n\\t\\tcount = count + 1\\n\\n\\treturn final_slices\",\n \"def crop_acc_mask(images_dir, images_output_dir, masks_dir, mask_suffix=None, masks_output_dir=None): \\n image_suffix_list = [\\\"C0\\\", \\\"DE\\\", \\\"T2\\\"]\\n if not os.path.exists(images_output_dir):\\n os.makedirs(images_output_dir)\\n if masks_output_dir is not None and (not os.path.exists(masks_output_dir)):\\n os.makedirs(masks_output_dir)\\n margin = [0, 30, 30]\\n masks_list = os.listdir(masks_dir)\\n masks_list.sort()\\n json_dict = OrderedDict()\\n for mask in masks_list:\\n mask_path = os.path.join(masks_dir, mask)\\n if mask.endswith(\\\".nii.gz\\\"):\\n print(\\\"#\\\" * 11 *11)\\n print(mask_path)\\n mask_sitk = sitk.ReadImage(mask_path)\\n mask_npy = sitk.GetArrayFromImage(mask_sitk)\\n mask_shape = mask_npy.shape\\n crop_bbox_min, crop_bbox_max = get_ND_bounding_box(mask_npy, margin=margin)\\n # do not crop along depth dimension\\n crop_bbox_min[0] = 0\\n crop_bbox_max[0] = mask_shape[0]\\n print(crop_bbox_min, crop_bbox_max)\\n json_dict[mask_path] = {\\\"crop_bbox_min\\\": crop_bbox_min, \\\"crop_bbox_max\\\": crop_bbox_max}\\n mask_output_npy = crop_ND_volume_with_bounding_box(mask_npy, crop_bbox_min, crop_bbox_max)\\n if mask_suffix is not None:\\n mask = mask.replace(\\\"_\\\" + mask_suffix + \\\".nii.gz\\\", \\\".nii.gz\\\")\\n if masks_output_dir is not None:\\n save_cropped_array_as_nifty_volume(mask_output_npy, os.path.join(masks_output_dir, mask), mask_sitk)\\n save_cropped_array_as_nifty_volume(convert_label(mask_output_npy, [1, 2, 3, 4, 5], [1, 2, 3, 1, 1]), \\\\\\n os.path.join(images_output_dir, mask.replace(\\\".nii.gz\\\", \\\"_{0:04d}.nii.gz\\\".format(len( \\\\\\n image_suffix_list)))), mask_sitk)\\n for i, image_suffix in enumerate(image_suffix_list):\\n image = mask.replace(\\\".nii.gz\\\", \\\"_{}.nii.gz\\\".format(image_suffix))\\n image_path = os.path.join(images_dir, image)\\n print(image_path)\\n image_sitk = sitk.ReadImage(image_path)\\n image_npy = sitk.GetArrayFromImage(image_sitk)\\n image_output_npy = crop_ND_volume_with_bounding_box(image_npy, crop_bbox_min, crop_bbox_max)\\n save_cropped_array_as_nifty_volume(image_output_npy, os.path.join(images_output_dir, mask.replace( \\\\\\n \\\".nii.gz\\\", \\\"_{0:04d}.nii.gz\\\".format(i))), image_sitk)\\n save_json(json_dict, os.path.join(images_output_dir, \\\"crop_information.json\\\"))\\n if masks_output_dir is not None:\\n save_json(json_dict, os.path.join(masks_output_dir, \\\"crop_information.json\\\"))\",\n \"def slice_array():\\n img = Image.open(\\\"flamingo.jpg\\\")\\n image_as_array = np.array(img)\\n width, height, depth = image_as_array.shape\\n\\n red_channel = image_as_array[:, :, 0]\\n green_channel = image_as_array[:, :, 1]\\n blue_channel = image_as_array[:, :, 2]\\n\\n top_left_corner = image_as_array[:height // 2, :width // 2, :]\\n top_right_corner = image_as_array[:height // 2, width // 2:, :]\\n random_middle_pixels = image_as_array[11:29, 101:400, :]\",\n \"def show_slice(file_path, x, y, z):\\n img = nib.load(file_path)\\n img = img.get_fdata()\\n print(\\\"The scan has dimensions {}.\\\".format(img.shape))\\n slice_0 = img[x, :, :]\\n slice_1 = img[:, y, :]\\n slice_2 = img[:, :, z]\\n slices = [slice_0, slice_1, slice_2]\\n fig, axes = plt.subplots(1, len(slices), figsize=[12, 4])\\n for i, sli in enumerate(slices):\\n axes[i].imshow(sli.T, cmap=\\\"gray\\\", origin=\\\"lower\\\")\",\n \"def plot_pet_image(pet_image, yz_slice_pos, xz_slice_pos, xy_slice_pos, pixel_shape,\\n pixel_spacing, mask=None):\\n # create axis for plotting\\n x = np.arange(0.0, (pixel_shape[0] + 1) * pixel_spacing[0], pixel_spacing[0])\\n y = np.arange(0.0, (pixel_shape[1] + 1) * pixel_spacing[1], pixel_spacing[1])\\n z = np.arange(0.0, (pixel_shape[2] + 1) * pixel_spacing[2], pixel_spacing[2])\\n if mask is not None:\\n pet_image = np.ma.masked_array(pet_image, mask)\\n # create slices that will be shown\\n yz_slice = pet_image[yz_slice_pos, :, :]\\n xz_slice = pet_image[:, xz_slice_pos, :]\\n xy_slice = pet_image[:, :, xy_slice_pos]\\n vmin = min(np.min(yz_slice), np.min(xz_slice), np.min(xy_slice))\\n vmax = max(np.max(yz_slice), np.max(xz_slice), np.max(xy_slice))\\n yz_slice = np.rot90(yz_slice)\\n xz_slice = np.fliplr(np.rot90(xz_slice))\\n # normalize values\\n vmin = min(np.min(yz_slice), np.min(xz_slice), np.min(xy_slice))\\n vmax = max(np.max(yz_slice), np.max(xz_slice), np.max(xy_slice))\\n cmap = plt.cm.gray\\n cmap.set_bad('r', 1)\\n # show images\\n plt.figure(0)\\n plt.clf()\\n plt.subplot(221)\\n plt.pcolormesh(y, z, yz_slice, vmin=vmin, vmax=vmax, cmap=cmap)\\n plt.ylabel('z')\\n plt.subplot(222)\\n plt.pcolormesh(x, z, xz_slice, vmin=vmin, vmax=vmax, cmap=cmap)\\n plt.xlabel('x')\\n plt.subplot(223)\\n plt.pcolormesh(x, y, xy_slice, vmin=vmin, vmax=vmax, cmap=cmap)\\n plt.xlabel('y')\\n plt.ylabel('x')\\n plt.subplot(224)\\n plt.axis([0, 5, 0, 4.5])\\n plt.axis('off')\\n plt.text(1, 3, \\\"x: {:.4f}\\\".format(yz_slice_pos * pixel_spacing[0]), fontsize=15)\\n plt.text(1, 2, \\\"y: {:.4f}\\\".format(xz_slice_pos * pixel_spacing[1]), fontsize=15)\\n plt.text(1, 1, \\\"z: {:.4f}\\\".format(xy_slice_pos * pixel_spacing[2]), fontsize=15)\\n return vmin, vmax\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6989787","0.69521314","0.63546145","0.61053276","0.59612685","0.5914441","0.5825741","0.582431","0.5722109","0.56852674","0.56654567","0.5582949","0.5580172","0.55788565","0.55557424","0.5504493","0.54561037","0.54267657","0.54023594","0.53983194","0.5396745","0.53917056","0.5363869","0.53602153","0.5345241","0.53194577","0.5307303","0.52996516","0.5289846","0.5283133","0.52816343","0.5279728","0.52748525","0.526686","0.5255092","0.5247336","0.52379715","0.5227269","0.522496","0.52194625","0.5216955","0.5191006","0.5178667","0.5178158","0.5170727","0.5168281","0.51606506","0.5157267","0.51481086","0.5148079","0.51468676","0.5145897","0.51458746","0.51426184","0.5141271","0.51407945","0.51374054","0.51148385","0.5110334","0.50992876","0.5098156","0.5087803","0.5086386","0.5083547","0.5080644","0.5075632","0.5073773","0.5049901","0.504612","0.504502","0.50358605","0.5030566","0.5024629","0.50242317","0.50131434","0.50109607","0.50023645","0.50012505","0.5000005","0.49984708","0.49884954","0.49845955","0.49784538","0.49776518","0.49641863","0.4953631","0.49505296","0.49391222","0.49373925","0.49369907","0.49315545","0.49306923","0.49304232","0.49302408","0.49253395","0.49250656","0.49219704","0.49136606","0.4908513","0.49057975"],"string":"[\n \"0.6989787\",\n \"0.69521314\",\n \"0.63546145\",\n \"0.61053276\",\n \"0.59612685\",\n \"0.5914441\",\n \"0.5825741\",\n \"0.582431\",\n \"0.5722109\",\n \"0.56852674\",\n \"0.56654567\",\n \"0.5582949\",\n \"0.5580172\",\n \"0.55788565\",\n \"0.55557424\",\n \"0.5504493\",\n \"0.54561037\",\n \"0.54267657\",\n \"0.54023594\",\n \"0.53983194\",\n \"0.5396745\",\n \"0.53917056\",\n \"0.5363869\",\n \"0.53602153\",\n \"0.5345241\",\n \"0.53194577\",\n \"0.5307303\",\n \"0.52996516\",\n \"0.5289846\",\n \"0.5283133\",\n \"0.52816343\",\n \"0.5279728\",\n \"0.52748525\",\n \"0.526686\",\n \"0.5255092\",\n \"0.5247336\",\n \"0.52379715\",\n \"0.5227269\",\n \"0.522496\",\n \"0.52194625\",\n \"0.5216955\",\n \"0.5191006\",\n \"0.5178667\",\n \"0.5178158\",\n \"0.5170727\",\n \"0.5168281\",\n \"0.51606506\",\n \"0.5157267\",\n \"0.51481086\",\n \"0.5148079\",\n \"0.51468676\",\n \"0.5145897\",\n \"0.51458746\",\n \"0.51426184\",\n \"0.5141271\",\n \"0.51407945\",\n \"0.51374054\",\n \"0.51148385\",\n \"0.5110334\",\n \"0.50992876\",\n \"0.5098156\",\n \"0.5087803\",\n \"0.5086386\",\n \"0.5083547\",\n \"0.5080644\",\n \"0.5075632\",\n \"0.5073773\",\n \"0.5049901\",\n \"0.504612\",\n \"0.504502\",\n \"0.50358605\",\n \"0.5030566\",\n \"0.5024629\",\n \"0.50242317\",\n \"0.50131434\",\n \"0.50109607\",\n \"0.50023645\",\n \"0.50012505\",\n \"0.5000005\",\n \"0.49984708\",\n \"0.49884954\",\n \"0.49845955\",\n \"0.49784538\",\n \"0.49776518\",\n \"0.49641863\",\n \"0.4953631\",\n \"0.49505296\",\n \"0.49391222\",\n \"0.49373925\",\n \"0.49369907\",\n \"0.49315545\",\n \"0.49306923\",\n \"0.49304232\",\n \"0.49302408\",\n \"0.49253395\",\n \"0.49250656\",\n \"0.49219704\",\n \"0.49136606\",\n \"0.4908513\",\n \"0.49057975\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69521314"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":78492,"cells":{"query":{"kind":"string","value":"Calculates cost and its gradient using Mean Squared Error. (1/2m)sum(Y Y_hat)^.2"},"document":{"kind":"string","value":"def mean_squared_error(Y, Y_hat):\n \n m = Y.shape[0]\n \n # calc cost\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = - (1 / m) * (Y - Y_hat)\n \n return cost, dY_hat"},"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 compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_cost(Y_hat, Y):\r\n\r\n m = Y.shape[1]\r\n\r\n\r\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\r\n\r\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\r\n\r\n return cost","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\n m = X.shape[0]\n y_hat = sigmoid(X @ theta.T)\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\n temp = theta\n temp[0] = 0\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\n return J, grad","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def compute_cost_derivative(AL, Y):\n pass","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def _calc_gradients(self, X, y, y_hat):\n # calculate gradient of weight and bias\n grad_b = 2 * np.mean(y_hat - y)\n grad_W = 2 * np.mean(np.matmul((y_hat - y), X))\n return grad_W, grad_b","def cost(self, X, y) :\n ### ========== TODO : START ========== ###\n # part d: compute J(theta)\n #we know for linear/polynomial regression, the cost is the square of the errors\n X = self.generate_polynomial_features(X)\n y_pred_vector = np.dot(X, self.coef_)\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\n ### ========== TODO : END ========== ###\n return cost","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def compute_cost(X, y, theta, lambd):\n assert(theta.shape[0] == X.shape[1])\n \n m = X.shape[0]\n grad = np.zeros(y.shape)\n J = 0\n \n output = sigmoid(np.dot(X, theta))\n\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\n\n grad = np.dot(X.T, (output - y)) / m\n \n grad[1:] = grad[1:] + lambd / m * theta[1:]\n\n return J, grad","def cost_func(w, X, y):\n y_pred = np.dot(X, w)\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\n\n return err","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def compute_square_loss_gradient(X, y, theta):\n #TODO\n (N,p) = np.shape(X)\n grad = -(1/np.float(N))*np.array([(y - X.dot(theta))*X[:,i] for i in range(p)])\n return np.sum(grad,axis=1)","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def get_cost_updates(self):\n\n y = self.get_hidden_values()\n z = self.get_reconstructed_input(y)\n\n L = T.sum((self.x-z)**2, axis=1)\n\n cost = T.mean(L)\n\n return cost","def cost_derivative(self, y_pred, Y, X):\n # Derivative of loss wrt b0\n D_b0 = -2 * sum((Y - y_pred) * y_pred * (1 - y_pred))\n # Derivative of loss wrt b1\n D_b1 = -2 * sum(X * (Y - y_pred) * y_pred * (1 - y_pred))\n return D_b0, D_b1","def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\n # compute cost\n A1 = x @ W + b0\n A2 = x @ V + b1\n z0 = sigmoid(A1)\n z1 = sigmoid(A2)\n z = np.array([z0, z1]).T\n A3 = z @ U + b2\n y = sigmoid(A3)\n if y0 is None:\n return y\n cost = np.sum((y - y0) ** 2)\n # compute gradient\n dy = 2 * (y - y0)\n dA3 = dy * (y * (1 - y))\n dz0 = dA3 * U[0]\n dz1 = dA3 * U[1]\n dA1 = dz0 * (z0 * (1 - z0))\n dA2 = dz1 * (z1 * (1 - z1))\n dW = x.T @ dA1\n dV = x.T @ dA2\n dU = z.T @ dA3\n db0 = np.sum(dA1)\n db1 = np.sum(dA2)\n db2 = np.sum(dA3)\n return cost, dW, dV, dU, db0, db1, db2","def compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\n #print theta, grad_theta, objective_function(theta, X, y)\n return grad_theta","def compute_square_loss_gradient(X, y, theta):\n #TODO\n P = (np.dot(X, theta)-y)\n m = X.shape[0]\n\n return (2/m)*np.dot(X.T, P)","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def __get_cost_value(self, Y_hat, Y):\n m = Y_hat.shape[1]\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\n return T.squeeze(cost)","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","def calc_cost(y, yhat, cost_matrix):\n return np.mean(cost_matrix[list(y), list(yhat)])","def approx_grad(theta, X, y):\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def compute_gradient(self, X, y, weights):\n sigmoid = self.sigmoid(np.dot(X, weights))\n return np.dot(X.T, y - sigmoid)","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def cost(self, X=None, y=None):\n\t\tif X is None:\n\t\t\tX = self.x_data\n\t\telse:\n\t\t\tn_samples = np.size(X, 0)\n\t\t\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\n\n\t\tif y is None:\n\t\t\ty = self.y_data\n\t\telse:\n\t\t\ty = y[:, np.newaxis]\n\n\t\ty_pred = X @ self.weights\n\n\t\t# SSE formula\n\t\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\n\n\t\treturn cost","def gradient_descent(x, y, theta=[[0], [0]]):\n m = y.size\n j_history = []\n for i in range(ITERATIONS):\n h = x.dot(theta)\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\n j_history.append(compute_cost(x, y, theta))\n return theta, j_history","def compute_cost(features, values, theta):\r\n m = len(values)\r\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\r\n cost = sum_of_square_errors / (2*m)\r\n\r\n return cost","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def gradientFunctionReg(theta, X, y, Lambda): \n y = np.squeeze(y)\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad[1:] = grad[1:] + Lambda*theta[1:]\n grad /= m\n\n return grad","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n \r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range(num_iterations):\r\n # your code here\r\n cost = compute_cost(features, values, theta)/(2.0*m)\r\n cost_history.append([cost])\r\n \r\n error = features.dot(theta) - values\r\n error = np.reshape(error,(error.shape[0], 1))\r\n errorWeighted = features*error\r\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\r\n theta = theta - alpha*errorSum \r\n \r\n return theta, pandas.Series(cost_history)","def compute_cost_gradient1(x, y0, W, b):\n # compute cost\n A = x @ W + b\n y = sigmoid(A)\n if y0 is None:\n return y\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\n # compute gradients\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\n dA = dy * (y * (1 - y))\n dW = x.T @ dA\n db = np.sum(dA)\n return cost, dW, db","def compute_cost(features, values, theta):\r\n \r\n # your code here\r\n error = (values - features.dot(theta))\r\n cost = error.dot(error) \r\n return cost","def gradientDescent(self,X, y, theta): \n # number of instances\n m = len(y)\n J_history = np.zeros((self.NUM_ITERS,1))\n for i in range(self.NUM_ITERS):\n h = self.sigmoid(X@theta)\n grad = 1 / m * X.T @ (h - y)\n theta = theta - self.ALPHA * grad \n J_history[i] = self.costFunction(theta, X, y)\n \n \n return theta, J_history","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","def calc_gradient(self, W, X, y, reg):\n\n N = X.shape[0]\n grad_W = np.zeros_like(W)\n I = np.ones((1,10))\n score = np.dot(X, W) # (N, C)\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\n #print(\"out\", out)\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\n \n dout = np.copy(out) # (N, C)\n dout[np.arange(N), y] -= 1\n grad_W = np.dot(X.T, dout) # (D, C)\n grad_W /= N\n #grad_W += reg * W\n \n return grad_W","def compute_cost(features, values, theta):\n m = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2 * m)\n\n return cost","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def cost(self, Y, A):\n loss1 = Y * np.log(A)\n m = Y.shape[1]\n cost = -1 * np.sum(loss1) / m\n return cost","def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\r\n # Step 0: Initialize the parameters\r\n n_samples, n_features = X.shape\r\n self.weights = np.zeros(shape=(n_features,1))\r\n self.bias = 0\r\n costs = []\r\n\r\n for i in range(n_iters):\r\n # Step 1: Compute a linear combination of the input features and weights\r\n y_predict = np.dot(X, self.weights) + self.bias\r\n\r\n # Step 2: Compute cost over training set\r\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\r\n costs.append(cost)\r\n\r\n if i % 100 == 0:\r\n print(f\"Cost at iteration {i}: {cost}\")\r\n\r\n # Step 3: Compute the gradients\r\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\r\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \r\n \r\n # Step 4: Update the parameters\r\n self.weights = self.weights - learning_rate * dJ_dw\r\n self.bias = self.bias - learning_rate * dJ_db\r\n\r\n return self.weights, self.bias, costs","def gradientFunctionReg(theta, X, y, Lambda):\n m = len(y) # number of training examples\n grad = np.zeros(theta.shape[0])\n theta = np.transpose(theta)\n sum_1 = 0\n X = X.values\n y = y.values\n #calcuate the theta_0 \n# ====================== YOUR CODE HERE ======================\n# Instructions: Compute the gradient of a particular choice of theta.\n# Compute the partial derivatives and set grad to the partial\n# derivatives of the cost w.r.t. each parameter in theta\n for i in range(theta.shape[0]):\n if i == 0:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\n else:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\n grad[i] = sum_1/m\n sum_1 = 0\n\n# =============================================================\n\n return grad","def compute_cost(features, values, theta):\n\n npoints = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2*npoints)\n\n return cost","def fit(self, X, y):\n\n n, m = X.shape[0], X.shape[1]\n\n # theta is (nx1) (one theta per dimension)\n self.theta = np.random.uniform(-10, 10, (n, 1))\n\n for i in range(self.epochs):\n # Get predictions\n y_pred = self.predict(X)\n\n # calculate cost\n # cost = ...\n cost = self._cost_function(y_pred, y, m)\n \n\n # gradient is an (n) x 1 array, it refers to the derivate per theta\n gradient = self._cost_function_derivative(y_pred, y, X, m)\n\n # delta/update rule\n self.theta = gradient\n\n self.costs.append(cost)\n pass\n\n print(\"Final theta is {} (cost: {})\".format(self.theta.T, cost))","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n\r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range (num_iterations):\r\n \r\n h = numpy.dot(features, theta)\r\n \r\n theta = theta - alpha / m * numpy.dot((h-values),features)\r\n \r\n cost = compute_cost(features, values, theta)\r\n \r\n cost_history.append(cost)\r\n\r\n return theta, pandas.Series(cost_history) # leave this line for the grader\r","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def compute_cost(AL, Y):\n pass","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def approx_grad_reg(theta, X, y, _lambda):\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def run_gradient_descent(data,theta,alpha,num_iters):\n population = data[:,0]\n prices = data[:,1]\n x = ones(shape=(len(population),2)) #add ones for theta0 \n x[:,1] = population\n x = transpose(x)\n error_history = zeros(shape=(num_iters,1))\n \n for i in range(num_iters):\n predictions = theta.dot(x)\n errors_x1 = (predictions - prices) * x[0,:]\n errors_x2 = (predictions - prices) * x[1,:]\n theta[0][0] = theta[0][0] - alpha*(1.0/len(population))*errors_x1.sum()\n theta[0][1] = theta[0][1] - alpha*(1.0/len(population))*errors_x2.sum()\n error_history[i,0] = calculate_cost(theta,data)\n \n return theta, error_history","def gradient_descent(X, Y, iterations, alpha, l = 0):\n \n # initialize B0, B1, ..., Bp\n betas = np.array([0.0]*(len(X[0])+1))\n \n # initialize list of cost vs iterations; should see a gradual descent\n costs = np.array([0.0]*iterations)\n \n # number of observations\n m = len(X)\n \n for i in range(iterations):\n sumterms = 1.0/m * ([estimation(xvec,betas) for xvec in X] - Y)\n errors = np.array([0.0]*len(betas))\n errors[0] = sum(sumterms) # error term for B0 has no multiplier\n for k in range(1,len(betas)):\n errors[k] = np.dot(sumterms, [row[k-1] for row in X]) + l/m*betas[k]\n \n betas = betas - alpha * errors\n costs[i] = cost(X, Y, betas, l)\n \n return betas, costs","def gradient_loss_and_output(self, a_o, y):\n if self.regression:\n return 2*(a_o - y)\n else:\n return -y / (1 + np.exp(y * a_o))","def calculate_cost(theta_values, data):\n population = data[:,0]\n prices = data[:,1]\n total_error = 0\n for i in range(0,len(population)):\n x = array([[1],[population[i]]])\n hypothesis = theta_values.dot(x).flatten() \n squared_error = (hypothesis - prices[i])**2\n total_error += squared_error\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def compute_cost(AL, Y):\n \n m = Y.shape[1]\n\n # Compute loss from aL and y.\n ### START CODE HERE ### (≈ 1 lines of code)\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\n ### END CODE HERE ###\n \n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n assert(cost.shape == ())\n \n return cost","def compute_loss_and_gradients(self, X, y):\n # TODO Compute loss and fill param gradients\n # by running forward and backward passes through the model","def optimize(self, X, Y):\n\n costs = []\n\n for i in range(self.epochs):\n\n grads, cost = self.propagate(X, Y)\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n self.w -= self.learning_rate * dw\n self.b -= self.learning_rate * db\n\n if i % 100 == 0:\n\n costs.append(cost)\n\n return costs","def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and the gradient. Store the gradient\n # as the variable grad.\n # ================================================================ #\n \n exp_a = np.zeros((num_classes,num_train))\n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n \n #if i==0:\n grada = np.zeros(X.shape[1])\n \n for j in range(num_classes):\n if j != y[i]:\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \n else: \n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \n\n grad += grad_tmp\n loss += Loss \n \n pass\n\n\n loss /= num_train\n grad /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def compute_cost(AL, Y):\n m = Y.shape[1]\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\n cost = np.sum(log_val) * (-1/m)\n cost = np.squeeze(cost)\n return cost","def calc_grad(X, Y, theta):\n m, n = X.shape\n\n margins = Y * X.dot(theta)\n probs = 1. / (1 + np.exp(margins))\n grad = -(1./m) * (X.T.dot(probs * Y))\n\n return grad","def compute_cost(self, AL, Y):\n m = Y.shape[1]\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\n cost = np.squeeze(cost)\n\n return cost","def compute_cost(AL, Y):\n pass","def compute_regularized_square_loss_gradient(X, y, theta, lambda_reg):\n #TODO\n P = (np.dot(X, theta)-y)\n m = X.shape[0]\n\n return (2/m)*np.dot(X.T, P)+(2*lambda_reg*theta)","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n\n cur_cost = float(\"inf\")\n tolerance = 10 ** -6\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n while abs(new_cost - cur_cost) > tolerance:\n cur_cost = new_cost\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\n self.weights = self.weights - (step_size * gradient)\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n\n #Format properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def compute_gradient_and_loss2(W, X, y, reg, reg_type, opt):\n if opt == 0: # compute gradient only if opt == 0\n dW = np.zeros(W.shape) # initialize the gradient as zero\n \n # compute the loss and the gradient\n num_classes = W.shape[1]\n num_train = X.shape[0]\n loss = 0.0\n #############################################################################\n # TODO: #\n # Implement the routine to compute the loss, storing the result in loss #\n ############################################################################# \n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\n s = X[i].dot(W) # compute s (scores)\n s_y = s[y[i]] # keep the correct ground truth class score\n max_sj = -999\n argmax_sj = -1\n local_loss = 0.0\n for j in xrange(num_classes): # for every class \n if j == y[i]: # don't take the correct ground truth index\n continue\n if s[j] > max_sj:\n max_sj = s[j]\n argmax_sj = j\n\n term = 1 + max_sj - s_y # max term with Delta = 1, according to Hinge loss formula \n\n for j in xrange(num_classes): # for every class \n if j == y[i]: # don't take the correct ground truth index\n continue\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\n local_loss = term # add the possitive term \n if opt == 0: # compute gradient only if opt == 0\n if j == argmax_sj:\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\n dW[:, y[i]] -= X[i] # case j==y[i]\n \n loss += local_loss \n\n# loss /= num_train # num_train = M, according to given formula \n\n if reg_type == 1: # loss + regularization , l2 or l1\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\n else:\n loss += reg * np.sum(W * W) # l2\n \n if opt == 0: # compute gradient only if opt == 0\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\n if reg_type == 1: # we use deriv_abs function for l1 derivative\n dW[:,-1] += reg * deriv_abs(W[:,-1]) #dW[:,-1]\n else:\n dW[:,-1] += 2 * reg * W[:,-1] # l2 derivative formula\n \n return loss, dW\n else:\n return loss, None\n \n print 'CSFAK INSIDE compute_gradient_and_loss'\n #############################################################################\n # TODO: #\n # Implement the gradient for the required loss, storing the result in dW.\t #\n # #\n # Hint: Instead of computing the gradient from scratch, it may be easier #\n # to reuse some of the intermediate values that you used to compute the #\n # loss. #\n #############################################################################\n \n #pass\n\n #############################################################################\n # END OF YOUR CODE #\n ############################################################################# ","def compute_gradient_and_loss(W, X, y, reg, reg_type, opt):\n if opt == 0: # compute gradient only if opt == 0\n dW = np.zeros(W.shape) # initialize the gradient as zero\n \n # compute the loss and the gradient\n num_classes = W.shape[1]\n num_train = X.shape[0]\n loss = 0.0\n #############################################################################\n # TODO: #\n # Implement the routine to compute the loss, storing the result in loss #\n ############################################################################# \n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\n s = X[i].dot(W) # compute s (scores)\n s_y = s[y[i]] # keep the correct ground truth class score\n max_sj = -999\n argmax_sj = -1\n local_loss = 0.0\n for j in xrange(num_classes): # for every class \n if j != y[i]: # don't take the correct ground truth index\n if s[j] > max_sj:\n max_sj = s[j]\n argmax_sj = j\n\n term = 1 + max_sj - s_y # max term with Delta = 1, according to Hinge loss formula \n \n if term > 0:\n local_loss = term\n \n loss += local_loss\n \n for j in xrange(num_classes): # for every class \n if j != y[i]: # don't take the correct ground truth index\n if opt == 0: # compute gradient only if opt == 0\n if j == argmax_sj:\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\n dW[:, y[i]] -= X[i] # case j==y[i]\n \n \n\n# loss /= num_train # num_train = M, according to given formula \n\n if reg_type == 1: # loss + regularization , l2 or l1\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\n else:\n loss += reg * np.sum(W * W) # l2\n \n if opt == 0: # compute gradient only if opt == 0\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\n if reg_type == 1: # we use deriv_abs function for l1 derivative\n# dW += reg * deriv_abs(W) #dW[:,-1]\n# else:\n# dW += 2 * reg * W # l2 derivative formula \n dW[:-1,:] += reg * np.sign((W[:-1,:])) #dW[:,-1]\n else:\n dW[:-1,:] += 2 * reg * W[:-1,:] # l2 derivative formula \n return loss, dW\n else:\n return loss, None\n \n print 'CSFAK INSIDE compute_gradient_and_loss'\n #############################################################################\n # TODO: #\n # Implement the gradient for the required loss, storing the result in dW.\t #\n # #\n # Hint: Instead of computing the gradient from scratch, it may be easier #\n # to reuse some of the intermediate values that you used to compute the #\n # loss. #\n #############################################################################\n \n #pass\n\n #############################################################################\n # END OF YOUR CODE #\n ############################################################################# ","def calculate_gradients(self, X, Y):\n Z1 = np.matmul(self.weights[0], X) + self.biases[0] #(30, m)\n A1 = sigmoid(Z1) #(30, m)\n Z2 = np.matmul(self.weights[1], A1) + self.biases[1] #(10, m)\n A2 = sigmoid(Z2) #(10, m)\n # number of examples\n m = X.shape[1]\n dZ2 = A2 - Y #(784, m)\n dW2 = (1 / m) * np.matmul(dZ2, A1.T) #(10, 30)\n db2 = (1 / m) * np.sum(dZ2, axis = 1, keepdims = True) #(10, 1)\n dZ1 = np.multiply(np.matmul(self.weights[1].T, dZ2), sigmoid_deri(Z1)) #(30, m)\n dW1 = (1 / m) * np.matmul(dZ1, X.T) #(30, 784)\n db1 = (1 / m) * np.sum(dZ1, axis = 1, keepdims = True) #(30, 1)\n \n grads = {\"dW1\":dW1, \"db1\":db1, \"dW2\":dW2, \"db2\":db2} \n return grads","def deriv_costFunction(self, x, y):\n self.yEst = self.forward_propagate(x)\n\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\n #partial deriv of cost wrt hidden -> output weights\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\n\n ones_o = np.ones( delta_o.shape[0] )\n #partial deriv of cost wrt output biases\n partial_J_b_o = np.dot( ones_o, delta_o )\n\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\n #partial deriv of cost wrt input -> hidden weights\n partial_J_w_ih = np.dot( x.T, delta_h )\n \n ones_h = np.ones( delta_h.shape[0] )\n #partial deriv of cost wrt hidden biases\n partial_J_b_h = np.dot( ones_h, delta_h)\n\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o","def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\n\n # Cost history\n cost_tracking = np.zeros(nb_iterations)\n\n for _i in range(nb_iterations):\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\n # recording the cost for each iteration\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\n\n return parameters, cost_tracking","def compute_regularized_square_loss_gradient(X, y, theta, lambda_reg):\n return compute_square_loss_gradient(X,y,theta) + 2*lambda_reg*theta","def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # You need to return the following variable correctly.\n grad = np.zeros(theta.shape)\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the partial derivatives and set grad to the partial\n # derivatives of the cost w.r.t. each parameter in theta.\n\n # =============================================================\n return grad","def GD_method(self, X, Y):\n X = self.normalize(X)\n for epoch in range(self.epochs):\n y_pred = self.logistic_function(X, self.b0, self.b1)\n D_b0, D_b1 = self.cost_derivative(y_pred, Y, X)\n # Update Weights\n self.b0 = self.b0 - self.learning_rate * D_b0\n self.b1 = self.b1 - self.learning_rate * D_b1\n y_pred = self.predict(X)\n self.evaluate(y_pred, Y)","def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\n TrainingTarget, TestData, ValData):\n # Gradient Descent Solution for Linear Regression\n La = 2\n # learningRate = 0.01\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\n\n for i in range(0, 400):\n\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\n Delta_E_D = -np.dot(\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\n TRAINING_PHI[i])\n La_Delta_E_W = np.dot(La, W_Now)\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\n Delta_W = -np.dot(learningRate, Delta_E)\n W_T_Next = W_Now + Delta_W\n W_Now = W_T_Next\n\n #-----------------TrainingData Accuracy---------------------#\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\n\n #-----------------ValidationData Accuracy---------------------#\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\n\n #-----------------TestingData Accuracy---------------------#\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\n\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])","def loss(self, X, Y, lmd):\n P, _ = self.forward(X)\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\n\n reg = 0 # Regularization term\n for w in self.W:\n reg += np.sum(np.square(w))\n\n reg *= lmd\n\n cost = loss + reg\n\n return cost","def gradient_descent(self, X, theta, Y, m):\n\n Z = X.dot(theta)\n H = Predict.g(Z)\n gradient = np.dot(X.T, (H - Y)) / m\n return self.alpha * gradient","def mse_grad(y, y_hat, d_y_hat):\n n = y.shape[0]\n error = (y_hat - y) / n\n\n if isinstance(d_y_hat, list):\n # print([d_y_hat_.shape for d_y_hat_ in d_y_hat])\n loss_grad = [np.dot(error.T, d_y_hat_) if d_y_hat_.shape[0] > 0 else np.array([]) for d_y_hat_ in d_y_hat]\n return loss_grad\n else:\n loss_grad = np.dot(error.T, d_y_hat)\n return loss_grad","def gradient_descent(features, values, theta, alpha, num_iterations):\n m = len(values)\n cost_history = []\n\n for i in range(num_iterations):\n predicted_values = np.dot(features, theta)\n delta = alpha / m * np.dot((predicted_values - values), features)\n theta = theta - delta\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n return theta, pandas.Series(cost_history)","def compute_gradient_and_loss1(W, X, y, reg, reg_type, opt):\n if opt == 0: # compute gradient only if opt == 0\n dW = np.zeros(W.shape) # initialize the gradient as zero\n \n # compute the loss and the gradient\n num_classes = W.shape[1]\n num_train = X.shape[0]\n loss = 0.0\n #############################################################################\n # TODO: #\n # Implement the routine to compute the loss, storing the result in loss #\n ############################################################################# \n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\n s = X[i].dot(W) # compute s (scores)\n s_y = s[y[i]] # keep the correct ground truth class score\n for j in xrange(num_classes): # for every class\n if j != y[i]: # don't take the correct ground truth index\n term = s[j] - s_y + 1 # max term with Delta = 1, according to Hinge loss formula\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\n loss += term # add the possitive term \n if opt == 0: # compute gradient only if opt == 0\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\n dW[:, y[i]] -= X[i] # case j==y[i]\n\n# loss /= num_train # num_train = M, according to given formula \n\n if reg_type == 1: # loss + regularization , l2 or l1\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\n else:\n loss += reg * np.sum(W * W) # l2\n \n if opt == 0: # compute gradient only if opt == 0\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\n if reg_type == 1: # we use deriv_abs function for l1 derivative\n dW += reg * deriv_abs(W)\n else:\n dW += 2 * reg * W # l2 derivative formula\n \n return loss, dW\n else:\n return loss, None\n \n print 'CSFAK INSIDE compute_gradient_and_loss'\n #############################################################################\n # TODO: #\n # Implement the gradient for the required loss, storing the result in dW.\t #\n # #\n # Hint: Instead of computing the gradient from scratch, it may be easier #\n # to reuse some of the intermediate values that you used to compute the #\n # loss. #\n #############################################################################\n \n #pass\n\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n epochs = 1000\n\n for epoch in range(epochs):\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\n data_set = np.append(Xless, y, axis=1)\n np.random.shuffle(data_set)\n Xless = data_set[:, 0:data_set.shape[1] - 1]\n y = data_set[:, -1, np.newaxis]\n for t in range(numsamples):\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\n step_size = 0.01 / (epoch + 1)\n self.weights = self.weights - (step_size * gradient)\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\n #Format the array properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def computeGradient(self, X, y, w):\n n = len(X)\n if self.loss == 'linear':\n gradient = -2 * np.dot(X.T, (y - X.dot(w)))\n elif self.loss == 'logistic':\n g = self.logistic(X, w)\n gradient = -2 * np.dot(X.T, (y - g) * g * (1 - g))\n elif self.loss == 'perceptron':\n newY = (y > 0).astype(int) * 2 - 1 # change from (0, 1) to (-1, 1)\n index = ((np.dot(X, w) >= 0).astype(int) != y)\n usedX = X[index[:, 0]]\n usedY = newY[index[:, 0]]\n gradient = -np.dot(usedX.T, usedY)\n elif self.loss == 'svm':\n newY = (y > 0).astype(int) * 2 - 1 # change from (0, 1) to (-1, 1)\n index = (np.dot(X, w) * newY < 1)\n usedX = X[index[:, 0]]\n usedY = newY[index[:, 0]]\n gradient = 2 * w - self.C * np.dot(usedX.T, usedY)\n gradient[0] = gradient[0] + 2 * w[0]\n\n return gradient","def square_loss_grad(X, Y, W):\n return 2.0 / X.shape[0] * np.dot(X.T, (np.dot(X, W) - Y))","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n y_hat = softmax(np.dot(outputVectors,predicted))\n y = np.zeros(outputVectors.shape[0])\n y[target] = 1.0\n\n cost = -np.log(y_hat[target])\n gradPred = np.dot(outputVectors.T,y_hat - y)\n grad = np.outer(y_hat - y,predicted)\n ### END YOUR CODE\n\n return cost, gradPred, grad","def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\n A = np.dot(self.X, self.w)\n m = self.t.shape[0]\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\n return (1 / m) * np.dot(self.X.T, C)","def cost_derivative(output_activations, y):\n return (output_activations - y)","def cost(self, Y, Y_hat):\n\n total = self.kl(Y=Y, Y_hat=Y_hat)\n\n ave = total.mean()\n #ave = T.cast(ave, dtype='float32')\n return ave","def costFunctionReg(theta, X, y, Lambda):\n # Initialize some useful values\n m = len(y) # number of training examples\n j = costFunction(theta, X, y)\n j += (Lambda/(2*m))*np.sum(theta[1:]**2)\n return j","def gradient_descent(regression_type, trainingData, theta,\n maxIter, learningRate):\n regression = None\n\n if(regression_type == 1):\n regression = LinearRegression()\n\n all_costs = zeros(maxIter)\n\n for num_iter in range(maxIter):\n\n gradient = regression.calculateGradient(trainingData, theta)\n gradient = gradient*learningRate\n\n theta = theta - gradient\n\n all_costs[num_iter] = regression.calculateCost(trainingData, theta)\n\n return (all_costs, theta)","def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\n theta_list = []\n cost_list = []\n\n theta = initial_theta\n for i in range(0, niter):\n theta -= alpha*gradient(theta, X, y, Lambda)\n theta_list.append(theta)\n cost_list.append(cost(theta, X, y, Lambda))\n\n return theta_list, cost_list","def get_cost(self):\n\n\t\tx = self.symbolic_input\n\t\ty = self.get_reconstructed_input()\n\n\t\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\n\t\t\t(1-x)*theano.tensor.log(1-y), axis=1)\n\n\t\tmean_loss = theano.tensor.mean(negative_log_loss)\n\n\t\treturn mean_loss"],"string":"[\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_cost(Y_hat, Y):\\r\\n\\r\\n m = Y.shape[1]\\r\\n\\r\\n\\r\\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\\r\\n\\r\\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\r\\n\\r\\n return cost\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\\n m = X.shape[0]\\n y_hat = sigmoid(X @ theta.T)\\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\\n temp = theta\\n temp[0] = 0\\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\\n return J, grad\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def _calc_gradients(self, X, y, y_hat):\\n # calculate gradient of weight and bias\\n grad_b = 2 * np.mean(y_hat - y)\\n grad_W = 2 * np.mean(np.matmul((y_hat - y), X))\\n return grad_W, grad_b\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def compute_cost(X, y, theta, lambd):\\n assert(theta.shape[0] == X.shape[1])\\n \\n m = X.shape[0]\\n grad = np.zeros(y.shape)\\n J = 0\\n \\n output = sigmoid(np.dot(X, theta))\\n\\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\\n\\n grad = np.dot(X.T, (output - y)) / m\\n \\n grad[1:] = grad[1:] + lambd / m * theta[1:]\\n\\n return J, grad\",\n \"def cost_func(w, X, y):\\n y_pred = np.dot(X, w)\\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\\n\\n return err\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def compute_square_loss_gradient(X, y, theta):\\n #TODO\\n (N,p) = np.shape(X)\\n grad = -(1/np.float(N))*np.array([(y - X.dot(theta))*X[:,i] for i in range(p)])\\n return np.sum(grad,axis=1)\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def get_cost_updates(self):\\n\\n y = self.get_hidden_values()\\n z = self.get_reconstructed_input(y)\\n\\n L = T.sum((self.x-z)**2, axis=1)\\n\\n cost = T.mean(L)\\n\\n return cost\",\n \"def cost_derivative(self, y_pred, Y, X):\\n # Derivative of loss wrt b0\\n D_b0 = -2 * sum((Y - y_pred) * y_pred * (1 - y_pred))\\n # Derivative of loss wrt b1\\n D_b1 = -2 * sum(X * (Y - y_pred) * y_pred * (1 - y_pred))\\n return D_b0, D_b1\",\n \"def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\\n # compute cost\\n A1 = x @ W + b0\\n A2 = x @ V + b1\\n z0 = sigmoid(A1)\\n z1 = sigmoid(A2)\\n z = np.array([z0, z1]).T\\n A3 = z @ U + b2\\n y = sigmoid(A3)\\n if y0 is None:\\n return y\\n cost = np.sum((y - y0) ** 2)\\n # compute gradient\\n dy = 2 * (y - y0)\\n dA3 = dy * (y * (1 - y))\\n dz0 = dA3 * U[0]\\n dz1 = dA3 * U[1]\\n dA1 = dz0 * (z0 * (1 - z0))\\n dA2 = dz1 * (z1 * (1 - z1))\\n dW = x.T @ dA1\\n dV = x.T @ dA2\\n dU = z.T @ dA3\\n db0 = np.sum(dA1)\\n db1 = np.sum(dA2)\\n db2 = np.sum(dA3)\\n return cost, dW, dV, dU, db0, db1, db2\",\n \"def compute_gradient(theta, X, y):\\n m = X.shape[0]\\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\\n #print theta, grad_theta, objective_function(theta, X, y)\\n return grad_theta\",\n \"def compute_square_loss_gradient(X, y, theta):\\n #TODO\\n P = (np.dot(X, theta)-y)\\n m = X.shape[0]\\n\\n return (2/m)*np.dot(X.T, P)\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def __get_cost_value(self, Y_hat, Y):\\n m = Y_hat.shape[1]\\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\\n return T.squeeze(cost)\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\n \"def calc_cost(y, yhat, cost_matrix):\\n return np.mean(cost_matrix[list(y), list(yhat)])\",\n \"def approx_grad(theta, X, y):\\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def compute_gradient(self, X, y, weights):\\n sigmoid = self.sigmoid(np.dot(X, weights))\\n return np.dot(X.T, y - sigmoid)\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def cost(self, X=None, y=None):\\n\\t\\tif X is None:\\n\\t\\t\\tX = self.x_data\\n\\t\\telse:\\n\\t\\t\\tn_samples = np.size(X, 0)\\n\\t\\t\\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\\n\\n\\t\\tif y is None:\\n\\t\\t\\ty = self.y_data\\n\\t\\telse:\\n\\t\\t\\ty = y[:, np.newaxis]\\n\\n\\t\\ty_pred = X @ self.weights\\n\\n\\t\\t# SSE formula\\n\\t\\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\\n\\n\\t\\treturn cost\",\n \"def gradient_descent(x, y, theta=[[0], [0]]):\\n m = y.size\\n j_history = []\\n for i in range(ITERATIONS):\\n h = x.dot(theta)\\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\\n j_history.append(compute_cost(x, y, theta))\\n return theta, j_history\",\n \"def compute_cost(features, values, theta):\\r\\n m = len(values)\\r\\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\\r\\n cost = sum_of_square_errors / (2*m)\\r\\n\\r\\n return cost\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def gradientFunctionReg(theta, X, y, Lambda): \\n y = np.squeeze(y)\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad[1:] = grad[1:] + Lambda*theta[1:]\\n grad /= m\\n\\n return grad\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n \\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range(num_iterations):\\r\\n # your code here\\r\\n cost = compute_cost(features, values, theta)/(2.0*m)\\r\\n cost_history.append([cost])\\r\\n \\r\\n error = features.dot(theta) - values\\r\\n error = np.reshape(error,(error.shape[0], 1))\\r\\n errorWeighted = features*error\\r\\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\\r\\n theta = theta - alpha*errorSum \\r\\n \\r\\n return theta, pandas.Series(cost_history)\",\n \"def compute_cost_gradient1(x, y0, W, b):\\n # compute cost\\n A = x @ W + b\\n y = sigmoid(A)\\n if y0 is None:\\n return y\\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\\n # compute gradients\\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\\n dA = dy * (y * (1 - y))\\n dW = x.T @ dA\\n db = np.sum(dA)\\n return cost, dW, db\",\n \"def compute_cost(features, values, theta):\\r\\n \\r\\n # your code here\\r\\n error = (values - features.dot(theta))\\r\\n cost = error.dot(error) \\r\\n return cost\",\n \"def gradientDescent(self,X, y, theta): \\n # number of instances\\n m = len(y)\\n J_history = np.zeros((self.NUM_ITERS,1))\\n for i in range(self.NUM_ITERS):\\n h = self.sigmoid(X@theta)\\n grad = 1 / m * X.T @ (h - y)\\n theta = theta - self.ALPHA * grad \\n J_history[i] = self.costFunction(theta, X, y)\\n \\n \\n return theta, J_history\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\n \"def calc_gradient(self, W, X, y, reg):\\n\\n N = X.shape[0]\\n grad_W = np.zeros_like(W)\\n I = np.ones((1,10))\\n score = np.dot(X, W) # (N, C)\\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\\n #print(\\\"out\\\", out)\\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\\n \\n dout = np.copy(out) # (N, C)\\n dout[np.arange(N), y] -= 1\\n grad_W = np.dot(X.T, dout) # (D, C)\\n grad_W /= N\\n #grad_W += reg * W\\n \\n return grad_W\",\n \"def compute_cost(features, values, theta):\\n m = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2 * m)\\n\\n return cost\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def cost(self, Y, A):\\n loss1 = Y * np.log(A)\\n m = Y.shape[1]\\n cost = -1 * np.sum(loss1) / m\\n return cost\",\n \"def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\\r\\n # Step 0: Initialize the parameters\\r\\n n_samples, n_features = X.shape\\r\\n self.weights = np.zeros(shape=(n_features,1))\\r\\n self.bias = 0\\r\\n costs = []\\r\\n\\r\\n for i in range(n_iters):\\r\\n # Step 1: Compute a linear combination of the input features and weights\\r\\n y_predict = np.dot(X, self.weights) + self.bias\\r\\n\\r\\n # Step 2: Compute cost over training set\\r\\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\\r\\n costs.append(cost)\\r\\n\\r\\n if i % 100 == 0:\\r\\n print(f\\\"Cost at iteration {i}: {cost}\\\")\\r\\n\\r\\n # Step 3: Compute the gradients\\r\\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\\r\\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \\r\\n \\r\\n # Step 4: Update the parameters\\r\\n self.weights = self.weights - learning_rate * dJ_dw\\r\\n self.bias = self.bias - learning_rate * dJ_db\\r\\n\\r\\n return self.weights, self.bias, costs\",\n \"def gradientFunctionReg(theta, X, y, Lambda):\\n m = len(y) # number of training examples\\n grad = np.zeros(theta.shape[0])\\n theta = np.transpose(theta)\\n sum_1 = 0\\n X = X.values\\n y = y.values\\n #calcuate the theta_0 \\n# ====================== YOUR CODE HERE ======================\\n# Instructions: Compute the gradient of a particular choice of theta.\\n# Compute the partial derivatives and set grad to the partial\\n# derivatives of the cost w.r.t. each parameter in theta\\n for i in range(theta.shape[0]):\\n if i == 0:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\\n else:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\\n grad[i] = sum_1/m\\n sum_1 = 0\\n\\n# =============================================================\\n\\n return grad\",\n \"def compute_cost(features, values, theta):\\n\\n npoints = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2*npoints)\\n\\n return cost\",\n \"def fit(self, X, y):\\n\\n n, m = X.shape[0], X.shape[1]\\n\\n # theta is (nx1) (one theta per dimension)\\n self.theta = np.random.uniform(-10, 10, (n, 1))\\n\\n for i in range(self.epochs):\\n # Get predictions\\n y_pred = self.predict(X)\\n\\n # calculate cost\\n # cost = ...\\n cost = self._cost_function(y_pred, y, m)\\n \\n\\n # gradient is an (n) x 1 array, it refers to the derivate per theta\\n gradient = self._cost_function_derivative(y_pred, y, X, m)\\n\\n # delta/update rule\\n self.theta = gradient\\n\\n self.costs.append(cost)\\n pass\\n\\n print(\\\"Final theta is {} (cost: {})\\\".format(self.theta.T, cost))\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n\\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range (num_iterations):\\r\\n \\r\\n h = numpy.dot(features, theta)\\r\\n \\r\\n theta = theta - alpha / m * numpy.dot((h-values),features)\\r\\n \\r\\n cost = compute_cost(features, values, theta)\\r\\n \\r\\n cost_history.append(cost)\\r\\n\\r\\n return theta, pandas.Series(cost_history) # leave this line for the grader\\r\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def approx_grad_reg(theta, X, y, _lambda):\\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def run_gradient_descent(data,theta,alpha,num_iters):\\n population = data[:,0]\\n prices = data[:,1]\\n x = ones(shape=(len(population),2)) #add ones for theta0 \\n x[:,1] = population\\n x = transpose(x)\\n error_history = zeros(shape=(num_iters,1))\\n \\n for i in range(num_iters):\\n predictions = theta.dot(x)\\n errors_x1 = (predictions - prices) * x[0,:]\\n errors_x2 = (predictions - prices) * x[1,:]\\n theta[0][0] = theta[0][0] - alpha*(1.0/len(population))*errors_x1.sum()\\n theta[0][1] = theta[0][1] - alpha*(1.0/len(population))*errors_x2.sum()\\n error_history[i,0] = calculate_cost(theta,data)\\n \\n return theta, error_history\",\n \"def gradient_descent(X, Y, iterations, alpha, l = 0):\\n \\n # initialize B0, B1, ..., Bp\\n betas = np.array([0.0]*(len(X[0])+1))\\n \\n # initialize list of cost vs iterations; should see a gradual descent\\n costs = np.array([0.0]*iterations)\\n \\n # number of observations\\n m = len(X)\\n \\n for i in range(iterations):\\n sumterms = 1.0/m * ([estimation(xvec,betas) for xvec in X] - Y)\\n errors = np.array([0.0]*len(betas))\\n errors[0] = sum(sumterms) # error term for B0 has no multiplier\\n for k in range(1,len(betas)):\\n errors[k] = np.dot(sumterms, [row[k-1] for row in X]) + l/m*betas[k]\\n \\n betas = betas - alpha * errors\\n costs[i] = cost(X, Y, betas, l)\\n \\n return betas, costs\",\n \"def gradient_loss_and_output(self, a_o, y):\\n if self.regression:\\n return 2*(a_o - y)\\n else:\\n return -y / (1 + np.exp(y * a_o))\",\n \"def calculate_cost(theta_values, data):\\n population = data[:,0]\\n prices = data[:,1]\\n total_error = 0\\n for i in range(0,len(population)):\\n x = array([[1],[population[i]]])\\n hypothesis = theta_values.dot(x).flatten() \\n squared_error = (hypothesis - prices[i])**2\\n total_error += squared_error\\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n \\n m = Y.shape[1]\\n\\n # Compute loss from aL and y.\\n ### START CODE HERE ### (≈ 1 lines of code)\\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\\n ### END CODE HERE ###\\n \\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\n assert(cost.shape == ())\\n \\n return cost\",\n \"def compute_loss_and_gradients(self, X, y):\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\",\n \"def optimize(self, X, Y):\\n\\n costs = []\\n\\n for i in range(self.epochs):\\n\\n grads, cost = self.propagate(X, Y)\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n self.w -= self.learning_rate * dw\\n self.b -= self.learning_rate * db\\n\\n if i % 100 == 0:\\n\\n costs.append(cost)\\n\\n return costs\",\n \"def loss_and_grad(self, X, y):\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n grad = np.zeros_like(self.W)\\n grad_tmp = np.zeros_like(self.W)\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and the gradient. Store the gradient\\n # as the variable grad.\\n # ================================================================ #\\n \\n exp_a = np.zeros((num_classes,num_train))\\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n \\n #if i==0:\\n grada = np.zeros(X.shape[1])\\n \\n for j in range(num_classes):\\n if j != y[i]:\\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \\n else: \\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \\n\\n grad += grad_tmp\\n loss += Loss \\n \\n pass\\n\\n\\n loss /= num_train\\n grad /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def compute_cost(AL, Y):\\n m = Y.shape[1]\\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\\n cost = np.sum(log_val) * (-1/m)\\n cost = np.squeeze(cost)\\n return cost\",\n \"def calc_grad(X, Y, theta):\\n m, n = X.shape\\n\\n margins = Y * X.dot(theta)\\n probs = 1. / (1 + np.exp(margins))\\n grad = -(1./m) * (X.T.dot(probs * Y))\\n\\n return grad\",\n \"def compute_cost(self, AL, Y):\\n m = Y.shape[1]\\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\\n cost = np.squeeze(cost)\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def compute_regularized_square_loss_gradient(X, y, theta, lambda_reg):\\n #TODO\\n P = (np.dot(X, theta)-y)\\n m = X.shape[0]\\n\\n return (2/m)*np.dot(X.T, P)+(2*lambda_reg*theta)\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n\\n cur_cost = float(\\\"inf\\\")\\n tolerance = 10 ** -6\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n while abs(new_cost - cur_cost) > tolerance:\\n cur_cost = new_cost\\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\\n self.weights = self.weights - (step_size * gradient)\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n\\n #Format properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def compute_gradient_and_loss2(W, X, y, reg, reg_type, opt):\\n if opt == 0: # compute gradient only if opt == 0\\n dW = np.zeros(W.shape) # initialize the gradient as zero\\n \\n # compute the loss and the gradient\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n loss = 0.0\\n #############################################################################\\n # TODO: #\\n # Implement the routine to compute the loss, storing the result in loss #\\n ############################################################################# \\n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\\n s = X[i].dot(W) # compute s (scores)\\n s_y = s[y[i]] # keep the correct ground truth class score\\n max_sj = -999\\n argmax_sj = -1\\n local_loss = 0.0\\n for j in xrange(num_classes): # for every class \\n if j == y[i]: # don't take the correct ground truth index\\n continue\\n if s[j] > max_sj:\\n max_sj = s[j]\\n argmax_sj = j\\n\\n term = 1 + max_sj - s_y # max term with Delta = 1, according to Hinge loss formula \\n\\n for j in xrange(num_classes): # for every class \\n if j == y[i]: # don't take the correct ground truth index\\n continue\\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\\n local_loss = term # add the possitive term \\n if opt == 0: # compute gradient only if opt == 0\\n if j == argmax_sj:\\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\\n dW[:, y[i]] -= X[i] # case j==y[i]\\n \\n loss += local_loss \\n\\n# loss /= num_train # num_train = M, according to given formula \\n\\n if reg_type == 1: # loss + regularization , l2 or l1\\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\\n else:\\n loss += reg * np.sum(W * W) # l2\\n \\n if opt == 0: # compute gradient only if opt == 0\\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\\n if reg_type == 1: # we use deriv_abs function for l1 derivative\\n dW[:,-1] += reg * deriv_abs(W[:,-1]) #dW[:,-1]\\n else:\\n dW[:,-1] += 2 * reg * W[:,-1] # l2 derivative formula\\n \\n return loss, dW\\n else:\\n return loss, None\\n \\n print 'CSFAK INSIDE compute_gradient_and_loss'\\n #############################################################################\\n # TODO: #\\n # Implement the gradient for the required loss, storing the result in dW.\\t #\\n # #\\n # Hint: Instead of computing the gradient from scratch, it may be easier #\\n # to reuse some of the intermediate values that you used to compute the #\\n # loss. #\\n #############################################################################\\n \\n #pass\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n ############################################################################# \",\n \"def compute_gradient_and_loss(W, X, y, reg, reg_type, opt):\\n if opt == 0: # compute gradient only if opt == 0\\n dW = np.zeros(W.shape) # initialize the gradient as zero\\n \\n # compute the loss and the gradient\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n loss = 0.0\\n #############################################################################\\n # TODO: #\\n # Implement the routine to compute the loss, storing the result in loss #\\n ############################################################################# \\n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\\n s = X[i].dot(W) # compute s (scores)\\n s_y = s[y[i]] # keep the correct ground truth class score\\n max_sj = -999\\n argmax_sj = -1\\n local_loss = 0.0\\n for j in xrange(num_classes): # for every class \\n if j != y[i]: # don't take the correct ground truth index\\n if s[j] > max_sj:\\n max_sj = s[j]\\n argmax_sj = j\\n\\n term = 1 + max_sj - s_y # max term with Delta = 1, according to Hinge loss formula \\n \\n if term > 0:\\n local_loss = term\\n \\n loss += local_loss\\n \\n for j in xrange(num_classes): # for every class \\n if j != y[i]: # don't take the correct ground truth index\\n if opt == 0: # compute gradient only if opt == 0\\n if j == argmax_sj:\\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\\n dW[:, y[i]] -= X[i] # case j==y[i]\\n \\n \\n\\n# loss /= num_train # num_train = M, according to given formula \\n\\n if reg_type == 1: # loss + regularization , l2 or l1\\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\\n else:\\n loss += reg * np.sum(W * W) # l2\\n \\n if opt == 0: # compute gradient only if opt == 0\\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\\n if reg_type == 1: # we use deriv_abs function for l1 derivative\\n# dW += reg * deriv_abs(W) #dW[:,-1]\\n# else:\\n# dW += 2 * reg * W # l2 derivative formula \\n dW[:-1,:] += reg * np.sign((W[:-1,:])) #dW[:,-1]\\n else:\\n dW[:-1,:] += 2 * reg * W[:-1,:] # l2 derivative formula \\n return loss, dW\\n else:\\n return loss, None\\n \\n print 'CSFAK INSIDE compute_gradient_and_loss'\\n #############################################################################\\n # TODO: #\\n # Implement the gradient for the required loss, storing the result in dW.\\t #\\n # #\\n # Hint: Instead of computing the gradient from scratch, it may be easier #\\n # to reuse some of the intermediate values that you used to compute the #\\n # loss. #\\n #############################################################################\\n \\n #pass\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n ############################################################################# \",\n \"def calculate_gradients(self, X, Y):\\n Z1 = np.matmul(self.weights[0], X) + self.biases[0] #(30, m)\\n A1 = sigmoid(Z1) #(30, m)\\n Z2 = np.matmul(self.weights[1], A1) + self.biases[1] #(10, m)\\n A2 = sigmoid(Z2) #(10, m)\\n # number of examples\\n m = X.shape[1]\\n dZ2 = A2 - Y #(784, m)\\n dW2 = (1 / m) * np.matmul(dZ2, A1.T) #(10, 30)\\n db2 = (1 / m) * np.sum(dZ2, axis = 1, keepdims = True) #(10, 1)\\n dZ1 = np.multiply(np.matmul(self.weights[1].T, dZ2), sigmoid_deri(Z1)) #(30, m)\\n dW1 = (1 / m) * np.matmul(dZ1, X.T) #(30, 784)\\n db1 = (1 / m) * np.sum(dZ1, axis = 1, keepdims = True) #(30, 1)\\n \\n grads = {\\\"dW1\\\":dW1, \\\"db1\\\":db1, \\\"dW2\\\":dW2, \\\"db2\\\":db2} \\n return grads\",\n \"def deriv_costFunction(self, x, y):\\n self.yEst = self.forward_propagate(x)\\n\\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\\n #partial deriv of cost wrt hidden -> output weights\\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\\n\\n ones_o = np.ones( delta_o.shape[0] )\\n #partial deriv of cost wrt output biases\\n partial_J_b_o = np.dot( ones_o, delta_o )\\n\\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\\n #partial deriv of cost wrt input -> hidden weights\\n partial_J_w_ih = np.dot( x.T, delta_h )\\n \\n ones_h = np.ones( delta_h.shape[0] )\\n #partial deriv of cost wrt hidden biases\\n partial_J_b_h = np.dot( ones_h, delta_h)\\n\\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o\",\n \"def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\\n\\n # Cost history\\n cost_tracking = np.zeros(nb_iterations)\\n\\n for _i in range(nb_iterations):\\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\\n # recording the cost for each iteration\\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\\n\\n return parameters, cost_tracking\",\n \"def compute_regularized_square_loss_gradient(X, y, theta, lambda_reg):\\n return compute_square_loss_gradient(X,y,theta) + 2*lambda_reg*theta\",\n \"def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # You need to return the following variable correctly.\\n grad = np.zeros(theta.shape)\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the partial derivatives and set grad to the partial\\n # derivatives of the cost w.r.t. each parameter in theta.\\n\\n # =============================================================\\n return grad\",\n \"def GD_method(self, X, Y):\\n X = self.normalize(X)\\n for epoch in range(self.epochs):\\n y_pred = self.logistic_function(X, self.b0, self.b1)\\n D_b0, D_b1 = self.cost_derivative(y_pred, Y, X)\\n # Update Weights\\n self.b0 = self.b0 - self.learning_rate * D_b0\\n self.b1 = self.b1 - self.learning_rate * D_b1\\n y_pred = self.predict(X)\\n self.evaluate(y_pred, Y)\",\n \"def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\\n TrainingTarget, TestData, ValData):\\n # Gradient Descent Solution for Linear Regression\\n La = 2\\n # learningRate = 0.01\\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\\n\\n for i in range(0, 400):\\n\\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\\n Delta_E_D = -np.dot(\\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\\n TRAINING_PHI[i])\\n La_Delta_E_W = np.dot(La, W_Now)\\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\\n Delta_W = -np.dot(learningRate, Delta_E)\\n W_T_Next = W_Now + Delta_W\\n W_Now = W_T_Next\\n\\n #-----------------TrainingData Accuracy---------------------#\\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\\n\\n #-----------------ValidationData Accuracy---------------------#\\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\\n\\n #-----------------TestingData Accuracy---------------------#\\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\\n\\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])\",\n \"def loss(self, X, Y, lmd):\\n P, _ = self.forward(X)\\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\\n\\n reg = 0 # Regularization term\\n for w in self.W:\\n reg += np.sum(np.square(w))\\n\\n reg *= lmd\\n\\n cost = loss + reg\\n\\n return cost\",\n \"def gradient_descent(self, X, theta, Y, m):\\n\\n Z = X.dot(theta)\\n H = Predict.g(Z)\\n gradient = np.dot(X.T, (H - Y)) / m\\n return self.alpha * gradient\",\n \"def mse_grad(y, y_hat, d_y_hat):\\n n = y.shape[0]\\n error = (y_hat - y) / n\\n\\n if isinstance(d_y_hat, list):\\n # print([d_y_hat_.shape for d_y_hat_ in d_y_hat])\\n loss_grad = [np.dot(error.T, d_y_hat_) if d_y_hat_.shape[0] > 0 else np.array([]) for d_y_hat_ in d_y_hat]\\n return loss_grad\\n else:\\n loss_grad = np.dot(error.T, d_y_hat)\\n return loss_grad\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\n m = len(values)\\n cost_history = []\\n\\n for i in range(num_iterations):\\n predicted_values = np.dot(features, theta)\\n delta = alpha / m * np.dot((predicted_values - values), features)\\n theta = theta - delta\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n return theta, pandas.Series(cost_history)\",\n \"def compute_gradient_and_loss1(W, X, y, reg, reg_type, opt):\\n if opt == 0: # compute gradient only if opt == 0\\n dW = np.zeros(W.shape) # initialize the gradient as zero\\n \\n # compute the loss and the gradient\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n loss = 0.0\\n #############################################################################\\n # TODO: #\\n # Implement the routine to compute the loss, storing the result in loss #\\n ############################################################################# \\n for i in xrange(num_train): # for every augmended image data (3072+1 vector)\\n s = X[i].dot(W) # compute s (scores)\\n s_y = s[y[i]] # keep the correct ground truth class score\\n for j in xrange(num_classes): # for every class\\n if j != y[i]: # don't take the correct ground truth index\\n term = s[j] - s_y + 1 # max term with Delta = 1, according to Hinge loss formula\\n if term > 0: # trick: take only the term > 0, equal to max(0,...) formula\\n loss += term # add the possitive term \\n if opt == 0: # compute gradient only if opt == 0\\n dW[:, j] += X[i] # this is a analytically with Calculus gradient, case j<>y[i]\\n dW[:, y[i]] -= X[i] # case j==y[i]\\n\\n# loss /= num_train # num_train = M, according to given formula \\n\\n if reg_type == 1: # loss + regularization , l2 or l1\\n loss += reg * np.sum(np.abs(W)) # l1, reg is actually lambda regularization strength\\n else:\\n loss += reg * np.sum(W * W) # l2\\n \\n if opt == 0: # compute gradient only if opt == 0\\n dW /= num_train # we have to divide by num_train in order to have the 'mean' gradient\\n if reg_type == 1: # we use deriv_abs function for l1 derivative\\n dW += reg * deriv_abs(W)\\n else:\\n dW += 2 * reg * W # l2 derivative formula\\n \\n return loss, dW\\n else:\\n return loss, None\\n \\n print 'CSFAK INSIDE compute_gradient_and_loss'\\n #############################################################################\\n # TODO: #\\n # Implement the gradient for the required loss, storing the result in dW.\\t #\\n # #\\n # Hint: Instead of computing the gradient from scratch, it may be easier #\\n # to reuse some of the intermediate values that you used to compute the #\\n # loss. #\\n #############################################################################\\n \\n #pass\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n epochs = 1000\\n\\n for epoch in range(epochs):\\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\\n data_set = np.append(Xless, y, axis=1)\\n np.random.shuffle(data_set)\\n Xless = data_set[:, 0:data_set.shape[1] - 1]\\n y = data_set[:, -1, np.newaxis]\\n for t in range(numsamples):\\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\\n step_size = 0.01 / (epoch + 1)\\n self.weights = self.weights - (step_size * gradient)\\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\\n #Format the array properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def computeGradient(self, X, y, w):\\n n = len(X)\\n if self.loss == 'linear':\\n gradient = -2 * np.dot(X.T, (y - X.dot(w)))\\n elif self.loss == 'logistic':\\n g = self.logistic(X, w)\\n gradient = -2 * np.dot(X.T, (y - g) * g * (1 - g))\\n elif self.loss == 'perceptron':\\n newY = (y > 0).astype(int) * 2 - 1 # change from (0, 1) to (-1, 1)\\n index = ((np.dot(X, w) >= 0).astype(int) != y)\\n usedX = X[index[:, 0]]\\n usedY = newY[index[:, 0]]\\n gradient = -np.dot(usedX.T, usedY)\\n elif self.loss == 'svm':\\n newY = (y > 0).astype(int) * 2 - 1 # change from (0, 1) to (-1, 1)\\n index = (np.dot(X, w) * newY < 1)\\n usedX = X[index[:, 0]]\\n usedY = newY[index[:, 0]]\\n gradient = 2 * w - self.C * np.dot(usedX.T, usedY)\\n gradient[0] = gradient[0] + 2 * w[0]\\n\\n return gradient\",\n \"def square_loss_grad(X, Y, W):\\n return 2.0 / X.shape[0] * np.dot(X.T, (np.dot(X, W) - Y))\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n y_hat = softmax(np.dot(outputVectors,predicted))\\n y = np.zeros(outputVectors.shape[0])\\n y[target] = 1.0\\n\\n cost = -np.log(y_hat[target])\\n gradPred = np.dot(outputVectors.T,y_hat - y)\\n grad = np.outer(y_hat - y,predicted)\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\\n A = np.dot(self.X, self.w)\\n m = self.t.shape[0]\\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\\n return (1 / m) * np.dot(self.X.T, C)\",\n \"def cost_derivative(output_activations, y):\\n return (output_activations - y)\",\n \"def cost(self, Y, Y_hat):\\n\\n total = self.kl(Y=Y, Y_hat=Y_hat)\\n\\n ave = total.mean()\\n #ave = T.cast(ave, dtype='float32')\\n return ave\",\n \"def costFunctionReg(theta, X, y, Lambda):\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n j = costFunction(theta, X, y)\\n j += (Lambda/(2*m))*np.sum(theta[1:]**2)\\n return j\",\n \"def gradient_descent(regression_type, trainingData, theta,\\n maxIter, learningRate):\\n regression = None\\n\\n if(regression_type == 1):\\n regression = LinearRegression()\\n\\n all_costs = zeros(maxIter)\\n\\n for num_iter in range(maxIter):\\n\\n gradient = regression.calculateGradient(trainingData, theta)\\n gradient = gradient*learningRate\\n\\n theta = theta - gradient\\n\\n all_costs[num_iter] = regression.calculateCost(trainingData, theta)\\n\\n return (all_costs, theta)\",\n \"def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\\n theta_list = []\\n cost_list = []\\n\\n theta = initial_theta\\n for i in range(0, niter):\\n theta -= alpha*gradient(theta, X, y, Lambda)\\n theta_list.append(theta)\\n cost_list.append(cost(theta, X, y, Lambda))\\n\\n return theta_list, cost_list\",\n \"def get_cost(self):\\n\\n\\t\\tx = self.symbolic_input\\n\\t\\ty = self.get_reconstructed_input()\\n\\n\\t\\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\\n\\t\\t\\t(1-x)*theano.tensor.log(1-y), axis=1)\\n\\n\\t\\tmean_loss = theano.tensor.mean(negative_log_loss)\\n\\n\\t\\treturn mean_loss\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80790156","0.80790156","0.7456379","0.73937976","0.7304459","0.7289378","0.72770244","0.7272426","0.7232527","0.7229088","0.7182291","0.7179993","0.71723986","0.71631444","0.71498054","0.71384823","0.7122224","0.7103611","0.7058416","0.70522356","0.7051138","0.7047269","0.70457315","0.7042027","0.70337","0.70331174","0.70329255","0.7027246","0.7019208","0.69982356","0.6995962","0.69774884","0.6961591","0.69410264","0.69103825","0.6898288","0.6897659","0.68951285","0.68936205","0.68920213","0.6876808","0.6866037","0.68599534","0.68573236","0.6823601","0.6818917","0.68118024","0.68042964","0.6800118","0.6797066","0.6791681","0.67872083","0.67823184","0.67778665","0.6755782","0.6749699","0.67442524","0.6728859","0.6710193","0.6708337","0.6703186","0.67030424","0.6693367","0.6688392","0.6682301","0.6674082","0.66738695","0.6663794","0.6663193","0.66610354","0.6658642","0.6653406","0.6650043","0.6644763","0.66440064","0.6633721","0.6627751","0.6624496","0.6623883","0.6623665","0.6616747","0.66140443","0.6613975","0.6609784","0.6607498","0.6605231","0.6601197","0.6599415","0.659573","0.65940976","0.6592641","0.6579029","0.6561574","0.6554018","0.6552683","0.65458876","0.65368575","0.65320957","0.65284014","0.6525967"],"string":"[\n \"0.80790156\",\n \"0.80790156\",\n \"0.7456379\",\n \"0.73937976\",\n \"0.7304459\",\n \"0.7289378\",\n \"0.72770244\",\n \"0.7272426\",\n \"0.7232527\",\n \"0.7229088\",\n \"0.7182291\",\n \"0.7179993\",\n \"0.71723986\",\n \"0.71631444\",\n \"0.71498054\",\n \"0.71384823\",\n \"0.7122224\",\n \"0.7103611\",\n \"0.7058416\",\n \"0.70522356\",\n \"0.7051138\",\n \"0.7047269\",\n \"0.70457315\",\n \"0.7042027\",\n \"0.70337\",\n \"0.70331174\",\n \"0.70329255\",\n \"0.7027246\",\n \"0.7019208\",\n \"0.69982356\",\n \"0.6995962\",\n \"0.69774884\",\n \"0.6961591\",\n \"0.69410264\",\n \"0.69103825\",\n \"0.6898288\",\n \"0.6897659\",\n \"0.68951285\",\n \"0.68936205\",\n \"0.68920213\",\n \"0.6876808\",\n \"0.6866037\",\n \"0.68599534\",\n \"0.68573236\",\n \"0.6823601\",\n \"0.6818917\",\n \"0.68118024\",\n \"0.68042964\",\n \"0.6800118\",\n \"0.6797066\",\n \"0.6791681\",\n \"0.67872083\",\n \"0.67823184\",\n \"0.67778665\",\n \"0.6755782\",\n \"0.6749699\",\n \"0.67442524\",\n \"0.6728859\",\n \"0.6710193\",\n \"0.6708337\",\n \"0.6703186\",\n \"0.67030424\",\n \"0.6693367\",\n \"0.6688392\",\n \"0.6682301\",\n \"0.6674082\",\n \"0.66738695\",\n \"0.6663794\",\n \"0.6663193\",\n \"0.66610354\",\n \"0.6658642\",\n \"0.6653406\",\n \"0.6650043\",\n \"0.6644763\",\n \"0.66440064\",\n \"0.6633721\",\n \"0.6627751\",\n \"0.6624496\",\n \"0.6623883\",\n \"0.6623665\",\n \"0.6616747\",\n \"0.66140443\",\n \"0.6613975\",\n \"0.6609784\",\n \"0.6607498\",\n \"0.6605231\",\n \"0.6601197\",\n \"0.6599415\",\n \"0.659573\",\n \"0.65940976\",\n \"0.6592641\",\n \"0.6579029\",\n \"0.6561574\",\n \"0.6554018\",\n \"0.6552683\",\n \"0.65458876\",\n \"0.65368575\",\n \"0.65320957\",\n \"0.65284014\",\n \"0.6525967\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79877114"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":78493,"cells":{"query":{"kind":"string","value":"Calculates cost and its gradient using Binary Cross Entropy. (1/m) np.sum(np.log(Y_hat) Y np.log(1Y_hat) (1Y))"},"document":{"kind":"string","value":"def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -(Y / Y_hat) + (1 - Y) / (1 - Y_hat)\n \n return cost, dY_hat"},"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 compute_cost(Y_hat, Y):\r\n\r\n m = Y.shape[1]\r\n\r\n\r\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\r\n\r\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\r\n\r\n return cost","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def cost(h, y):\n\tm = y.shape[0]\n\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\n\treturn cost","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def compute_cost(AL, Y):\n m = Y.shape[1]\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\n cost = np.sum(log_val) * (-1/m)\n cost = np.squeeze(cost)\n return cost","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def compute_cost(self, AL, Y):\n m = Y.shape[1]\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\n cost = np.squeeze(cost)\n\n return cost","def compute_cost(AL, Y):\n m = AL.shape[1]\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\n cost = np.squeeze(cost)\n return cost","def cost(self, Y, A):\n loss1 = Y * np.log(A)\n m = Y.shape[1]\n cost = -1 * np.sum(loss1) / m\n return cost","def cost(TH,X,Y,lda=1):\n m = X.shape[0]\n htx = ff(X,TH)[-1]\n\n termsum = 0\n for rn in range(m):\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\n termsum = 1./m*(termsum)\n\n regsum = 0\n for th in TH:\n regsum += sum(sum(np.power(th[:,1:],2)))\n regsum = lda/(2.*m)*regsum\n\n return termsum[0,0] +regsum","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def compute_cost(X, y, theta, lambd):\n assert(theta.shape[0] == X.shape[1])\n \n m = X.shape[0]\n grad = np.zeros(y.shape)\n J = 0\n \n output = sigmoid(np.dot(X, theta))\n\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\n\n grad = np.dot(X.T, (output - y)) / m\n \n grad[1:] = grad[1:] + lambd / m * theta[1:]\n\n return J, grad","def cost(self, Y, A):\n m = Y.shape[1]\n cost = - (1 / m) * np.sum(\n np.multiply(\n Y, np.log(A)) + np.multiply(\n 1 - Y, np.log(1.0000001 - A)))\n return cost","def cost(self, h_theta, y):\n \n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)","def cost(self, Y, A):\n\n m = Y.shape[1]\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\n (np.log(1.0000001 - A)))\n return C","def cost(self, X=None, y=None, theta=None):\n X = self.X_train if X is None else X\n y = self.y_train if y is None else y\n m = X.shape[1]\n\n prob_mat = self.softmax_mat(X, theta)\n cost = -(y * np.log(prob_mat)).sum() / m\n return cost","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","def compute_cost(AL, Y):\n\n m = Y.shape[1] # number of example\n\n n = 10 #number of labels\n\n y_binary = get_binary_matrix(Y)\n\n # Compute the cross-entropy cost\n # sum_M = 0\n # for i in range(m):\n # sum_K = 0\n # for k in range(n):\n # cur_y = 0\n # if (Y[0, i] == k):\n # cur_y = 1\n # sum_K += -cur_y * np.log(A2[k, i]) - (1 - cur_y) * np.log(1 - A2[k, i])\n # sum_M += sum_K\n #\n # cost = 1 / m * sum_M\n\n logprobs = np.multiply(-y_binary, np.log(AL)) - np.multiply((1 - y_binary), np.log(1 - AL))\n cost = 1 / m * np.sum(logprobs)\n\n cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect.\n # E.g., turns [[17]] into 17\n\n return cost","def cost_grad_log_reg(w, b, X, y, Multicalss=False):\n if not len(X.shape) == 2:\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\n else:\n X_flattened = X\n m = X_flattened.shape[1]\n print(m)\n if Multicalss:\n # Multi-class\n\n y_train_reshaped = y.reshape(len(y), 1)\n ohe = OneHotEncoder(categories='auto')\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\n print(y_train_reshaped.shape)\n A = softmax(np.dot(X_flattened, w) + b)\n print(A.shape)\n xentropy = -np.sum(y_train_reshaped * np.log(A))\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\n keepdims=True))\n\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\n db = 1 / m * np.sum(A - y_train_reshaped)\n else:\n # Binary\n A = sigmoid(np.dot(w.T, X_flattened) + b)\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\n\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\n db = 1 / m * np.sum(A - y)\n\n # grads/derivatives\n cost = np.squeeze(cost)\n\n return dw, db, cost","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def compute_cost(AL, Y):\n \n m = Y.shape[1]\n\n # Compute loss from aL and y.\n ### START CODE HERE ### (≈ 1 lines of code)\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\n ### END CODE HERE ###\n \n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n assert(cost.shape == ())\n \n return cost","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def compute_cost_gradient1(x, y0, W, b):\n # compute cost\n A = x @ W + b\n y = sigmoid(A)\n if y0 is None:\n return y\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\n # compute gradients\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\n dA = dy * (y * (1 - y))\n dW = x.T @ dA\n db = np.sum(dA)\n return cost, dW, db","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_logistic_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)","def __get_cost_value(self, Y_hat, Y):\n m = Y_hat.shape[1]\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\n return T.squeeze(cost)","def fast_loss_and_grad(self, X, y):\n loss = 0.0\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and gradient WITHOUT any for loops.\n # ================================================================ #\n \n num_train = X.shape[0]\n num_classes = self.W.shape[0]\n \n# # vectorized loss calculation #\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\n \n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\n# #print(exp_a[:,:3])\n# #print(y[:3])\n# #print(y_exp[:3])\n \n# tt = np.sum(exp_a,axis=0)\n# tt2 = np.divide(tt,y_exp)\n# print(num_train)\n# tt3 = np.power(tt2,1/num_train)\n# loss = np.log(np.prod(tt3))\n \n \n \n \n (C, D) = self.W.shape\n N = X.shape[0]\n\n scores = np.dot(self.W, X.T)\n scores -= np.max(scores) # shift by log C to avoid numerical instability\n\n y_mat = np.zeros(shape = (C, N))\n y_mat[y, range(N)] = 1\n\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\n # quantity we need to subtract from each row of scores\n correct_wx = np.multiply(y_mat, scores)\n\n # create a single row of the correct wx_y + log C values for each data point\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\n\n exp_scores = np.exp(scores)\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\n result = np.log(sums_exp)\n\n result -= sums_wy\n\n loss = np.sum(result)\n loss /= num_train\n \n \n # vectorized gradient calculation #\n exp_a_sum = np.sum(exp_a,axis=0)\n\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\n y_mat_corres[y, range(num_train)] = 1\n sum_exp_scores = np.sum(exp_a, axis=0) \n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\n exp_a *= sum_exp_scores\n grad = np.dot(exp_a, X)\n grad -= np.dot(y_mat_corres, X)\n grad /= num_train\n \n\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def compute_gradients(self, logits, target):\n\n target_length = target.shape[0]\n num_time_steps = logits.shape[0]\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n\n # expand labels by inserting a blank between each pair\n normalized_logits = softmax(logits)\n blank_label = normalized_logits.shape[1] - 1\n l = add_blanks(target, blank_label)\n target_length = l.shape[0]\n\n alpha = self.compute_forward_variables(normalized_logits, target) \n beta = self.compute_backward_variables(normalized_logits, target)\n\n # rescale\n alpha = alpha / np.sum(alpha, axis=0)\n beta = beta / np.sum(beta, axis=0)\n alphabeta = alpha * beta\n print \"alpha\"\n print alpha\n\n # compute zt\n z = Counter()\n for t in xrange(num_time_steps):\n for s, k in enumerate(l):\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\n \n # normalized_logits is time steps t by labels k\n # alpha is 2 * target_length - 1 by time steps\n lab_zk = np.zeros_like(normalized_logits)\n for s, k in enumerate(l):\n for t in xrange(num_time_steps):\n lab_zk[t, k] += alphabeta[s, t]\n\n grad = normalized_logits\n for k in xrange(target.shape[0]):\n for t in xrange(num_time_steps):\n ytk = normalized_logits[t, k]\n constant = 1.0 / (ytk * z[t])\n grad[t, k] = ytk - constant * lab_zk[t, k]\n \n return grad","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\n m = X.shape[0]\n y_hat = sigmoid(X @ theta.T)\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\n temp = theta\n temp[0] = 0\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\n return J, grad","def prediction_cost(a, y):\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))","def getCost(Y_predicted, Y):\n delta = 1e-47 # threshold to avoid log(0)\n _, m = Y.shape\n if __debug__:\n print(\"~~~~~~~~~ COST ~~~~~~~~~\")\n print(\"m: {}\".format(m))\n print(\"Max and min values predicted: {} & {}\".format(np.max(Y_predicted), np.min(Y_predicted)))\n print(\"Max and min values true: {} & {}\".format(np.max(Y), np.min(Y)))\n return -np.sum(Y * np.log(Y_predicted + delta) + (1 - Y) * np.log(1 - Y_predicted + delta))/m","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def compute_cost(A2, Y, params):\n m = Y.shape[1]\n \n logprobs1 = -np.dot(Y, np.log(A2).T)\n logprobs2 = -np.dot(1-Y, np.log(1-A2).T)\n cost = 1/m * (logprobs1 + logprobs2)\n \n cost = np.asscalar(cost)\n return cost","def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\n return cost","def get_cost(self, y_enc, output, w1, w2):\n cost = - np.sum(y_enc*np.log(output))\n # add the L2 regularization by taking the L2-norm of the weights and multiplying it with our constant.\n l2_term = (self.l2/2.0) * (np.sum(np.square(w1[:, 1:])) + np.sum(np.square(w2[:, 1:])))\n cost = cost + l2_term\n return cost/y_enc.shape[1]","def gradientDescent(self,X, y, theta): \n # number of instances\n m = len(y)\n J_history = np.zeros((self.NUM_ITERS,1))\n for i in range(self.NUM_ITERS):\n h = self.sigmoid(X@theta)\n grad = 1 / m * X.T @ (h - y)\n theta = theta - self.ALPHA * grad \n J_history[i] = self.costFunction(theta, X, y)\n \n \n return theta, J_history","def cost(self, X, y) :\n ### ========== TODO : START ========== ###\n # part d: compute J(theta)\n #we know for linear/polynomial regression, the cost is the square of the errors\n X = self.generate_polynomial_features(X)\n y_pred_vector = np.dot(X, self.coef_)\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\n ### ========== TODO : END ========== ###\n return cost","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def cost(theta, X, y, Lambda=0.0):\n m = X.shape[0] # number of samples\n\n h = hypothesis(theta, X) \n \n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \n\n reg_term = 0.0\n if Lambda:\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\n\n return (1/m)*suma + reg_term","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def gradient_descent(x, y, theta=[[0], [0]]):\n m = y.size\n j_history = []\n for i in range(ITERATIONS):\n h = x.dot(theta)\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\n j_history.append(compute_cost(x, y, theta))\n return theta, j_history","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def compute_cost(A2, Y, parameters):\n\n\tm = Y.shape[1] # number of example\n\n\t# Compute the cross-entropy cost\n\tlogprobs = np.multiply(np.log(A2), Y)\n\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\n\n\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \n\t \t# E.g., turns [[17]] into 17 \n\tassert(isinstance(cost, float))\n\n\treturn cost","def comp_cost(y_hat, y, activation, epsilon=1e-15):\n if activation == 'sigmoid':\n m = y.shape[1]\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\n cost = (-1. / m) * cost\n cost = np.squeeze(cost) # turns [[17]] into 17).\n assert (cost.shape == ())\n elif activation == 'softmax':\n \"\"\"\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\n \n Arguments:\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\n \n Returns:\n cost -- categorical cross entropy cost\n \n Algorithm:\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\n \n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \n \"\"\"\n cost = log_loss(y, y_hat)\n else:\n raise AttributeError('Unexpected activation function:', activation)\n return cost","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def compute_cost(A3, Y):\n m = A3.shape[1]\n cost = -1 / m * (np.dot(Y, np.log(A3).T) + np.dot(1 - Y, np.log(1 - A3).T));\n return cost","def loss(self, X, Y, lmd):\n P, _ = self.forward(X)\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\n\n reg = 0 # Regularization term\n for w in self.W:\n reg += np.sum(np.square(w))\n\n reg *= lmd\n\n cost = loss + reg\n\n return cost","def cross_entropy_gradient(self, yhat):\n n = len(self._y)\n p = len(self.beta)\n g = np.zeros(p)\n for i in range(0, n):\n g = g + (self._y[i] - yhat[i]) * np.array(\n [1.0, *self._feat_mtx[i, :]])\n\n return g","def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\n m, n = X.shape\n intercept = ones((m, 1), dtype=float64)\n X = append(intercept, X, axis=1)\n\n _h = h(X, theta, n_hidden_layers) # model hypothesis\n\n J = 0\n for c in range(num_labels):\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\n _J = _J + dot((y == c).T, log(_h[:, c]))\n J = J - (1 / m) * sum(_J)\n\n theta_squared_term = 0\n for j in range(len(theta)):\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\n\n J = J + (_lambda / (2 * m)) * theta_squared_term\n\n return J","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n y_hat = softmax(np.dot(outputVectors,predicted))\n y = np.zeros(outputVectors.shape[0])\n y[target] = 1.0\n\n cost = -np.log(y_hat[target])\n gradPred = np.dot(outputVectors.T,y_hat - y)\n grad = np.outer(y_hat - y,predicted)\n ### END YOUR CODE\n\n return cost, gradPred, grad","def cost_function(theta, X, y):\n\n l = None\n #######################################################################\n # TODO: #\n # Compute and return the cost l of a particular choice of #\n # theta. #\n # #\n #######################################################################\n thetaX = np.dot(X, theta)\n g = tanh(thetaX)-y\n l = np.sum(g*g) / X.shape[0]\n \n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return l","def cross_entropy_cost(m, A, L):\n\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\n\n\n\t# Sanity checks\n\tcost = np.squeeze(cost) \t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\n\tassert(cost.shape == ()) \t#checks if cost value is a scalar\n\n\treturn cost","def compute_gradient_logreg(y, tx, w):\n assert len(set(y).difference({0., 1.})) == 0, \"Class labels must be encoded as {0, 1}\"\n\n s = sigmoid(tx.dot(w)) - y\n grad = tx.T.dot(s)\n\n return grad","def compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\n #print theta, grad_theta, objective_function(theta, X, y)\n return grad_theta","def compute_cost(Z6, Y):\n\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\n\n return cost","def compute_ctc_loss(self, logits, target):\n\n num_time_steps = logits.shape[0]\n num_labels = logits.shape[1] - 1\n num_labels_with_blank = num_labels + 1\n\n # sanity check to ensure targets are all right\n assert (target < num_labels).all()\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n target_length = 2 * target.shape[0] + 1\n\n normalized_logits = softmax(logits)\n alpha = self.compute_forward_variables(normalized_logits, target) \n \n return -np.log(np.sum(alpha[target_length-1, :] \\\n + alpha[target_length - 2, :], axis=0))","def _softmax_cost(self, theta, *args):\n epsilon = 1e-32\n wd, PHI, y = args\n N, P = PHI.shape\n W = np.reshape(theta, [P, -1])\n t = softmax(np.matmul(PHI, W)) + epsilon\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\n grad = grad.flatten()\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\n return cost, grad","def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\n h = compute_probabilities(X, theta, temp_parameter)\n\n cost = 0\n for i in range(X.shape[0]):\n for j in range(theta.shape[0]):\n if Y[i] == j:\n cost += np.log(h[j,i])\n\n cost = -cost / X.shape[0]\n\n theta = np.power(theta, 2)\n\n cost += lambda_factor / 2 * theta.sum()\n\n return cost","def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd):\n X = np.reshape(params[:num_movies*num_features], (num_movies, num_features))\n Theta = np.reshape(params[num_movies*num_features:], (num_users, num_features))\n\n # J=sum((X*Theta'-Y)^2) where R[i,j]==1\n h = X.dot(Theta.T)-Y\n M = h**2\n J = (M*R).sum()/2\n reg = lbd/2*((X**2).sum()+(Theta**2).sum())\n J = J+reg\n\n X_grad = (h*R).dot(Theta)+lbd*X\n Theta_grad = (h*R).T.dot(X)+lbd*Theta\n\n grad = np.r_[X_grad.flatten(), Theta_grad.flatten()]\n return J, grad","def grad_log(self, X):\n # \"\"\"\n # Evaluate the gradients (with respect to the input) of the log density at\n # each of the n points in X. This is the score function.\n\n # X: n x d numpy array.\n XB = np.dot(X, self.B)\n Y = 0.5*XB + self.c\n E2y = np.exp(2*Y)\n # n x dh\n Phi = old_div((E2y-1.0),(E2y+1))\n # n x dx\n T = np.dot(Phi, 0.5*self.B.T)\n S = self.b - X + T\n return S","def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and the gradient. Store the gradient\n # as the variable grad.\n # ================================================================ #\n \n exp_a = np.zeros((num_classes,num_train))\n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n \n #if i==0:\n grada = np.zeros(X.shape[1])\n \n for j in range(num_classes):\n if j != y[i]:\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \n else: \n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \n\n grad += grad_tmp\n loss += Loss \n \n pass\n\n\n loss /= num_train\n grad /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\n # compute cost\n A1 = x @ W + b0\n A2 = x @ V + b1\n z0 = sigmoid(A1)\n z1 = sigmoid(A2)\n z = np.array([z0, z1]).T\n A3 = z @ U + b2\n y = sigmoid(A3)\n if y0 is None:\n return y\n cost = np.sum((y - y0) ** 2)\n # compute gradient\n dy = 2 * (y - y0)\n dA3 = dy * (y * (1 - y))\n dz0 = dA3 * U[0]\n dz1 = dA3 * U[1]\n dA1 = dz0 * (z0 * (1 - z0))\n dA2 = dz1 * (z1 * (1 - z1))\n dW = x.T @ dA1\n dV = x.T @ dA2\n dU = z.T @ dA3\n db0 = np.sum(dA1)\n db1 = np.sum(dA2)\n db2 = np.sum(dA3)\n return cost, dW, dV, dU, db0, db1, db2","def nn_cost_function(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\n Theta_1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\n (hidden_layer_size, input_layer_size + 1))\n Theta_2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\n (num_labels, hidden_layer_size + 1))\n\n m, n = X.shape\n X = np.hstack((np.ones((m, 1)), X))\n\n Z_2 = X.dot(Theta_1.T)\n A_2 = sigmoid(Z_2)\n A_2 = np.hstack((np.ones((m, 1)), A_2))\n\n Z_3 = A_2.dot(Theta_2.T)\n A_3 = sigmoid(Z_3)\n\n Y = np.zeros((m, num_labels))\n for i in range(m):\n Y[i, y[i] - 1] = 1\n\n j = 0.0\n for i in range(m):\n j += np.log(A_3[i, ]).dot(-Y[i, ].T) - np.log(1 - A_3[i, ]).dot(1 - Y[i, ].T)\n j /= m\n\n Theta_1_square = np.square(Theta_1[:, 1:])\n Theta_2_square = np.square(Theta_2[:, 1:])\n reg = 1.0 * l / (2 * m) * (np.sum(Theta_1_square) + np.sum(Theta_2_square))\n j += reg\n\n d_3 = A_3 - Y\n D_2 = d_3.T.dot(A_2)\n\n Z_2 = np.hstack((np.ones((m, 1)), Z_2))\n d_2 = d_3.dot(Theta_2) * sigmoid_gradient(Z_2)\n d_2 = d_2[:, 1:]\n D_1 = d_2.T.dot(X)\n\n Theta_1_grad = 1.0 * D_1 / m\n Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta_1[:, 1:]\n\n Theta_2_grad = 1.0 * D_2 / m\n Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta_2[:, 1:]\n\n grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\n\n return j, grad","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\n y_hat = softmax(scores)\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\n one_hot_target = np.zeros_like(y_hat)\n one_hot_target[target] = 1\n grad = np.outer((y_hat - one_hot_target), predicted)\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\n \n '''\n final_predicted = predicted.dot(outputVectors.T)\n probability = softmax(final_predicted)\n cost = -np.log(probability[target])\n \n one_hot_target = np.zeros_like(probability)\n one_hot_target[target] += 1\n dlogits = probability - one_hot_target\n grad = np.outer(predicted, dlogits).T\n gradPred = outputVectors.T.dot(dlogits)\n '''\n ### END YOUR CODE\n\n return cost, gradPred, grad","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def compute_gradient(self, X, y, weights):\n sigmoid = self.sigmoid(np.dot(X, weights))\n return np.dot(X.T, y - sigmoid)","def loss_func(self, logits, targets):\r\n return -np.sum(targets * np.log(logits)) / logits.shape[0]","def loss(self, y: np.ndarray, y_hat: np.ndarray) -> float:\n losses = -(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))\n return losses.mean() + self.reg / self.num_parameters * (\n (self.v[:, -1] ** 2).sum() + (self.w ** 2).sum()\n )","def propagate(self, X, Y):\n\n m = X.shape[1]\n\n A = self.sigmoid(self.w.T @ X + self.b)\n cost = -np.sum(Y * np.log(A) + (1-Y) * np.log(1-A)) / m\n\n dZ = A - Y\n dw = (X @ dZ.T) / m\n db = np.sum(dZ) / m\n\n assert(dw.shape == self.w.shape)\n assert(db.dtype == float)\n\n cost = np.squeeze(cost)\n\n assert(cost.shape == ())\n\n grads = {\"dw\": dw,\n \"db\": db}\n\n return grads, cost","def calc_gradient(self, W, X, y, reg):\n\n N = X.shape[0]\n grad_W = np.zeros_like(W)\n I = np.ones((1,10))\n score = np.dot(X, W) # (N, C)\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\n #print(\"out\", out)\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\n \n dout = np.copy(out) # (N, C)\n dout[np.arange(N), y] -= 1\n grad_W = np.dot(X.T, dout) # (D, C)\n grad_W /= N\n #grad_W += reg * W\n \n return grad_W","def loss_gradient(self, targets, scores):\n m = targets * scores\n numer = 4. * (2. * numpy.arctan(m) - 1.)\n denom = 1. + m**2\n return numer/denom","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","def grad_softmax_cross_entropy_loss(logit, labels):\n return softmax(logit) - labels","def total_cost(self, X, Y, thetas = None):\n \n if thetas == None:\n thetas = self.thetas\n \n J = 0.0\n m = X.shape[0]\n for x, true_indx in zip(X, Y):\n y = np.zeros(self.noutputs)\n y[true_indx] = 1.\n h_theta = self._forward_prop(x, thetas)[-1]\n J += self.cost(h_theta, y)\n \n return np.sum(J)/m","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def calculate_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))","def gradient_function(theta, X, y):\n\n grad = None\n #######################################################################\n # TODO: #\n # Compute the gradient for a particular choice of theta. #\n # Compute the partial derivatives and set grad to the partial #\n # derivatives of the cost w.r.t. each parameter in theta #\n # #\n #######################################################################\n \n theta = theta[:, np.newaxis]\n \n thetatrans = theta.T\n Xtrans = X.T\n \n MulThetaX = np.dot(thetatrans, Xtrans)\n \n h = sigmoid(MulThetaX)\n \n grad = (y - h) * Xtrans\n\n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return grad","def logistic_pen(weights, data, targets, hyperparameters):\n\n wr = hyperparameters['weight_regularization']\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\n df = np.reshape(df, ((len(df), 1)))\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\n\n f += (weights[-1, 0] ** 2) * wr / 2\n df[-1] += weights[-1,0] * wr \n\n return f, df, np.reshape(y, (len(y), 1))","def compute_cost_derivative(AL, Y):\n pass","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def compute_cost(AL, Y):\n pass","def cost_(theta, X, Y):\n if X.shape[1] + 1 != theta.size or X.shape[0] != Y.size:\n print(\"Inc dim\")\n return\n c = cost_elem_(theta, X, Y)\n s = 0\n for i in c:\n s = s + i\n return(s)","def loss(self, X_batch, y_batch, learning_rate=1e-3, one_vs_all_index=-1, reg=True):\n #########################################################################\n # TODO: #\n # calculate the loss and the derivative #\n #########################################################################\n loss = 0\n for i in range(X_batch.shape[0]):\n if one_vs_all_index == -1:\n loss += -(y_batch[i] * (np.dot(self.w.T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.w.T, X_batch[i])))\n else:\n if reg:\n reg = (learning_rate / 2 * X_batch.shape[0]) * np.sum(np.power(self.ws[one_vs_all_index], 2))\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + reg\n else:\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i])))\n gradients = np.zeros(X_batch.shape[1])\n if one_vs_all_index == -1:\n dot = np.dot(X_batch, self.w)\n else:\n dot = np.dot(X_batch, self.ws[one_vs_all_index])\n logists = sigmod(dot)\n diff = y_batch - logists\n for index in range(X_batch.shape[0]):\n if one_vs_all_index != -1:\n if reg:\n dot = np.dot(X_batch[index], diff[index])\n gradients[1:] += dot[1:] + (learning_rate / X_batch.shape[0]) * self.ws[one_vs_all_index][1:]\n gradients[0] += dot[0]\n else:\n gradients += np.dot(X_batch[index], diff[index])\n else:\n gradients += np.dot(X_batch[index], diff[index])\n\n return loss, gradients / X_batch.shape[0] # 取均值免得步长过大直接nan\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def cost_func(w, X, y):\n y_pred = np.dot(X, w)\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\n\n return err","def calculate_gradient(y, tx, w): \n return tx.T@(sigmoid(tx@w)-y)","def calculate_gradient(y, tx, w):\n\n\tret = tx.T.dot(sigmoid(np.dot(tx, w)) - y)\n\treturn ret","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def calc_grad(X, Y, theta):\n m, n = X.shape\n\n margins = Y * X.dot(theta)\n probs = 1. / (1 + np.exp(margins))\n grad = -(1./m) * (X.T.dot(probs * Y))\n\n return grad","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def gradient_descent(self, X, theta, Y, m):\n\n Z = X.dot(theta)\n H = Predict.g(Z)\n gradient = np.dot(X.T, (H - Y)) / m\n return self.alpha * gradient"],"string":"[\n \"def compute_cost(Y_hat, Y):\\r\\n\\r\\n m = Y.shape[1]\\r\\n\\r\\n\\r\\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\\r\\n\\r\\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\r\\n\\r\\n return cost\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def cost(h, y):\\n\\tm = y.shape[0]\\n\\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\\n\\treturn cost\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def compute_cost(AL, Y):\\n m = Y.shape[1]\\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\\n cost = np.sum(log_val) * (-1/m)\\n cost = np.squeeze(cost)\\n return cost\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def compute_cost(self, AL, Y):\\n m = Y.shape[1]\\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\\n cost = np.squeeze(cost)\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n m = AL.shape[1]\\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\\n cost = np.squeeze(cost)\\n return cost\",\n \"def cost(self, Y, A):\\n loss1 = Y * np.log(A)\\n m = Y.shape[1]\\n cost = -1 * np.sum(loss1) / m\\n return cost\",\n \"def cost(TH,X,Y,lda=1):\\n m = X.shape[0]\\n htx = ff(X,TH)[-1]\\n\\n termsum = 0\\n for rn in range(m):\\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\\n termsum = 1./m*(termsum)\\n\\n regsum = 0\\n for th in TH:\\n regsum += sum(sum(np.power(th[:,1:],2)))\\n regsum = lda/(2.*m)*regsum\\n\\n return termsum[0,0] +regsum\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def compute_cost(X, y, theta, lambd):\\n assert(theta.shape[0] == X.shape[1])\\n \\n m = X.shape[0]\\n grad = np.zeros(y.shape)\\n J = 0\\n \\n output = sigmoid(np.dot(X, theta))\\n\\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\\n\\n grad = np.dot(X.T, (output - y)) / m\\n \\n grad[1:] = grad[1:] + lambd / m * theta[1:]\\n\\n return J, grad\",\n \"def cost(self, Y, A):\\n m = Y.shape[1]\\n cost = - (1 / m) * np.sum(\\n np.multiply(\\n Y, np.log(A)) + np.multiply(\\n 1 - Y, np.log(1.0000001 - A)))\\n return cost\",\n \"def cost(self, h_theta, y):\\n \\n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)\",\n \"def cost(self, Y, A):\\n\\n m = Y.shape[1]\\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\\n (np.log(1.0000001 - A)))\\n return C\",\n \"def cost(self, X=None, y=None, theta=None):\\n X = self.X_train if X is None else X\\n y = self.y_train if y is None else y\\n m = X.shape[1]\\n\\n prob_mat = self.softmax_mat(X, theta)\\n cost = -(y * np.log(prob_mat)).sum() / m\\n return cost\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\n \"def compute_cost(AL, Y):\\n\\n m = Y.shape[1] # number of example\\n\\n n = 10 #number of labels\\n\\n y_binary = get_binary_matrix(Y)\\n\\n # Compute the cross-entropy cost\\n # sum_M = 0\\n # for i in range(m):\\n # sum_K = 0\\n # for k in range(n):\\n # cur_y = 0\\n # if (Y[0, i] == k):\\n # cur_y = 1\\n # sum_K += -cur_y * np.log(A2[k, i]) - (1 - cur_y) * np.log(1 - A2[k, i])\\n # sum_M += sum_K\\n #\\n # cost = 1 / m * sum_M\\n\\n logprobs = np.multiply(-y_binary, np.log(AL)) - np.multiply((1 - y_binary), np.log(1 - AL))\\n cost = 1 / m * np.sum(logprobs)\\n\\n cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect.\\n # E.g., turns [[17]] into 17\\n\\n return cost\",\n \"def cost_grad_log_reg(w, b, X, y, Multicalss=False):\\n if not len(X.shape) == 2:\\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\\n else:\\n X_flattened = X\\n m = X_flattened.shape[1]\\n print(m)\\n if Multicalss:\\n # Multi-class\\n\\n y_train_reshaped = y.reshape(len(y), 1)\\n ohe = OneHotEncoder(categories='auto')\\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\\n print(y_train_reshaped.shape)\\n A = softmax(np.dot(X_flattened, w) + b)\\n print(A.shape)\\n xentropy = -np.sum(y_train_reshaped * np.log(A))\\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\\n keepdims=True))\\n\\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\\n db = 1 / m * np.sum(A - y_train_reshaped)\\n else:\\n # Binary\\n A = sigmoid(np.dot(w.T, X_flattened) + b)\\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\\n\\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\\n db = 1 / m * np.sum(A - y)\\n\\n # grads/derivatives\\n cost = np.squeeze(cost)\\n\\n return dw, db, cost\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def compute_cost(AL, Y):\\n \\n m = Y.shape[1]\\n\\n # Compute loss from aL and y.\\n ### START CODE HERE ### (≈ 1 lines of code)\\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\\n ### END CODE HERE ###\\n \\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\n assert(cost.shape == ())\\n \\n return cost\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def compute_cost_gradient1(x, y0, W, b):\\n # compute cost\\n A = x @ W + b\\n y = sigmoid(A)\\n if y0 is None:\\n return y\\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\\n # compute gradients\\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\\n dA = dy * (y * (1 - y))\\n dW = x.T @ dA\\n db = np.sum(dA)\\n return cost, dW, db\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_logistic_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)\",\n \"def __get_cost_value(self, Y_hat, Y):\\n m = Y_hat.shape[1]\\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\\n return T.squeeze(cost)\",\n \"def fast_loss_and_grad(self, X, y):\\n loss = 0.0\\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and gradient WITHOUT any for loops.\\n # ================================================================ #\\n \\n num_train = X.shape[0]\\n num_classes = self.W.shape[0]\\n \\n# # vectorized loss calculation #\\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\\n \\n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\\n# #print(exp_a[:,:3])\\n# #print(y[:3])\\n# #print(y_exp[:3])\\n \\n# tt = np.sum(exp_a,axis=0)\\n# tt2 = np.divide(tt,y_exp)\\n# print(num_train)\\n# tt3 = np.power(tt2,1/num_train)\\n# loss = np.log(np.prod(tt3))\\n \\n \\n \\n \\n (C, D) = self.W.shape\\n N = X.shape[0]\\n\\n scores = np.dot(self.W, X.T)\\n scores -= np.max(scores) # shift by log C to avoid numerical instability\\n\\n y_mat = np.zeros(shape = (C, N))\\n y_mat[y, range(N)] = 1\\n\\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\\n # quantity we need to subtract from each row of scores\\n correct_wx = np.multiply(y_mat, scores)\\n\\n # create a single row of the correct wx_y + log C values for each data point\\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\\n\\n exp_scores = np.exp(scores)\\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\\n result = np.log(sums_exp)\\n\\n result -= sums_wy\\n\\n loss = np.sum(result)\\n loss /= num_train\\n \\n \\n # vectorized gradient calculation #\\n exp_a_sum = np.sum(exp_a,axis=0)\\n\\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\\n y_mat_corres[y, range(num_train)] = 1\\n sum_exp_scores = np.sum(exp_a, axis=0) \\n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\\n exp_a *= sum_exp_scores\\n grad = np.dot(exp_a, X)\\n grad -= np.dot(y_mat_corres, X)\\n grad /= num_train\\n \\n\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def compute_gradients(self, logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n\\n # expand labels by inserting a blank between each pair\\n normalized_logits = softmax(logits)\\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n alpha = self.compute_forward_variables(normalized_logits, target) \\n beta = self.compute_backward_variables(normalized_logits, target)\\n\\n # rescale\\n alpha = alpha / np.sum(alpha, axis=0)\\n beta = beta / np.sum(beta, axis=0)\\n alphabeta = alpha * beta\\n print \\\"alpha\\\"\\n print alpha\\n\\n # compute zt\\n z = Counter()\\n for t in xrange(num_time_steps):\\n for s, k in enumerate(l):\\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\\n \\n # normalized_logits is time steps t by labels k\\n # alpha is 2 * target_length - 1 by time steps\\n lab_zk = np.zeros_like(normalized_logits)\\n for s, k in enumerate(l):\\n for t in xrange(num_time_steps):\\n lab_zk[t, k] += alphabeta[s, t]\\n\\n grad = normalized_logits\\n for k in xrange(target.shape[0]):\\n for t in xrange(num_time_steps):\\n ytk = normalized_logits[t, k]\\n constant = 1.0 / (ytk * z[t])\\n grad[t, k] = ytk - constant * lab_zk[t, k]\\n \\n return grad\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\\n m = X.shape[0]\\n y_hat = sigmoid(X @ theta.T)\\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\\n temp = theta\\n temp[0] = 0\\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\\n return J, grad\",\n \"def prediction_cost(a, y):\\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))\",\n \"def getCost(Y_predicted, Y):\\n delta = 1e-47 # threshold to avoid log(0)\\n _, m = Y.shape\\n if __debug__:\\n print(\\\"~~~~~~~~~ COST ~~~~~~~~~\\\")\\n print(\\\"m: {}\\\".format(m))\\n print(\\\"Max and min values predicted: {} & {}\\\".format(np.max(Y_predicted), np.min(Y_predicted)))\\n print(\\\"Max and min values true: {} & {}\\\".format(np.max(Y), np.min(Y)))\\n return -np.sum(Y * np.log(Y_predicted + delta) + (1 - Y) * np.log(1 - Y_predicted + delta))/m\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def compute_cost(A2, Y, params):\\n m = Y.shape[1]\\n \\n logprobs1 = -np.dot(Y, np.log(A2).T)\\n logprobs2 = -np.dot(1-Y, np.log(1-A2).T)\\n cost = 1/m * (logprobs1 + logprobs2)\\n \\n cost = np.asscalar(cost)\\n return cost\",\n \"def compute_cost(AL, Y, parameters ,lambd):\\n L = len(parameters) // 2\\n m = Y.shape[1]\\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\\n return cost\",\n \"def get_cost(self, y_enc, output, w1, w2):\\n cost = - np.sum(y_enc*np.log(output))\\n # add the L2 regularization by taking the L2-norm of the weights and multiplying it with our constant.\\n l2_term = (self.l2/2.0) * (np.sum(np.square(w1[:, 1:])) + np.sum(np.square(w2[:, 1:])))\\n cost = cost + l2_term\\n return cost/y_enc.shape[1]\",\n \"def gradientDescent(self,X, y, theta): \\n # number of instances\\n m = len(y)\\n J_history = np.zeros((self.NUM_ITERS,1))\\n for i in range(self.NUM_ITERS):\\n h = self.sigmoid(X@theta)\\n grad = 1 / m * X.T @ (h - y)\\n theta = theta - self.ALPHA * grad \\n J_history[i] = self.costFunction(theta, X, y)\\n \\n \\n return theta, J_history\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def cost(theta, X, y, Lambda=0.0):\\n m = X.shape[0] # number of samples\\n\\n h = hypothesis(theta, X) \\n \\n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \\n\\n reg_term = 0.0\\n if Lambda:\\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\\n\\n return (1/m)*suma + reg_term\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def gradient_descent(x, y, theta=[[0], [0]]):\\n m = y.size\\n j_history = []\\n for i in range(ITERATIONS):\\n h = x.dot(theta)\\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\\n j_history.append(compute_cost(x, y, theta))\\n return theta, j_history\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def compute_cost(A2, Y, parameters):\\n\\n\\tm = Y.shape[1] # number of example\\n\\n\\t# Compute the cross-entropy cost\\n\\tlogprobs = np.multiply(np.log(A2), Y)\\n\\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\\n\\n\\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \\n\\t \\t# E.g., turns [[17]] into 17 \\n\\tassert(isinstance(cost, float))\\n\\n\\treturn cost\",\n \"def comp_cost(y_hat, y, activation, epsilon=1e-15):\\n if activation == 'sigmoid':\\n m = y.shape[1]\\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\\n cost = (-1. / m) * cost\\n cost = np.squeeze(cost) # turns [[17]] into 17).\\n assert (cost.shape == ())\\n elif activation == 'softmax':\\n \\\"\\\"\\\"\\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\\n \\n Arguments:\\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\\n \\n Returns:\\n cost -- categorical cross entropy cost\\n \\n Algorithm:\\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\\n \\n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \\n \\\"\\\"\\\"\\n cost = log_loss(y, y_hat)\\n else:\\n raise AttributeError('Unexpected activation function:', activation)\\n return cost\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def compute_cost(A3, Y):\\n m = A3.shape[1]\\n cost = -1 / m * (np.dot(Y, np.log(A3).T) + np.dot(1 - Y, np.log(1 - A3).T));\\n return cost\",\n \"def loss(self, X, Y, lmd):\\n P, _ = self.forward(X)\\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\\n\\n reg = 0 # Regularization term\\n for w in self.W:\\n reg += np.sum(np.square(w))\\n\\n reg *= lmd\\n\\n cost = loss + reg\\n\\n return cost\",\n \"def cross_entropy_gradient(self, yhat):\\n n = len(self._y)\\n p = len(self.beta)\\n g = np.zeros(p)\\n for i in range(0, n):\\n g = g + (self._y[i] - yhat[i]) * np.array(\\n [1.0, *self._feat_mtx[i, :]])\\n\\n return g\",\n \"def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\\n m, n = X.shape\\n intercept = ones((m, 1), dtype=float64)\\n X = append(intercept, X, axis=1)\\n\\n _h = h(X, theta, n_hidden_layers) # model hypothesis\\n\\n J = 0\\n for c in range(num_labels):\\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\\n _J = _J + dot((y == c).T, log(_h[:, c]))\\n J = J - (1 / m) * sum(_J)\\n\\n theta_squared_term = 0\\n for j in range(len(theta)):\\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\\n\\n J = J + (_lambda / (2 * m)) * theta_squared_term\\n\\n return J\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n y_hat = softmax(np.dot(outputVectors,predicted))\\n y = np.zeros(outputVectors.shape[0])\\n y[target] = 1.0\\n\\n cost = -np.log(y_hat[target])\\n gradPred = np.dot(outputVectors.T,y_hat - y)\\n grad = np.outer(y_hat - y,predicted)\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def cost_function(theta, X, y):\\n\\n l = None\\n #######################################################################\\n # TODO: #\\n # Compute and return the cost l of a particular choice of #\\n # theta. #\\n # #\\n #######################################################################\\n thetaX = np.dot(X, theta)\\n g = tanh(thetaX)-y\\n l = np.sum(g*g) / X.shape[0]\\n \\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return l\",\n \"def cross_entropy_cost(m, A, L):\\n\\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\\n\\n\\n\\t# Sanity checks\\n\\tcost = np.squeeze(cost) \\t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\\n\\tassert(cost.shape == ()) \\t#checks if cost value is a scalar\\n\\n\\treturn cost\",\n \"def compute_gradient_logreg(y, tx, w):\\n assert len(set(y).difference({0., 1.})) == 0, \\\"Class labels must be encoded as {0, 1}\\\"\\n\\n s = sigmoid(tx.dot(w)) - y\\n grad = tx.T.dot(s)\\n\\n return grad\",\n \"def compute_gradient(theta, X, y):\\n m = X.shape[0]\\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\\n #print theta, grad_theta, objective_function(theta, X, y)\\n return grad_theta\",\n \"def compute_cost(Z6, Y):\\n\\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\\n\\n return cost\",\n \"def compute_ctc_loss(self, logits, target):\\n\\n num_time_steps = logits.shape[0]\\n num_labels = logits.shape[1] - 1\\n num_labels_with_blank = num_labels + 1\\n\\n # sanity check to ensure targets are all right\\n assert (target < num_labels).all()\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n target_length = 2 * target.shape[0] + 1\\n\\n normalized_logits = softmax(logits)\\n alpha = self.compute_forward_variables(normalized_logits, target) \\n \\n return -np.log(np.sum(alpha[target_length-1, :] \\\\\\n + alpha[target_length - 2, :], axis=0))\",\n \"def _softmax_cost(self, theta, *args):\\n epsilon = 1e-32\\n wd, PHI, y = args\\n N, P = PHI.shape\\n W = np.reshape(theta, [P, -1])\\n t = softmax(np.matmul(PHI, W)) + epsilon\\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\\n grad = grad.flatten()\\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\\\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\\n return cost, grad\",\n \"def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n cost = 0\\n for i in range(X.shape[0]):\\n for j in range(theta.shape[0]):\\n if Y[i] == j:\\n cost += np.log(h[j,i])\\n\\n cost = -cost / X.shape[0]\\n\\n theta = np.power(theta, 2)\\n\\n cost += lambda_factor / 2 * theta.sum()\\n\\n return cost\",\n \"def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd):\\n X = np.reshape(params[:num_movies*num_features], (num_movies, num_features))\\n Theta = np.reshape(params[num_movies*num_features:], (num_users, num_features))\\n\\n # J=sum((X*Theta'-Y)^2) where R[i,j]==1\\n h = X.dot(Theta.T)-Y\\n M = h**2\\n J = (M*R).sum()/2\\n reg = lbd/2*((X**2).sum()+(Theta**2).sum())\\n J = J+reg\\n\\n X_grad = (h*R).dot(Theta)+lbd*X\\n Theta_grad = (h*R).T.dot(X)+lbd*Theta\\n\\n grad = np.r_[X_grad.flatten(), Theta_grad.flatten()]\\n return J, grad\",\n \"def grad_log(self, X):\\n # \\\"\\\"\\\"\\n # Evaluate the gradients (with respect to the input) of the log density at\\n # each of the n points in X. This is the score function.\\n\\n # X: n x d numpy array.\\n XB = np.dot(X, self.B)\\n Y = 0.5*XB + self.c\\n E2y = np.exp(2*Y)\\n # n x dh\\n Phi = old_div((E2y-1.0),(E2y+1))\\n # n x dx\\n T = np.dot(Phi, 0.5*self.B.T)\\n S = self.b - X + T\\n return S\",\n \"def loss_and_grad(self, X, y):\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n grad = np.zeros_like(self.W)\\n grad_tmp = np.zeros_like(self.W)\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and the gradient. Store the gradient\\n # as the variable grad.\\n # ================================================================ #\\n \\n exp_a = np.zeros((num_classes,num_train))\\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n \\n #if i==0:\\n grada = np.zeros(X.shape[1])\\n \\n for j in range(num_classes):\\n if j != y[i]:\\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \\n else: \\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \\n\\n grad += grad_tmp\\n loss += Loss \\n \\n pass\\n\\n\\n loss /= num_train\\n grad /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\\n # compute cost\\n A1 = x @ W + b0\\n A2 = x @ V + b1\\n z0 = sigmoid(A1)\\n z1 = sigmoid(A2)\\n z = np.array([z0, z1]).T\\n A3 = z @ U + b2\\n y = sigmoid(A3)\\n if y0 is None:\\n return y\\n cost = np.sum((y - y0) ** 2)\\n # compute gradient\\n dy = 2 * (y - y0)\\n dA3 = dy * (y * (1 - y))\\n dz0 = dA3 * U[0]\\n dz1 = dA3 * U[1]\\n dA1 = dz0 * (z0 * (1 - z0))\\n dA2 = dz1 * (z1 * (1 - z1))\\n dW = x.T @ dA1\\n dV = x.T @ dA2\\n dU = z.T @ dA3\\n db0 = np.sum(dA1)\\n db1 = np.sum(dA2)\\n db2 = np.sum(dA3)\\n return cost, dW, dV, dU, db0, db1, db2\",\n \"def nn_cost_function(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\\n Theta_1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\\n (hidden_layer_size, input_layer_size + 1))\\n Theta_2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\\n (num_labels, hidden_layer_size + 1))\\n\\n m, n = X.shape\\n X = np.hstack((np.ones((m, 1)), X))\\n\\n Z_2 = X.dot(Theta_1.T)\\n A_2 = sigmoid(Z_2)\\n A_2 = np.hstack((np.ones((m, 1)), A_2))\\n\\n Z_3 = A_2.dot(Theta_2.T)\\n A_3 = sigmoid(Z_3)\\n\\n Y = np.zeros((m, num_labels))\\n for i in range(m):\\n Y[i, y[i] - 1] = 1\\n\\n j = 0.0\\n for i in range(m):\\n j += np.log(A_3[i, ]).dot(-Y[i, ].T) - np.log(1 - A_3[i, ]).dot(1 - Y[i, ].T)\\n j /= m\\n\\n Theta_1_square = np.square(Theta_1[:, 1:])\\n Theta_2_square = np.square(Theta_2[:, 1:])\\n reg = 1.0 * l / (2 * m) * (np.sum(Theta_1_square) + np.sum(Theta_2_square))\\n j += reg\\n\\n d_3 = A_3 - Y\\n D_2 = d_3.T.dot(A_2)\\n\\n Z_2 = np.hstack((np.ones((m, 1)), Z_2))\\n d_2 = d_3.dot(Theta_2) * sigmoid_gradient(Z_2)\\n d_2 = d_2[:, 1:]\\n D_1 = d_2.T.dot(X)\\n\\n Theta_1_grad = 1.0 * D_1 / m\\n Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta_1[:, 1:]\\n\\n Theta_2_grad = 1.0 * D_2 / m\\n Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta_2[:, 1:]\\n\\n grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\\n\\n return j, grad\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\\n y_hat = softmax(scores)\\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\\n one_hot_target = np.zeros_like(y_hat)\\n one_hot_target[target] = 1\\n grad = np.outer((y_hat - one_hot_target), predicted)\\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\\n \\n '''\\n final_predicted = predicted.dot(outputVectors.T)\\n probability = softmax(final_predicted)\\n cost = -np.log(probability[target])\\n \\n one_hot_target = np.zeros_like(probability)\\n one_hot_target[target] += 1\\n dlogits = probability - one_hot_target\\n grad = np.outer(predicted, dlogits).T\\n gradPred = outputVectors.T.dot(dlogits)\\n '''\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def compute_gradient(self, X, y, weights):\\n sigmoid = self.sigmoid(np.dot(X, weights))\\n return np.dot(X.T, y - sigmoid)\",\n \"def loss_func(self, logits, targets):\\r\\n return -np.sum(targets * np.log(logits)) / logits.shape[0]\",\n \"def loss(self, y: np.ndarray, y_hat: np.ndarray) -> float:\\n losses = -(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))\\n return losses.mean() + self.reg / self.num_parameters * (\\n (self.v[:, -1] ** 2).sum() + (self.w ** 2).sum()\\n )\",\n \"def propagate(self, X, Y):\\n\\n m = X.shape[1]\\n\\n A = self.sigmoid(self.w.T @ X + self.b)\\n cost = -np.sum(Y * np.log(A) + (1-Y) * np.log(1-A)) / m\\n\\n dZ = A - Y\\n dw = (X @ dZ.T) / m\\n db = np.sum(dZ) / m\\n\\n assert(dw.shape == self.w.shape)\\n assert(db.dtype == float)\\n\\n cost = np.squeeze(cost)\\n\\n assert(cost.shape == ())\\n\\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n return grads, cost\",\n \"def calc_gradient(self, W, X, y, reg):\\n\\n N = X.shape[0]\\n grad_W = np.zeros_like(W)\\n I = np.ones((1,10))\\n score = np.dot(X, W) # (N, C)\\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\\n #print(\\\"out\\\", out)\\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\\n \\n dout = np.copy(out) # (N, C)\\n dout[np.arange(N), y] -= 1\\n grad_W = np.dot(X.T, dout) # (D, C)\\n grad_W /= N\\n #grad_W += reg * W\\n \\n return grad_W\",\n \"def loss_gradient(self, targets, scores):\\n m = targets * scores\\n numer = 4. * (2. * numpy.arctan(m) - 1.)\\n denom = 1. + m**2\\n return numer/denom\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def total_cost(self, X, Y, thetas = None):\\n \\n if thetas == None:\\n thetas = self.thetas\\n \\n J = 0.0\\n m = X.shape[0]\\n for x, true_indx in zip(X, Y):\\n y = np.zeros(self.noutputs)\\n y[true_indx] = 1.\\n h_theta = self._forward_prop(x, thetas)[-1]\\n J += self.cost(h_theta, y)\\n \\n return np.sum(J)/m\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def calculate_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))\",\n \"def gradient_function(theta, X, y):\\n\\n grad = None\\n #######################################################################\\n # TODO: #\\n # Compute the gradient for a particular choice of theta. #\\n # Compute the partial derivatives and set grad to the partial #\\n # derivatives of the cost w.r.t. each parameter in theta #\\n # #\\n #######################################################################\\n \\n theta = theta[:, np.newaxis]\\n \\n thetatrans = theta.T\\n Xtrans = X.T\\n \\n MulThetaX = np.dot(thetatrans, Xtrans)\\n \\n h = sigmoid(MulThetaX)\\n \\n grad = (y - h) * Xtrans\\n\\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return grad\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n wr = hyperparameters['weight_regularization']\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n\\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\\n df = np.reshape(df, ((len(df), 1)))\\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\\n\\n f += (weights[-1, 0] ** 2) * wr / 2\\n df[-1] += weights[-1,0] * wr \\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def cost_(theta, X, Y):\\n if X.shape[1] + 1 != theta.size or X.shape[0] != Y.size:\\n print(\\\"Inc dim\\\")\\n return\\n c = cost_elem_(theta, X, Y)\\n s = 0\\n for i in c:\\n s = s + i\\n return(s)\",\n \"def loss(self, X_batch, y_batch, learning_rate=1e-3, one_vs_all_index=-1, reg=True):\\n #########################################################################\\n # TODO: #\\n # calculate the loss and the derivative #\\n #########################################################################\\n loss = 0\\n for i in range(X_batch.shape[0]):\\n if one_vs_all_index == -1:\\n loss += -(y_batch[i] * (np.dot(self.w.T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.w.T, X_batch[i])))\\n else:\\n if reg:\\n reg = (learning_rate / 2 * X_batch.shape[0]) * np.sum(np.power(self.ws[one_vs_all_index], 2))\\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + reg\\n else:\\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i])))\\n gradients = np.zeros(X_batch.shape[1])\\n if one_vs_all_index == -1:\\n dot = np.dot(X_batch, self.w)\\n else:\\n dot = np.dot(X_batch, self.ws[one_vs_all_index])\\n logists = sigmod(dot)\\n diff = y_batch - logists\\n for index in range(X_batch.shape[0]):\\n if one_vs_all_index != -1:\\n if reg:\\n dot = np.dot(X_batch[index], diff[index])\\n gradients[1:] += dot[1:] + (learning_rate / X_batch.shape[0]) * self.ws[one_vs_all_index][1:]\\n gradients[0] += dot[0]\\n else:\\n gradients += np.dot(X_batch[index], diff[index])\\n else:\\n gradients += np.dot(X_batch[index], diff[index])\\n\\n return loss, gradients / X_batch.shape[0] # 取均值免得步长过大直接nan\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def cost_func(w, X, y):\\n y_pred = np.dot(X, w)\\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\\n\\n return err\",\n \"def calculate_gradient(y, tx, w): \\n return tx.T@(sigmoid(tx@w)-y)\",\n \"def calculate_gradient(y, tx, w):\\n\\n\\tret = tx.T.dot(sigmoid(np.dot(tx, w)) - y)\\n\\treturn ret\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def calc_grad(X, Y, theta):\\n m, n = X.shape\\n\\n margins = Y * X.dot(theta)\\n probs = 1. / (1 + np.exp(margins))\\n grad = -(1./m) * (X.T.dot(probs * Y))\\n\\n return grad\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def gradient_descent(self, X, theta, Y, m):\\n\\n Z = X.dot(theta)\\n H = Predict.g(Z)\\n gradient = np.dot(X.T, (H - Y)) / m\\n return self.alpha * gradient\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79731613","0.79660696","0.77614254","0.7753233","0.7751599","0.7738234","0.7619114","0.7614405","0.756269","0.74779886","0.7462293","0.74533564","0.74393666","0.74089724","0.73822963","0.7329635","0.7329065","0.7310318","0.725654","0.72156954","0.71965724","0.7182802","0.71619695","0.71606594","0.7159231","0.71384776","0.71191376","0.71152383","0.70817584","0.70817584","0.7059236","0.7058607","0.70203626","0.7001082","0.699867","0.6995641","0.6993435","0.6964408","0.6953484","0.6939201","0.69249535","0.6913293","0.6895181","0.6892946","0.68894386","0.68729466","0.68675923","0.6846738","0.6841341","0.6840808","0.68355024","0.68348986","0.6826751","0.6802818","0.6779373","0.6778159","0.67592746","0.67558897","0.67541414","0.67521083","0.6745872","0.6733722","0.66985816","0.6667304","0.665834","0.6653984","0.6650926","0.66460013","0.66453964","0.66301227","0.660797","0.66043836","0.6599449","0.65984535","0.6581307","0.6581183","0.65759","0.65658665","0.6549021","0.65465623","0.65461624","0.65450716","0.65422297","0.65415037","0.6538364","0.6530038","0.65288675","0.6528832","0.6528191","0.6519741","0.6518749","0.65161663","0.6513082","0.6510606","0.6504117","0.6493325","0.64924324","0.6485277","0.64819854","0.647585"],"string":"[\n \"0.79731613\",\n \"0.79660696\",\n \"0.77614254\",\n \"0.7753233\",\n \"0.7751599\",\n \"0.7738234\",\n \"0.7619114\",\n \"0.7614405\",\n \"0.756269\",\n \"0.74779886\",\n \"0.7462293\",\n \"0.74533564\",\n \"0.74393666\",\n \"0.74089724\",\n \"0.73822963\",\n \"0.7329635\",\n \"0.7329065\",\n \"0.7310318\",\n \"0.725654\",\n \"0.72156954\",\n \"0.71965724\",\n \"0.7182802\",\n \"0.71619695\",\n \"0.71606594\",\n \"0.7159231\",\n \"0.71384776\",\n \"0.71191376\",\n \"0.71152383\",\n \"0.70817584\",\n \"0.70817584\",\n \"0.7059236\",\n \"0.7058607\",\n \"0.70203626\",\n \"0.7001082\",\n \"0.699867\",\n \"0.6995641\",\n \"0.6993435\",\n \"0.6964408\",\n \"0.6953484\",\n \"0.6939201\",\n \"0.69249535\",\n \"0.6913293\",\n \"0.6895181\",\n \"0.6892946\",\n \"0.68894386\",\n \"0.68729466\",\n \"0.68675923\",\n \"0.6846738\",\n \"0.6841341\",\n \"0.6840808\",\n \"0.68355024\",\n \"0.68348986\",\n \"0.6826751\",\n \"0.6802818\",\n \"0.6779373\",\n \"0.6778159\",\n \"0.67592746\",\n \"0.67558897\",\n \"0.67541414\",\n \"0.67521083\",\n \"0.6745872\",\n \"0.6733722\",\n \"0.66985816\",\n \"0.6667304\",\n \"0.665834\",\n \"0.6653984\",\n \"0.6650926\",\n \"0.66460013\",\n \"0.66453964\",\n \"0.66301227\",\n \"0.660797\",\n \"0.66043836\",\n \"0.6599449\",\n \"0.65984535\",\n \"0.6581307\",\n \"0.6581183\",\n \"0.65759\",\n \"0.65658665\",\n \"0.6549021\",\n \"0.65465623\",\n \"0.65461624\",\n \"0.65450716\",\n \"0.65422297\",\n \"0.65415037\",\n \"0.6538364\",\n \"0.6530038\",\n \"0.65288675\",\n \"0.6528832\",\n \"0.6528191\",\n \"0.6519741\",\n \"0.6518749\",\n \"0.65161663\",\n \"0.6513082\",\n \"0.6510606\",\n \"0.6504117\",\n \"0.6493325\",\n \"0.64924324\",\n \"0.6485277\",\n \"0.64819854\",\n \"0.647585\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71322453"},"document_rank":{"kind":"string","value":"26"}}},{"rowIdx":78494,"cells":{"query":{"kind":"string","value":"Calculates cost and its gradient using Cross Entropy. (1 / m) np.sum(Y np.log(Y_hat))"},"document":{"kind":"string","value":"def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat"},"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 compute_cost(Y_hat, Y):\r\n\r\n m = Y.shape[1]\r\n\r\n\r\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\r\n\r\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\r\n\r\n return cost","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","def cost(h, y):\n\tm = y.shape[0]\n\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\n\treturn cost","def cost(TH,X,Y,lda=1):\n m = X.shape[0]\n htx = ff(X,TH)[-1]\n\n termsum = 0\n for rn in range(m):\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\n termsum = 1./m*(termsum)\n\n regsum = 0\n for th in TH:\n regsum += sum(sum(np.power(th[:,1:],2)))\n regsum = lda/(2.*m)*regsum\n\n return termsum[0,0] +regsum","def cost(self, X=None, y=None, theta=None):\n X = self.X_train if X is None else X\n y = self.y_train if y is None else y\n m = X.shape[1]\n\n prob_mat = self.softmax_mat(X, theta)\n cost = -(y * np.log(prob_mat)).sum() / m\n return cost","def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def compute_cost(AL, Y):\n m = Y.shape[1]\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\n cost = np.sum(log_val) * (-1/m)\n cost = np.squeeze(cost)\n return cost","def cost(self, Y, A):\n loss1 = Y * np.log(A)\n m = Y.shape[1]\n cost = -1 * np.sum(loss1) / m\n return cost","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def cost(self, h_theta, y):\n \n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)","def compute_cost(self, AL, Y):\n m = Y.shape[1]\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\n cost = np.squeeze(cost)\n\n return cost","def compute_cost(AL, Y):\n m = AL.shape[1]\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\n cost = np.squeeze(cost)\n return cost","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","def __get_cost_value(self, Y_hat, Y):\n m = Y_hat.shape[1]\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\n return T.squeeze(cost)","def compute_cost(X, y, theta, lambd):\n assert(theta.shape[0] == X.shape[1])\n \n m = X.shape[0]\n grad = np.zeros(y.shape)\n J = 0\n \n output = sigmoid(np.dot(X, theta))\n\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\n\n grad = np.dot(X.T, (output - y)) / m\n \n grad[1:] = grad[1:] + lambd / m * theta[1:]\n\n return J, grad","def cost(self, X, y) :\n ### ========== TODO : START ========== ###\n # part d: compute J(theta)\n #we know for linear/polynomial regression, the cost is the square of the errors\n X = self.generate_polynomial_features(X)\n y_pred_vector = np.dot(X, self.coef_)\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\n ### ========== TODO : END ========== ###\n return cost","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def cost(self, Y, A):\n m = Y.shape[1]\n cost = - (1 / m) * np.sum(\n np.multiply(\n Y, np.log(A)) + np.multiply(\n 1 - Y, np.log(1.0000001 - A)))\n return cost","def cost(self, Y, A):\n\n m = Y.shape[1]\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\n (np.log(1.0000001 - A)))\n return C","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","def cross_entropy_gradient(self, yhat):\n n = len(self._y)\n p = len(self.beta)\n g = np.zeros(p)\n for i in range(0, n):\n g = g + (self._y[i] - yhat[i]) * np.array(\n [1.0, *self._feat_mtx[i, :]])\n\n return g","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def gradient_descent(x, y, theta=[[0], [0]]):\n m = y.size\n j_history = []\n for i in range(ITERATIONS):\n h = x.dot(theta)\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\n j_history.append(compute_cost(x, y, theta))\n return theta, j_history","def gradientDescent(self,X, y, theta): \n # number of instances\n m = len(y)\n J_history = np.zeros((self.NUM_ITERS,1))\n for i in range(self.NUM_ITERS):\n h = self.sigmoid(X@theta)\n grad = 1 / m * X.T @ (h - y)\n theta = theta - self.ALPHA * grad \n J_history[i] = self.costFunction(theta, X, y)\n \n \n return theta, J_history","def getCost(Y_predicted, Y):\n delta = 1e-47 # threshold to avoid log(0)\n _, m = Y.shape\n if __debug__:\n print(\"~~~~~~~~~ COST ~~~~~~~~~\")\n print(\"m: {}\".format(m))\n print(\"Max and min values predicted: {} & {}\".format(np.max(Y_predicted), np.min(Y_predicted)))\n print(\"Max and min values true: {} & {}\".format(np.max(Y), np.min(Y)))\n return -np.sum(Y * np.log(Y_predicted + delta) + (1 - Y) * np.log(1 - Y_predicted + delta))/m","def compute_cost(AL, Y):\n \n m = Y.shape[1]\n\n # Compute loss from aL and y.\n ### START CODE HERE ### (≈ 1 lines of code)\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\n ### END CODE HERE ###\n \n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\n assert(cost.shape == ())\n \n return cost","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def loss(self, X, Y, lmd):\n P, _ = self.forward(X)\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\n\n reg = 0 # Regularization term\n for w in self.W:\n reg += np.sum(np.square(w))\n\n reg *= lmd\n\n cost = loss + reg\n\n return cost","def compute_cost(AL, Y):\n\n m = Y.shape[1] # number of example\n\n n = 10 #number of labels\n\n y_binary = get_binary_matrix(Y)\n\n # Compute the cross-entropy cost\n # sum_M = 0\n # for i in range(m):\n # sum_K = 0\n # for k in range(n):\n # cur_y = 0\n # if (Y[0, i] == k):\n # cur_y = 1\n # sum_K += -cur_y * np.log(A2[k, i]) - (1 - cur_y) * np.log(1 - A2[k, i])\n # sum_M += sum_K\n #\n # cost = 1 / m * sum_M\n\n logprobs = np.multiply(-y_binary, np.log(AL)) - np.multiply((1 - y_binary), np.log(1 - AL))\n cost = 1 / m * np.sum(logprobs)\n\n cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect.\n # E.g., turns [[17]] into 17\n\n return cost","def compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\n #print theta, grad_theta, objective_function(theta, X, y)\n return grad_theta","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def gradient_descent(self, X, theta, Y, m):\n\n Z = X.dot(theta)\n H = Predict.g(Z)\n gradient = np.dot(X.T, (H - Y)) / m\n return self.alpha * gradient","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def fast_loss_and_grad(self, X, y):\n loss = 0.0\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and gradient WITHOUT any for loops.\n # ================================================================ #\n \n num_train = X.shape[0]\n num_classes = self.W.shape[0]\n \n# # vectorized loss calculation #\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\n \n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\n# #print(exp_a[:,:3])\n# #print(y[:3])\n# #print(y_exp[:3])\n \n# tt = np.sum(exp_a,axis=0)\n# tt2 = np.divide(tt,y_exp)\n# print(num_train)\n# tt3 = np.power(tt2,1/num_train)\n# loss = np.log(np.prod(tt3))\n \n \n \n \n (C, D) = self.W.shape\n N = X.shape[0]\n\n scores = np.dot(self.W, X.T)\n scores -= np.max(scores) # shift by log C to avoid numerical instability\n\n y_mat = np.zeros(shape = (C, N))\n y_mat[y, range(N)] = 1\n\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\n # quantity we need to subtract from each row of scores\n correct_wx = np.multiply(y_mat, scores)\n\n # create a single row of the correct wx_y + log C values for each data point\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\n\n exp_scores = np.exp(scores)\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\n result = np.log(sums_exp)\n\n result -= sums_wy\n\n loss = np.sum(result)\n loss /= num_train\n \n \n # vectorized gradient calculation #\n exp_a_sum = np.sum(exp_a,axis=0)\n\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\n y_mat_corres[y, range(num_train)] = 1\n sum_exp_scores = np.sum(exp_a, axis=0) \n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\n exp_a *= sum_exp_scores\n grad = np.dot(exp_a, X)\n grad -= np.dot(y_mat_corres, X)\n grad /= num_train\n \n\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def prediction_cost(a, y):\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def cost_function(theta, X, y):\n\n l = None\n #######################################################################\n # TODO: #\n # Compute and return the cost l of a particular choice of #\n # theta. #\n # #\n #######################################################################\n thetaX = np.dot(X, theta)\n g = tanh(thetaX)-y\n l = np.sum(g*g) / X.shape[0]\n \n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return l","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def cross_entropy_cost(m, A, L):\n\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\n\n\n\t# Sanity checks\n\tcost = np.squeeze(cost) \t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\n\tassert(cost.shape == ()) \t#checks if cost value is a scalar\n\n\treturn cost","def compute_cost(A2, Y, parameters):\n\n\tm = Y.shape[1] # number of example\n\n\t# Compute the cross-entropy cost\n\tlogprobs = np.multiply(np.log(A2), Y)\n\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\n\n\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \n\t \t# E.g., turns [[17]] into 17 \n\tassert(isinstance(cost, float))\n\n\treturn cost","def compute_gradients(self, logits, target):\n\n target_length = target.shape[0]\n num_time_steps = logits.shape[0]\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n\n # expand labels by inserting a blank between each pair\n normalized_logits = softmax(logits)\n blank_label = normalized_logits.shape[1] - 1\n l = add_blanks(target, blank_label)\n target_length = l.shape[0]\n\n alpha = self.compute_forward_variables(normalized_logits, target) \n beta = self.compute_backward_variables(normalized_logits, target)\n\n # rescale\n alpha = alpha / np.sum(alpha, axis=0)\n beta = beta / np.sum(beta, axis=0)\n alphabeta = alpha * beta\n print \"alpha\"\n print alpha\n\n # compute zt\n z = Counter()\n for t in xrange(num_time_steps):\n for s, k in enumerate(l):\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\n \n # normalized_logits is time steps t by labels k\n # alpha is 2 * target_length - 1 by time steps\n lab_zk = np.zeros_like(normalized_logits)\n for s, k in enumerate(l):\n for t in xrange(num_time_steps):\n lab_zk[t, k] += alphabeta[s, t]\n\n grad = normalized_logits\n for k in xrange(target.shape[0]):\n for t in xrange(num_time_steps):\n ytk = normalized_logits[t, k]\n constant = 1.0 / (ytk * z[t])\n grad[t, k] = ytk - constant * lab_zk[t, k]\n \n return grad","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\n m = X.shape[0]\n y_hat = sigmoid(X @ theta.T)\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\n temp = theta\n temp[0] = 0\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\n return J, grad","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n y_hat = softmax(np.dot(outputVectors,predicted))\n y = np.zeros(outputVectors.shape[0])\n y[target] = 1.0\n\n cost = -np.log(y_hat[target])\n gradPred = np.dot(outputVectors.T,y_hat - y)\n grad = np.outer(y_hat - y,predicted)\n ### END YOUR CODE\n\n return cost, gradPred, grad","def loss_gradient(self, targets, scores):\n m = targets * scores\n numer = 4. * (2. * numpy.arctan(m) - 1.)\n denom = 1. + m**2\n return numer/denom","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def cross_entropoy_loss_vectorized(W, X, y, reg): \n loss = 0 \n dW = np.zeros_like(W)\n N, D = X.shape \n \n \n scores = X.dot(W) # [K, N]\n # for numerical stability)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[range(N),y] \n scores_exp_sum = np.sum(scores_exp, axis=1) \n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= N\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = scores_exp.T / scores_exp_sum \n scores_exp_normalized[y, range(N)] -= 1 \n dW = np.dot(scores_exp_normalized,X)\n dW = dW.T\n dW /= N \n dW += reg * W\n \n \n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def comp_cost(y_hat, y, activation, epsilon=1e-15):\n if activation == 'sigmoid':\n m = y.shape[1]\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\n cost = (-1. / m) * cost\n cost = np.squeeze(cost) # turns [[17]] into 17).\n assert (cost.shape == ())\n elif activation == 'softmax':\n \"\"\"\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\n \n Arguments:\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\n \n Returns:\n cost -- categorical cross entropy cost\n \n Algorithm:\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\n \n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \n \"\"\"\n cost = log_loss(y, y_hat)\n else:\n raise AttributeError('Unexpected activation function:', activation)\n return cost","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\n m, n = X.shape\n intercept = ones((m, 1), dtype=float64)\n X = append(intercept, X, axis=1)\n\n _h = h(X, theta, n_hidden_layers) # model hypothesis\n\n J = 0\n for c in range(num_labels):\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\n _J = _J + dot((y == c).T, log(_h[:, c]))\n J = J - (1 / m) * sum(_J)\n\n theta_squared_term = 0\n for j in range(len(theta)):\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\n\n J = J + (_lambda / (2 * m)) * theta_squared_term\n\n return J","def cross_entropoy_loss_vectorized(W, X, y, reg):\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n \n amount = y.shape[0]\n exp_scores = np.exp(np.dot(X,W))\n p_scores = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\n log_scores = -np.log(p_scores[range(amount),y])\n loss += np.sum(log_scores)/amount\n\n loss += reg*np.sum(W*W)/2\n \n p_scores[range(amount), y] -= 1\n p_scores /= amount\n p_scores = np.dot(X.T, p_scores) \n dW = p_scores\n dW += reg*W\n\n return loss, dW","def cost(theta, X, y, Lambda=0.0):\n m = X.shape[0] # number of samples\n\n h = hypothesis(theta, X) \n \n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \n\n reg_term = 0.0\n if Lambda:\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\n\n return (1/m)*suma + reg_term","def compute_cost(A3, Y):\n m = A3.shape[1]\n cost = -1 / m * (np.dot(Y, np.log(A3).T) + np.dot(1 - Y, np.log(1 - A3).T));\n return cost","def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -(Y / Y_hat) + (1 - Y) / (1 - Y_hat)\n \n return cost, dY_hat","def compute_cost_derivative(AL, Y):\n pass","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def calc_grad(X, Y, theta):\n m, n = X.shape\n\n margins = Y * X.dot(theta)\n probs = 1. / (1 + np.exp(margins))\n grad = -(1./m) * (X.T.dot(probs * Y))\n\n return grad","def compute_cost(A2, Y, params):\n m = Y.shape[1]\n \n logprobs1 = -np.dot(Y, np.log(A2).T)\n logprobs2 = -np.dot(1-Y, np.log(1-A2).T)\n cost = 1/m * (logprobs1 + logprobs2)\n \n cost = np.asscalar(cost)\n return cost","def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\n h = compute_probabilities(X, theta, temp_parameter)\n\n cost = 0\n for i in range(X.shape[0]):\n for j in range(theta.shape[0]):\n if Y[i] == j:\n cost += np.log(h[j,i])\n\n cost = -cost / X.shape[0]\n\n theta = np.power(theta, 2)\n\n cost += lambda_factor / 2 * theta.sum()\n\n return cost","def softmaxCostAndGradient(vc_predicted, target, uw_output, dataset):\n\n N = uw_output.shape[0] # n_words: vocab size\n y = np.zeros(N)\n y[target] = 1 # y is a 1-hot encoded vector with the actual word's index being 1 and rest of elements being 0\n\n score = np.dot(vc_predicted, uw_output.T) # vc dot uo_transpose which gives a vector of dimension (1, n_words)\n y_hat = softmax(score)\n\n # cross-entropy cost is given by formula in assignment 1.2b\n cost = np.sum(-y * np.log(y_hat))\n\n dout = y_hat - y # (1, n_words)\n\n grad_pred_dJ_vc = np.dot(dout, uw_output) # (1, dim_embed)\n\n grad_dJ_uw = np.dot(dout.T, vc_predicted) # (n_words, dim_embed)\n\n return cost, grad_pred_dJ_vc, grad_dJ_uw","def get_cost(self, y_enc, output, w1, w2):\n cost = - np.sum(y_enc*np.log(output))\n # add the L2 regularization by taking the L2-norm of the weights and multiplying it with our constant.\n l2_term = (self.l2/2.0) * (np.sum(np.square(w1[:, 1:])) + np.sum(np.square(w2[:, 1:])))\n cost = cost + l2_term\n return cost/y_enc.shape[1]","def loss(self, y: np.ndarray, y_hat: np.ndarray) -> float:\n losses = -(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))\n return losses.mean() + self.reg / self.num_parameters * (\n (self.v[:, -1] ** 2).sum() + (self.w ** 2).sum()\n )","def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\n return cost","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n\r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range (num_iterations):\r\n \r\n h = numpy.dot(features, theta)\r\n \r\n theta = theta - alpha / m * numpy.dot((h-values),features)\r\n \r\n cost = compute_cost(features, values, theta)\r\n \r\n cost_history.append(cost)\r\n\r\n return theta, pandas.Series(cost_history) # leave this line for the grader\r","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def _softmax_cost(self, theta, *args):\n epsilon = 1e-32\n wd, PHI, y = args\n N, P = PHI.shape\n W = np.reshape(theta, [P, -1])\n t = softmax(np.matmul(PHI, W)) + epsilon\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\n grad = grad.flatten()\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\n return cost, grad","def cost_func(w, X, y):\n y_pred = np.dot(X, w)\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\n\n return err","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def gradient(cls, y, y_target):\n return (y - y_target) / MEE.euclidean_distance(y, y_target)","def fit(self, X, y):\n\n n, m = X.shape[0], X.shape[1]\n\n # theta is (nx1) (one theta per dimension)\n self.theta = np.random.uniform(-10, 10, (n, 1))\n\n for i in range(self.epochs):\n # Get predictions\n y_pred = self.predict(X)\n\n # calculate cost\n # cost = ...\n cost = self._cost_function(y_pred, y, m)\n \n\n # gradient is an (n) x 1 array, it refers to the derivate per theta\n gradient = self._cost_function_derivative(y_pred, y, X, m)\n\n # delta/update rule\n self.theta = gradient\n\n self.costs.append(cost)\n pass\n\n print(\"Final theta is {} (cost: {})\".format(self.theta.T, cost))","def compute_cost(Z6, Y):\n\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\n\n return cost","def cost_grad_log_reg(w, b, X, y, Multicalss=False):\n if not len(X.shape) == 2:\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\n else:\n X_flattened = X\n m = X_flattened.shape[1]\n print(m)\n if Multicalss:\n # Multi-class\n\n y_train_reshaped = y.reshape(len(y), 1)\n ohe = OneHotEncoder(categories='auto')\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\n print(y_train_reshaped.shape)\n A = softmax(np.dot(X_flattened, w) + b)\n print(A.shape)\n xentropy = -np.sum(y_train_reshaped * np.log(A))\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\n keepdims=True))\n\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\n db = 1 / m * np.sum(A - y_train_reshaped)\n else:\n # Binary\n A = sigmoid(np.dot(w.T, X_flattened) + b)\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\n\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\n db = 1 / m * np.sum(A - y)\n\n # grads/derivatives\n cost = np.squeeze(cost)\n\n return dw, db, cost","def calc_gradient(self, W, X, y, reg):\n\n N = X.shape[0]\n grad_W = np.zeros_like(W)\n I = np.ones((1,10))\n score = np.dot(X, W) # (N, C)\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\n #print(\"out\", out)\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\n \n dout = np.copy(out) # (N, C)\n dout[np.arange(N), y] -= 1\n grad_W = np.dot(X.T, dout) # (D, C)\n grad_W /= N\n #grad_W += reg * W\n \n return grad_W","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # You need to return the following variable correctly.\n grad = np.zeros(theta.shape)\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the partial derivatives and set grad to the partial\n # derivatives of the cost w.r.t. each parameter in theta.\n\n # =============================================================\n return grad","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def compute_cost(features, values, theta):\r\n m = len(values)\r\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\r\n cost = sum_of_square_errors / (2*m)\r\n\r\n return cost","def grad_log(self, X):\n # \"\"\"\n # Evaluate the gradients (with respect to the input) of the log density at\n # each of the n points in X. This is the score function.\n\n # X: n x d numpy array.\n XB = np.dot(X, self.B)\n Y = 0.5*XB + self.c\n E2y = np.exp(2*Y)\n # n x dh\n Phi = old_div((E2y-1.0),(E2y+1))\n # n x dx\n T = np.dot(Phi, 0.5*self.B.T)\n S = self.b - X + T\n return S","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def calc_cost(y, yhat, cost_matrix):\n return np.mean(cost_matrix[list(y), list(yhat)])","def approx_grad(theta, X, y):\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def compute_logistic_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)","def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\n A = np.dot(self.X, self.w)\n m = self.t.shape[0]\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\n return (1 / m) * np.dot(self.X.T, C)","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def _cost_function_derivative(self, y_pred, y, X, m):\n\n derivatives= np.zeros((X.shape[0],1))\n for j in range(X.shape[0]):\n auxsum = 0\n for i in range(m):\n auxsum+=(y_pred[0][i] -y[0][i])*X[j][i]\n derivatives[j][0] = self.theta[j][0] - self.alpha * 1/m * auxsum\n\n #empty_derivatives = np.zeros((X.shape[0],1))\n return derivatives","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\n y_hat = softmax(scores)\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\n one_hot_target = np.zeros_like(y_hat)\n one_hot_target[target] = 1\n grad = np.outer((y_hat - one_hot_target), predicted)\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\n \n '''\n final_predicted = predicted.dot(outputVectors.T)\n probability = softmax(final_predicted)\n cost = -np.log(probability[target])\n \n one_hot_target = np.zeros_like(probability)\n one_hot_target[target] += 1\n dlogits = probability - one_hot_target\n grad = np.outer(predicted, dlogits).T\n gradPred = outputVectors.T.dot(dlogits)\n '''\n ### END YOUR CODE\n\n return cost, gradPred, grad","def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and the gradient. Store the gradient\n # as the variable grad.\n # ================================================================ #\n \n exp_a = np.zeros((num_classes,num_train))\n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n \n #if i==0:\n grada = np.zeros(X.shape[1])\n \n for j in range(num_classes):\n if j != y[i]:\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \n else: \n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \n\n grad += grad_tmp\n loss += Loss \n \n pass\n\n\n loss /= num_train\n grad /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def cross_entropy_cost(output_out, target_out):\r\n total = 0\r\n for target_node in range(len(target_out)): # For each target data set\r\n for output_node in range(len(output_out)): # For each output node\r\n total += target_out[target_node][output_node] - target_out[target_node][output_node] * np.log(output_out[output_node]) - \\\r\n (1 - target_out[target_node][output_node]) * np.log(1 - output_out[output_node])\r\n\r\n total = 1 / total\r\n return total","def compute_cost(features, values, theta):\n m = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2 * m)\n\n return cost","def cost_(theta, X, Y):\n if X.shape[1] + 1 != theta.size or X.shape[0] != Y.size:\n print(\"Inc dim\")\n return\n c = cost_elem_(theta, X, Y)\n s = 0\n for i in c:\n s = s + i\n return(s)"],"string":"[\n \"def compute_cost(Y_hat, Y):\\r\\n\\r\\n m = Y.shape[1]\\r\\n\\r\\n\\r\\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\\r\\n\\r\\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\r\\n\\r\\n return cost\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\n \"def cost(h, y):\\n\\tm = y.shape[0]\\n\\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\\n\\treturn cost\",\n \"def cost(TH,X,Y,lda=1):\\n m = X.shape[0]\\n htx = ff(X,TH)[-1]\\n\\n termsum = 0\\n for rn in range(m):\\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\\n termsum = 1./m*(termsum)\\n\\n regsum = 0\\n for th in TH:\\n regsum += sum(sum(np.power(th[:,1:],2)))\\n regsum = lda/(2.*m)*regsum\\n\\n return termsum[0,0] +regsum\",\n \"def cost(self, X=None, y=None, theta=None):\\n X = self.X_train if X is None else X\\n y = self.y_train if y is None else y\\n m = X.shape[1]\\n\\n prob_mat = self.softmax_mat(X, theta)\\n cost = -(y * np.log(prob_mat)).sum() / m\\n return cost\",\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def compute_cost(AL, Y):\\n m = Y.shape[1]\\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\\n cost = np.sum(log_val) * (-1/m)\\n cost = np.squeeze(cost)\\n return cost\",\n \"def cost(self, Y, A):\\n loss1 = Y * np.log(A)\\n m = Y.shape[1]\\n cost = -1 * np.sum(loss1) / m\\n return cost\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def cost(self, h_theta, y):\\n \\n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)\",\n \"def compute_cost(self, AL, Y):\\n m = Y.shape[1]\\n cost = (-1 / m) * np.sum(np.multiply(Y, np.log(AL)) + np.multiply(1 - Y, np.log(1 - AL)))\\n cost = np.squeeze(cost)\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n m = AL.shape[1]\\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\\n cost = np.squeeze(cost)\\n return cost\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\n \"def __get_cost_value(self, Y_hat, Y):\\n m = Y_hat.shape[1]\\n cost = -1 / m * (T.dot(Y, T.log(Y_hat).T) + T.dot(T.sub(1, Y), T.log(1 - Y_hat).T))\\n return T.squeeze(cost)\",\n \"def compute_cost(X, y, theta, lambd):\\n assert(theta.shape[0] == X.shape[1])\\n \\n m = X.shape[0]\\n grad = np.zeros(y.shape)\\n J = 0\\n \\n output = sigmoid(np.dot(X, theta))\\n\\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\\n\\n grad = np.dot(X.T, (output - y)) / m\\n \\n grad[1:] = grad[1:] + lambd / m * theta[1:]\\n\\n return J, grad\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def cost(self, Y, A):\\n m = Y.shape[1]\\n cost = - (1 / m) * np.sum(\\n np.multiply(\\n Y, np.log(A)) + np.multiply(\\n 1 - Y, np.log(1.0000001 - A)))\\n return cost\",\n \"def cost(self, Y, A):\\n\\n m = Y.shape[1]\\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\\n (np.log(1.0000001 - A)))\\n return C\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\n \"def cross_entropy_gradient(self, yhat):\\n n = len(self._y)\\n p = len(self.beta)\\n g = np.zeros(p)\\n for i in range(0, n):\\n g = g + (self._y[i] - yhat[i]) * np.array(\\n [1.0, *self._feat_mtx[i, :]])\\n\\n return g\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def gradient_descent(x, y, theta=[[0], [0]]):\\n m = y.size\\n j_history = []\\n for i in range(ITERATIONS):\\n h = x.dot(theta)\\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\\n j_history.append(compute_cost(x, y, theta))\\n return theta, j_history\",\n \"def gradientDescent(self,X, y, theta): \\n # number of instances\\n m = len(y)\\n J_history = np.zeros((self.NUM_ITERS,1))\\n for i in range(self.NUM_ITERS):\\n h = self.sigmoid(X@theta)\\n grad = 1 / m * X.T @ (h - y)\\n theta = theta - self.ALPHA * grad \\n J_history[i] = self.costFunction(theta, X, y)\\n \\n \\n return theta, J_history\",\n \"def getCost(Y_predicted, Y):\\n delta = 1e-47 # threshold to avoid log(0)\\n _, m = Y.shape\\n if __debug__:\\n print(\\\"~~~~~~~~~ COST ~~~~~~~~~\\\")\\n print(\\\"m: {}\\\".format(m))\\n print(\\\"Max and min values predicted: {} & {}\\\".format(np.max(Y_predicted), np.min(Y_predicted)))\\n print(\\\"Max and min values true: {} & {}\\\".format(np.max(Y), np.min(Y)))\\n return -np.sum(Y * np.log(Y_predicted + delta) + (1 - Y) * np.log(1 - Y_predicted + delta))/m\",\n \"def compute_cost(AL, Y):\\n \\n m = Y.shape[1]\\n\\n # Compute loss from aL and y.\\n ### START CODE HERE ### (≈ 1 lines of code)\\n cost = - ( np.sum( np.multiply( Y, np.log(AL)) + np.multiply( (1 - Y), np.log(1 - AL))))/Y.shape[1]\\n ### END CODE HERE ###\\n \\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\\n assert(cost.shape == ())\\n \\n return cost\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def loss(self, X, Y, lmd):\\n P, _ = self.forward(X)\\n loss = np.mean(-np.log(np.einsum('ij,ji->i', Y.T, P)))\\n\\n reg = 0 # Regularization term\\n for w in self.W:\\n reg += np.sum(np.square(w))\\n\\n reg *= lmd\\n\\n cost = loss + reg\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n\\n m = Y.shape[1] # number of example\\n\\n n = 10 #number of labels\\n\\n y_binary = get_binary_matrix(Y)\\n\\n # Compute the cross-entropy cost\\n # sum_M = 0\\n # for i in range(m):\\n # sum_K = 0\\n # for k in range(n):\\n # cur_y = 0\\n # if (Y[0, i] == k):\\n # cur_y = 1\\n # sum_K += -cur_y * np.log(A2[k, i]) - (1 - cur_y) * np.log(1 - A2[k, i])\\n # sum_M += sum_K\\n #\\n # cost = 1 / m * sum_M\\n\\n logprobs = np.multiply(-y_binary, np.log(AL)) - np.multiply((1 - y_binary), np.log(1 - AL))\\n cost = 1 / m * np.sum(logprobs)\\n\\n cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect.\\n # E.g., turns [[17]] into 17\\n\\n return cost\",\n \"def compute_gradient(theta, X, y):\\n m = X.shape[0]\\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\\n #print theta, grad_theta, objective_function(theta, X, y)\\n return grad_theta\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def gradient_descent(self, X, theta, Y, m):\\n\\n Z = X.dot(theta)\\n H = Predict.g(Z)\\n gradient = np.dot(X.T, (H - Y)) / m\\n return self.alpha * gradient\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def fast_loss_and_grad(self, X, y):\\n loss = 0.0\\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and gradient WITHOUT any for loops.\\n # ================================================================ #\\n \\n num_train = X.shape[0]\\n num_classes = self.W.shape[0]\\n \\n# # vectorized loss calculation #\\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\\n \\n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\\n# #print(exp_a[:,:3])\\n# #print(y[:3])\\n# #print(y_exp[:3])\\n \\n# tt = np.sum(exp_a,axis=0)\\n# tt2 = np.divide(tt,y_exp)\\n# print(num_train)\\n# tt3 = np.power(tt2,1/num_train)\\n# loss = np.log(np.prod(tt3))\\n \\n \\n \\n \\n (C, D) = self.W.shape\\n N = X.shape[0]\\n\\n scores = np.dot(self.W, X.T)\\n scores -= np.max(scores) # shift by log C to avoid numerical instability\\n\\n y_mat = np.zeros(shape = (C, N))\\n y_mat[y, range(N)] = 1\\n\\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\\n # quantity we need to subtract from each row of scores\\n correct_wx = np.multiply(y_mat, scores)\\n\\n # create a single row of the correct wx_y + log C values for each data point\\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\\n\\n exp_scores = np.exp(scores)\\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\\n result = np.log(sums_exp)\\n\\n result -= sums_wy\\n\\n loss = np.sum(result)\\n loss /= num_train\\n \\n \\n # vectorized gradient calculation #\\n exp_a_sum = np.sum(exp_a,axis=0)\\n\\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\\n y_mat_corres[y, range(num_train)] = 1\\n sum_exp_scores = np.sum(exp_a, axis=0) \\n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\\n exp_a *= sum_exp_scores\\n grad = np.dot(exp_a, X)\\n grad -= np.dot(y_mat_corres, X)\\n grad /= num_train\\n \\n\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def prediction_cost(a, y):\\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def cost_function(theta, X, y):\\n\\n l = None\\n #######################################################################\\n # TODO: #\\n # Compute and return the cost l of a particular choice of #\\n # theta. #\\n # #\\n #######################################################################\\n thetaX = np.dot(X, theta)\\n g = tanh(thetaX)-y\\n l = np.sum(g*g) / X.shape[0]\\n \\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return l\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def cross_entropy_cost(m, A, L):\\n\\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\\n\\n\\n\\t# Sanity checks\\n\\tcost = np.squeeze(cost) \\t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\\n\\tassert(cost.shape == ()) \\t#checks if cost value is a scalar\\n\\n\\treturn cost\",\n \"def compute_cost(A2, Y, parameters):\\n\\n\\tm = Y.shape[1] # number of example\\n\\n\\t# Compute the cross-entropy cost\\n\\tlogprobs = np.multiply(np.log(A2), Y)\\n\\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\\n\\n\\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \\n\\t \\t# E.g., turns [[17]] into 17 \\n\\tassert(isinstance(cost, float))\\n\\n\\treturn cost\",\n \"def compute_gradients(self, logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n\\n # expand labels by inserting a blank between each pair\\n normalized_logits = softmax(logits)\\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n alpha = self.compute_forward_variables(normalized_logits, target) \\n beta = self.compute_backward_variables(normalized_logits, target)\\n\\n # rescale\\n alpha = alpha / np.sum(alpha, axis=0)\\n beta = beta / np.sum(beta, axis=0)\\n alphabeta = alpha * beta\\n print \\\"alpha\\\"\\n print alpha\\n\\n # compute zt\\n z = Counter()\\n for t in xrange(num_time_steps):\\n for s, k in enumerate(l):\\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\\n \\n # normalized_logits is time steps t by labels k\\n # alpha is 2 * target_length - 1 by time steps\\n lab_zk = np.zeros_like(normalized_logits)\\n for s, k in enumerate(l):\\n for t in xrange(num_time_steps):\\n lab_zk[t, k] += alphabeta[s, t]\\n\\n grad = normalized_logits\\n for k in xrange(target.shape[0]):\\n for t in xrange(num_time_steps):\\n ytk = normalized_logits[t, k]\\n constant = 1.0 / (ytk * z[t])\\n grad[t, k] = ytk - constant * lab_zk[t, k]\\n \\n return grad\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def compute_cost_and_grad_with_reg(theta, X, y, lambda_):\\n m = X.shape[0]\\n y_hat = sigmoid(X @ theta.T)\\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\\n temp = theta\\n temp[0] = 0\\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\\n return J, grad\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n y_hat = softmax(np.dot(outputVectors,predicted))\\n y = np.zeros(outputVectors.shape[0])\\n y[target] = 1.0\\n\\n cost = -np.log(y_hat[target])\\n gradPred = np.dot(outputVectors.T,y_hat - y)\\n grad = np.outer(y_hat - y,predicted)\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def loss_gradient(self, targets, scores):\\n m = targets * scores\\n numer = 4. * (2. * numpy.arctan(m) - 1.)\\n denom = 1. + m**2\\n return numer/denom\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def cross_entropoy_loss_vectorized(W, X, y, reg): \\n loss = 0 \\n dW = np.zeros_like(W)\\n N, D = X.shape \\n \\n \\n scores = X.dot(W) # [K, N]\\n # for numerical stability)\\n scores -= np.max(scores)\\n scores_exp = np.exp(scores)\\n correct_scores_exp = scores_exp[range(N),y] \\n scores_exp_sum = np.sum(scores_exp, axis=1) \\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\\n loss /= N\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n scores_exp_normalized = scores_exp.T / scores_exp_sum \\n scores_exp_normalized[y, range(N)] -= 1 \\n dW = np.dot(scores_exp_normalized,X)\\n dW = dW.T\\n dW /= N \\n dW += reg * W\\n \\n \\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def comp_cost(y_hat, y, activation, epsilon=1e-15):\\n if activation == 'sigmoid':\\n m = y.shape[1]\\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\\n cost = (-1. / m) * cost\\n cost = np.squeeze(cost) # turns [[17]] into 17).\\n assert (cost.shape == ())\\n elif activation == 'softmax':\\n \\\"\\\"\\\"\\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\\n \\n Arguments:\\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\\n \\n Returns:\\n cost -- categorical cross entropy cost\\n \\n Algorithm:\\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\\n \\n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \\n \\\"\\\"\\\"\\n cost = log_loss(y, y_hat)\\n else:\\n raise AttributeError('Unexpected activation function:', activation)\\n return cost\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\n \"def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\\n m, n = X.shape\\n intercept = ones((m, 1), dtype=float64)\\n X = append(intercept, X, axis=1)\\n\\n _h = h(X, theta, n_hidden_layers) # model hypothesis\\n\\n J = 0\\n for c in range(num_labels):\\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\\n _J = _J + dot((y == c).T, log(_h[:, c]))\\n J = J - (1 / m) * sum(_J)\\n\\n theta_squared_term = 0\\n for j in range(len(theta)):\\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\\n\\n J = J + (_lambda / (2 * m)) * theta_squared_term\\n\\n return J\",\n \"def cross_entropoy_loss_vectorized(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n amount = y.shape[0]\\n exp_scores = np.exp(np.dot(X,W))\\n p_scores = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)\\n log_scores = -np.log(p_scores[range(amount),y])\\n loss += np.sum(log_scores)/amount\\n\\n loss += reg*np.sum(W*W)/2\\n \\n p_scores[range(amount), y] -= 1\\n p_scores /= amount\\n p_scores = np.dot(X.T, p_scores) \\n dW = p_scores\\n dW += reg*W\\n\\n return loss, dW\",\n \"def cost(theta, X, y, Lambda=0.0):\\n m = X.shape[0] # number of samples\\n\\n h = hypothesis(theta, X) \\n \\n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \\n\\n reg_term = 0.0\\n if Lambda:\\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\\n\\n return (1/m)*suma + reg_term\",\n \"def compute_cost(A3, Y):\\n m = A3.shape[1]\\n cost = -1 / m * (np.dot(Y, np.log(A3).T) + np.dot(1 - Y, np.log(1 - A3).T));\\n return cost\",\n \"def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -(Y / Y_hat) + (1 - Y) / (1 - Y_hat)\\n \\n return cost, dY_hat\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def calc_grad(X, Y, theta):\\n m, n = X.shape\\n\\n margins = Y * X.dot(theta)\\n probs = 1. / (1 + np.exp(margins))\\n grad = -(1./m) * (X.T.dot(probs * Y))\\n\\n return grad\",\n \"def compute_cost(A2, Y, params):\\n m = Y.shape[1]\\n \\n logprobs1 = -np.dot(Y, np.log(A2).T)\\n logprobs2 = -np.dot(1-Y, np.log(1-A2).T)\\n cost = 1/m * (logprobs1 + logprobs2)\\n \\n cost = np.asscalar(cost)\\n return cost\",\n \"def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n cost = 0\\n for i in range(X.shape[0]):\\n for j in range(theta.shape[0]):\\n if Y[i] == j:\\n cost += np.log(h[j,i])\\n\\n cost = -cost / X.shape[0]\\n\\n theta = np.power(theta, 2)\\n\\n cost += lambda_factor / 2 * theta.sum()\\n\\n return cost\",\n \"def softmaxCostAndGradient(vc_predicted, target, uw_output, dataset):\\n\\n N = uw_output.shape[0] # n_words: vocab size\\n y = np.zeros(N)\\n y[target] = 1 # y is a 1-hot encoded vector with the actual word's index being 1 and rest of elements being 0\\n\\n score = np.dot(vc_predicted, uw_output.T) # vc dot uo_transpose which gives a vector of dimension (1, n_words)\\n y_hat = softmax(score)\\n\\n # cross-entropy cost is given by formula in assignment 1.2b\\n cost = np.sum(-y * np.log(y_hat))\\n\\n dout = y_hat - y # (1, n_words)\\n\\n grad_pred_dJ_vc = np.dot(dout, uw_output) # (1, dim_embed)\\n\\n grad_dJ_uw = np.dot(dout.T, vc_predicted) # (n_words, dim_embed)\\n\\n return cost, grad_pred_dJ_vc, grad_dJ_uw\",\n \"def get_cost(self, y_enc, output, w1, w2):\\n cost = - np.sum(y_enc*np.log(output))\\n # add the L2 regularization by taking the L2-norm of the weights and multiplying it with our constant.\\n l2_term = (self.l2/2.0) * (np.sum(np.square(w1[:, 1:])) + np.sum(np.square(w2[:, 1:])))\\n cost = cost + l2_term\\n return cost/y_enc.shape[1]\",\n \"def loss(self, y: np.ndarray, y_hat: np.ndarray) -> float:\\n losses = -(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat))\\n return losses.mean() + self.reg / self.num_parameters * (\\n (self.v[:, -1] ** 2).sum() + (self.w ** 2).sum()\\n )\",\n \"def compute_cost(AL, Y, parameters ,lambd):\\n L = len(parameters) // 2\\n m = Y.shape[1]\\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\\n return cost\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n\\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range (num_iterations):\\r\\n \\r\\n h = numpy.dot(features, theta)\\r\\n \\r\\n theta = theta - alpha / m * numpy.dot((h-values),features)\\r\\n \\r\\n cost = compute_cost(features, values, theta)\\r\\n \\r\\n cost_history.append(cost)\\r\\n\\r\\n return theta, pandas.Series(cost_history) # leave this line for the grader\\r\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def _softmax_cost(self, theta, *args):\\n epsilon = 1e-32\\n wd, PHI, y = args\\n N, P = PHI.shape\\n W = np.reshape(theta, [P, -1])\\n t = softmax(np.matmul(PHI, W)) + epsilon\\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\\n grad = grad.flatten()\\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\\\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\\n return cost, grad\",\n \"def cost_func(w, X, y):\\n y_pred = np.dot(X, w)\\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\\n\\n return err\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def gradient(cls, y, y_target):\\n return (y - y_target) / MEE.euclidean_distance(y, y_target)\",\n \"def fit(self, X, y):\\n\\n n, m = X.shape[0], X.shape[1]\\n\\n # theta is (nx1) (one theta per dimension)\\n self.theta = np.random.uniform(-10, 10, (n, 1))\\n\\n for i in range(self.epochs):\\n # Get predictions\\n y_pred = self.predict(X)\\n\\n # calculate cost\\n # cost = ...\\n cost = self._cost_function(y_pred, y, m)\\n \\n\\n # gradient is an (n) x 1 array, it refers to the derivate per theta\\n gradient = self._cost_function_derivative(y_pred, y, X, m)\\n\\n # delta/update rule\\n self.theta = gradient\\n\\n self.costs.append(cost)\\n pass\\n\\n print(\\\"Final theta is {} (cost: {})\\\".format(self.theta.T, cost))\",\n \"def compute_cost(Z6, Y):\\n\\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\\n\\n return cost\",\n \"def cost_grad_log_reg(w, b, X, y, Multicalss=False):\\n if not len(X.shape) == 2:\\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\\n else:\\n X_flattened = X\\n m = X_flattened.shape[1]\\n print(m)\\n if Multicalss:\\n # Multi-class\\n\\n y_train_reshaped = y.reshape(len(y), 1)\\n ohe = OneHotEncoder(categories='auto')\\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\\n print(y_train_reshaped.shape)\\n A = softmax(np.dot(X_flattened, w) + b)\\n print(A.shape)\\n xentropy = -np.sum(y_train_reshaped * np.log(A))\\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\\n keepdims=True))\\n\\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\\n db = 1 / m * np.sum(A - y_train_reshaped)\\n else:\\n # Binary\\n A = sigmoid(np.dot(w.T, X_flattened) + b)\\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\\n\\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\\n db = 1 / m * np.sum(A - y)\\n\\n # grads/derivatives\\n cost = np.squeeze(cost)\\n\\n return dw, db, cost\",\n \"def calc_gradient(self, W, X, y, reg):\\n\\n N = X.shape[0]\\n grad_W = np.zeros_like(W)\\n I = np.ones((1,10))\\n score = np.dot(X, W) # (N, C)\\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\\n #print(\\\"out\\\", out)\\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\\n \\n dout = np.copy(out) # (N, C)\\n dout[np.arange(N), y] -= 1\\n grad_W = np.dot(X.T, dout) # (D, C)\\n grad_W /= N\\n #grad_W += reg * W\\n \\n return grad_W\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # You need to return the following variable correctly.\\n grad = np.zeros(theta.shape)\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the partial derivatives and set grad to the partial\\n # derivatives of the cost w.r.t. each parameter in theta.\\n\\n # =============================================================\\n return grad\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def compute_cost(features, values, theta):\\r\\n m = len(values)\\r\\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\\r\\n cost = sum_of_square_errors / (2*m)\\r\\n\\r\\n return cost\",\n \"def grad_log(self, X):\\n # \\\"\\\"\\\"\\n # Evaluate the gradients (with respect to the input) of the log density at\\n # each of the n points in X. This is the score function.\\n\\n # X: n x d numpy array.\\n XB = np.dot(X, self.B)\\n Y = 0.5*XB + self.c\\n E2y = np.exp(2*Y)\\n # n x dh\\n Phi = old_div((E2y-1.0),(E2y+1))\\n # n x dx\\n T = np.dot(Phi, 0.5*self.B.T)\\n S = self.b - X + T\\n return S\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def calc_cost(y, yhat, cost_matrix):\\n return np.mean(cost_matrix[list(y), list(yhat)])\",\n \"def approx_grad(theta, X, y):\\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def compute_logistic_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)\",\n \"def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\\n A = np.dot(self.X, self.w)\\n m = self.t.shape[0]\\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\\n return (1 / m) * np.dot(self.X.T, C)\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def _cost_function_derivative(self, y_pred, y, X, m):\\n\\n derivatives= np.zeros((X.shape[0],1))\\n for j in range(X.shape[0]):\\n auxsum = 0\\n for i in range(m):\\n auxsum+=(y_pred[0][i] -y[0][i])*X[j][i]\\n derivatives[j][0] = self.theta[j][0] - self.alpha * 1/m * auxsum\\n\\n #empty_derivatives = np.zeros((X.shape[0],1))\\n return derivatives\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\\n y_hat = softmax(scores)\\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\\n one_hot_target = np.zeros_like(y_hat)\\n one_hot_target[target] = 1\\n grad = np.outer((y_hat - one_hot_target), predicted)\\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\\n \\n '''\\n final_predicted = predicted.dot(outputVectors.T)\\n probability = softmax(final_predicted)\\n cost = -np.log(probability[target])\\n \\n one_hot_target = np.zeros_like(probability)\\n one_hot_target[target] += 1\\n dlogits = probability - one_hot_target\\n grad = np.outer(predicted, dlogits).T\\n gradPred = outputVectors.T.dot(dlogits)\\n '''\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def loss_and_grad(self, X, y):\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n grad = np.zeros_like(self.W)\\n grad_tmp = np.zeros_like(self.W)\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and the gradient. Store the gradient\\n # as the variable grad.\\n # ================================================================ #\\n \\n exp_a = np.zeros((num_classes,num_train))\\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n \\n #if i==0:\\n grada = np.zeros(X.shape[1])\\n \\n for j in range(num_classes):\\n if j != y[i]:\\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \\n else: \\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \\n\\n grad += grad_tmp\\n loss += Loss \\n \\n pass\\n\\n\\n loss /= num_train\\n grad /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def cross_entropy_cost(output_out, target_out):\\r\\n total = 0\\r\\n for target_node in range(len(target_out)): # For each target data set\\r\\n for output_node in range(len(output_out)): # For each output node\\r\\n total += target_out[target_node][output_node] - target_out[target_node][output_node] * np.log(output_out[output_node]) - \\\\\\r\\n (1 - target_out[target_node][output_node]) * np.log(1 - output_out[output_node])\\r\\n\\r\\n total = 1 / total\\r\\n return total\",\n \"def compute_cost(features, values, theta):\\n m = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2 * m)\\n\\n return cost\",\n \"def cost_(theta, X, Y):\\n if X.shape[1] + 1 != theta.size or X.shape[0] != Y.size:\\n print(\\\"Inc dim\\\")\\n return\\n c = cost_elem_(theta, X, Y)\\n s = 0\\n for i in c:\\n s = s + i\\n return(s)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8094435","0.79508626","0.7784622","0.7753385","0.77234364","0.7718602","0.76510054","0.75447094","0.74698293","0.74428225","0.7442382","0.7431407","0.742752","0.742752","0.73978907","0.7375569","0.7369099","0.7367389","0.73666364","0.73191875","0.72881675","0.7277786","0.72420293","0.7217811","0.7210301","0.7200558","0.71934974","0.7138649","0.71282405","0.7124066","0.70811814","0.7055308","0.70536155","0.701949","0.7007484","0.69945186","0.6988211","0.69683856","0.6962602","0.69602203","0.69477993","0.6947782","0.69232655","0.6922226","0.6906559","0.6881717","0.6875346","0.6870016","0.6861863","0.6858509","0.682931","0.6823772","0.681405","0.68129236","0.6810785","0.68047315","0.67983","0.67881805","0.6784253","0.6777936","0.6728751","0.67286676","0.6727264","0.6723715","0.67202306","0.6716812","0.670978","0.66998786","0.66997427","0.66985804","0.6698363","0.6697324","0.66935706","0.6693517","0.6687027","0.66799444","0.6663624","0.6660404","0.66523004","0.6634458","0.6630314","0.66269344","0.66154736","0.660729","0.659614","0.6593035","0.658633","0.6585611","0.6580791","0.6580406","0.6577078","0.65746945","0.65743417","0.6572239","0.6571058","0.65698797","0.65613794","0.65610117","0.65572107","0.6546639"],"string":"[\n \"0.8094435\",\n \"0.79508626\",\n \"0.7784622\",\n \"0.7753385\",\n \"0.77234364\",\n \"0.7718602\",\n \"0.76510054\",\n \"0.75447094\",\n \"0.74698293\",\n \"0.74428225\",\n \"0.7442382\",\n \"0.7431407\",\n \"0.742752\",\n \"0.742752\",\n \"0.73978907\",\n \"0.7375569\",\n \"0.7369099\",\n \"0.7367389\",\n \"0.73666364\",\n \"0.73191875\",\n \"0.72881675\",\n \"0.7277786\",\n \"0.72420293\",\n \"0.7217811\",\n \"0.7210301\",\n \"0.7200558\",\n \"0.71934974\",\n \"0.7138649\",\n \"0.71282405\",\n \"0.7124066\",\n \"0.70811814\",\n \"0.7055308\",\n \"0.70536155\",\n \"0.701949\",\n \"0.7007484\",\n \"0.69945186\",\n \"0.6988211\",\n \"0.69683856\",\n \"0.6962602\",\n \"0.69602203\",\n \"0.69477993\",\n \"0.6947782\",\n \"0.69232655\",\n \"0.6922226\",\n \"0.6906559\",\n \"0.6881717\",\n \"0.6875346\",\n \"0.6870016\",\n \"0.6861863\",\n \"0.6858509\",\n \"0.682931\",\n \"0.6823772\",\n \"0.681405\",\n \"0.68129236\",\n \"0.6810785\",\n \"0.68047315\",\n \"0.67983\",\n \"0.67881805\",\n \"0.6784253\",\n \"0.6777936\",\n \"0.6728751\",\n \"0.67286676\",\n \"0.6727264\",\n \"0.6723715\",\n \"0.67202306\",\n \"0.6716812\",\n \"0.670978\",\n \"0.66998786\",\n \"0.66997427\",\n \"0.66985804\",\n \"0.6698363\",\n \"0.6697324\",\n \"0.66935706\",\n \"0.6693517\",\n \"0.6687027\",\n \"0.66799444\",\n \"0.6663624\",\n \"0.6660404\",\n \"0.66523004\",\n \"0.6634458\",\n \"0.6630314\",\n \"0.66269344\",\n \"0.66154736\",\n \"0.660729\",\n \"0.659614\",\n \"0.6593035\",\n \"0.658633\",\n \"0.6585611\",\n \"0.6580791\",\n \"0.6580406\",\n \"0.6577078\",\n \"0.65746945\",\n \"0.65743417\",\n \"0.6572239\",\n \"0.6571058\",\n \"0.65698797\",\n \"0.65613794\",\n \"0.65610117\",\n \"0.65572107\",\n \"0.6546639\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74783975"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":78495,"cells":{"query":{"kind":"string","value":"Convert a number to unicode, with appropriate substitutions."},"document":{"kind":"string","value":"def unicode_number(x):\n\n output = u\"%g\" % x\n\n if output[0] == u\"-\":\n output = u\"\\u2012\" + output[1:]\n\n index = output.find(u\"e\")\n if index != -1:\n uniout = unicode(output[:index]) + u\"\\u00d710\"\n saw_nonzero = False\n for n in output[index+1:]:\n if n == u\"+\": pass # uniout += u\"\\u207a\"\n elif n == u\"-\": uniout += u\"\\u207b\"\n elif n == u\"0\":\n if saw_nonzero: uniout += u\"\\u2070\"\n elif n == u\"1\":\n saw_nonzero = True\n uniout += u\"\\u00b9\"\n elif n == u\"2\":\n saw_nonzero = True\n uniout += u\"\\u00b2\"\n elif n == u\"3\":\n saw_nonzero = True\n uniout += u\"\\u00b3\"\n elif u\"4\" <= n <= u\"9\":\n saw_nonzero = True\n if saw_nonzero: uniout += eval(\"u\\\"\\\\u%x\\\"\" % (0x2070 + ord(n) - ord(u\"0\")))\n else: uniout += n\n\n if uniout[:2] == u\"1\\u00d7\": uniout = uniout[2:]\n return uniout\n\n return output"},"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 to_u(val, encoding='utf-8'):\r\n if isinstance(val, text_type):\r\n return val\r\n elif isinstance(val, numeric_types):\r\n return text_type(val)\r\n\r\n return val.decode(encoding)","def translate_number(number):\n return NUMBER_TRANSLATOR[number]","def _to_cn(number):\n\n chinese_numeral_dict = {\n '0': '零',\n '1': '一',\n '2': '二',\n '3': '三',\n '4': '四',\n '5': '五',\n '6': '六',\n '7': '七',\n '8': '八',\n '9': '九'\n }\n chinese_unit_map = [('', '十', '百', '千'),\n ('万', '十万', '百万', '千万'),\n ('亿', '十亿', '百亿', '千亿'),\n ('兆', '十兆', '百兆', '千兆'),\n ('吉', '十吉', '百吉', '千吉')]\n chinese_unit_sep = ['万', '亿', '兆', '吉']\n\n reversed_n_string = reversed(str(number))\n\n result_lst = []\n unit = 0\n\n for integer in reversed_n_string:\n if integer is not '0':\n result_lst.append(chinese_unit_map[unit // 4][unit % 4])\n result_lst.append(chinese_numeral_dict[integer])\n unit += 1\n else:\n if result_lst and result_lst[-1] != '零':\n result_lst.append('零')\n unit += 1\n\n result_lst.reverse()\n\n # clean convert result, make it more natural\n if result_lst[-1] is '零':\n result_lst.pop()\n\n result_lst = list(''.join(result_lst))\n\n for unit_sep in chinese_unit_sep:\n flag = result_lst.count(unit_sep)\n while flag > 1:\n result_lst.pop(result_lst.index(unit_sep))\n flag -= 1\n\n '''\n length = len(str(number))\n if 4 < length <= 8:\n flag = result_lst.count('万')\n while flag > 1:\n result_lst.pop(result_lst.index('万'))\n flag -= 1\n elif 8 < length <= 12:\n flag = result_lst.count('亿')\n while flag > 1:\n result_lst.pop(result_lst.index('亿'))\n flag -= 1\n elif 12 < length <= 16:\n flag = result_lst.count('兆')\n while flag > 1:\n result_lst.pop(result_lst.index('兆'))\n flag -= 1\n elif 16 < length <= 20:\n flag = result_lst.count('吉')\n while flag > 1:\n result_lst.pop(result_lst.index('吉'))\n flag -= 1\n '''\n\n return ''.join(result_lst)","def intRender(self, number):\n\n data = unicode(number)\n bites = list()\n\n while data:\n bites.append(data[-3:])\n data = data[:-3]\n\n return \" \".join(reversed(bites))","def convert(num):\r\n if len(str(num))==1:\r\n return \"000%i\"%num\r\n elif len(str(num)) == 2:\r\n return \"00%i\"%num\r\n elif len(str(num)) == 3:\r\n return \"0%i\"%num\r\n elif len(str(num)) == 4:\r\n return \"%i\"%num","def transforme(n):\n if n<10 :\n return '0'+str(n)\n else :\n return str(n)","def unicode_char(n):\n try:\n return unichr(n)\n except ValueError:\n # Generate bytes object packed as int.\n bytes_object = struct.pack('i', n)\n # Return decoded w/ utf-32 codec.\n return bytes_object.decode('utf-32')","def spell_number(num):\n tens, units = num / 10, num % 10\n tens_str = NUMBERS_10[tens]\n units_str = NUMBERS_1[units]\n if tens == 1:\n return NUMBERS_TEEN[units]\n elif tens:\n if units:\n return \"{t} {u}\".format(t=tens_str, u=units_str)\n return \"{t}\".format(t=tens_str)\n else:\n return units_str","def to_unicode(value):\r\n if isinstance(value, _TO_UNICODE_TYPES):\r\n return value\r\n if not isinstance(value, bytes_type):\r\n raise TypeError(\r\n \"Expected bytes, unicode, or None; got %r\" % type(value)\r\n )\r\n return value.decode(\"utf-8\")","def convert_number(number):\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '","def convert(number):\n out = \"\"\n if number % 3 == 0:\n out = \"Pling\"\n if number % 5 == 0:\n out = out + \"Plang\"\n if number % 7 == 0:\n out = out + \"Plong\"\n if out == \"\":\n out = str(number)\n return out","def translateNumber(n):\r\n if type(n) != str:\r\n return None\r\n else:\r\n translation = \"\"\r\n word = \"\"\r\n for c in n:\r\n if c != ' ':\r\n word += c\r\n elif word in Numbers:\r\n translation += Numbers[word] + \" \"\r\n else:\r\n translation += word + \" \"\r\n return translation","def zh_num2digit(string):\n for match in zh_nums_iter(string):\n num_str = match.group(0)\n digit_num = parse_zh_num(num_str)\n if digit_num is None:\n continue\n string = string.replace(num_str, str(digit_num), 1)\n return string","def to_us_number(number):\n number = number.replace('.', '')\n number = number.replace(',', '.')\n\n return float(number)","def cvt_to_readable(num):\n\n # Find the degree of the number like if it is in thousands or millions, etc.\n index = int(math.log(num) / math.log(1000))\n\n # Converts the number to the human readable format and returns it.\n newNum = round(num / (1000 ** index), 3)\n degree = UNITS[index]\n\n return (newNum, degree)","def format_number(number):\n return f'{number:8,}'","def decode(self, number: int) -> typing.Union[int, str]:\n return number","def utf8(num):\n # code de la prof louche\n if num < 8:\n return 1\n else:\n return num//6+1\n\n return binary","def to_number(self, to_number):\n self._to_number = to_number","def convert_base(num, to_base):\n\n\tdigits = '0123456789ABCDEF'\n\tresult = ''\n\n\tif num < to_base:\n\t\treturn digits[num]\n\telse:\n\t\tresult += convert_base(num/to_base, to_base) + str(digits[num % to_base])\n\n\treturn result","def int_to_unichr(codepoint):\n if PY2:\n return unichr(codepoint)\n return chr(codepoint)","def number_conversion(number):\n units = ['', 'K', 'M', 'G', 'T', 'P']\n k = 1000.0\n magnitude = int(floor(log(number, k)))\n return '%.2f%s' % (number / k**magnitude, units[magnitude])","def format_int(self, data):\n return u'%d' % data","def to_unicode(x):\n try: # This may never fail, but let's be safe\n encoding = locale.getpreferredencoding()\n except:\n encoding = 'utf-8'\n ret = x.decode(encoding, 'replace').encode('utf-8')\n return ret","def touni(x, enc='utf8', err='strict'):\r\n return x if isinstance(x, unicode) else unicode(str(x), enc, err)","def to_unicode(data):\n return to_string(data)","def _num2str(self, num):\n q, mod = divmod(num, 10)\n suffix = \"th\" if q == 1 else self.SUFFIX_DICT[mod]\n return f\"{num}{suffix}\"","def safe_unichr(intval):\n try:\n return unichr(intval)\n except ValueError:\n # ValueError: unichr() arg not in range(0x10000) (narrow Python build)\n s = \"\\\\U%08x\" % intval\n # return UTF16 surrogate pair\n return s.decode('unicode-escape')","def ToUnicode(val):\n if sys.version_info[0] >= 3:\n return val\n return val if isinstance(val, unicode) else val.decode('utf-8')","def format_number(n):\n # locale.setlocale(locale.LC_ALL, 'en_US') # commented by me\n # return locale.format('%d', n, grouping=True)\n return n","def get_number_in_portuguese(self, number, result=\"\"):\n number_as_str = str(number)\n\n # Check if the first char is a \"-\" sign\n first_position = number_as_str[0]\n if \"-\" == first_position:\n result = \"menos\"\n # Removes the negative sign from number\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\n\n number_len = len(number_as_str)\n\n if number_len > 1 and self._is_zero_sequence(number_as_str):\n # the rest of the number ends in a zero sequence\n return result.strip()\n\n if first_position == '0':\n if number_len > 1:\n # Cut off the leading zero\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\n if not result or result == '-':\n # The number is zero\n return self.ZERO\n\n if number_len > 5:\n # Out of range\n raise NotAcceptable(detail=self.MAX_LIMIT_ERROR)\n\n if number_len == 5:\n # Extract the dozen-thounsands\n first_two_positions = number_as_str[0] + number_as_str[1]\n result = ' '.join([result, self._get_two_digits_number_in_extension(first_two_positions), 'mil'])\n\n if self._is_zero_sequence(number_as_str[2::]):\n # Number ends in a zero sequence\n return result.strip()\n result = ' '.join([result, 'e'])\n\n return self.get_number_in_portuguese(number=number_as_str[2::], result=result)\n\n if number_len == 4:\n result = ' '.join([result, self.THOUSANDS[first_position]])\n\n if self._is_zero_sequence(number_as_str[1::]):\n # Number ends in a zero sequence\n return result.strip()\n result = ' '.join([result, 'e'])\n\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\n\n if number_len == 3:\n is_following_zeros = self._is_zero_sequence(number_as_str[1::])\n\n if first_position == '1':\n # Number ends in 1xx\n if is_following_zeros:\n # Number is 100\n result = ' '.join([result, self.CEM])\n return result.strip()\n result = ' '.join([result, 'cento e'])\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\n result = ' '.join([result, self.HUNDREDS[first_position]])\n if is_following_zeros:\n # Number ends in a zero sequence\n return result.strip()\n result = ' '.join([result, 'e'])\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\n\n if number_len == 2:\n result = ' '.join([result, self._get_two_digits_number_in_extension(number_as_str)])\n return result.strip()\n\n if number_len == 1:\n result = ' '.join([result, self.UNITS[number_as_str]])\n\n return result.strip()","def _num_to_pword(num):\n pword = ''\n for char in num:\n pword += chr(char)\n return pword","def _index_to_unicode(cls, index: int) -> str:\n return \"\".join(cls._unicode_subscripts[int(_)] for _ in str(index))","def convert_to_numerals(number):\n assert number < 4000\n expression = factorize(int(number), ROMAN_NUMERALS)\n result = list(numeral(f) * c for c, f in normalize(expression))\n return \"\".join(result)","def make_unicode():\r\n for num in range(300, 320):\r\n yield unichr(num)","def to_unicode(text, encoding='utf8', errors='strict'):\r\n if isinstance(text, unicode):\r\n return text\r\n return unicode(text, encoding, errors=errors)","def _convertUnicodeForCPS(self, value):\n try:\n value = str(value)\n except UnicodeEncodeError:\n try:\n value = str(value.encode('ISO-8859-15'))\n except UnicodeEncodeError:\n value = repr(value)\n return value","def Hex(num):\n return hex(CInt(num))[2:].upper()","def parse(cls, value: Union[str, int]) -> 'Unicode':\n return cls(value)","def compact(number):\n number = clean(number, ' ').upper().strip()\n for prefix in ('УНП', u'УНП', 'UNP', u'UNP'):\n if type(number) == type(prefix) and number.startswith(prefix):\n number = number[len(prefix):]\n # Replace Cyrillic letters with Latin letters\n cleaned = ''.join(_cyrillic_to_latin.get(x, x) for x in to_unicode(number))\n if type(cleaned) != type(number): # pragma: no cover (Python2 only)\n cleaned = cleaned.encode('utf-8')\n return cleaned","def _process_value(self, value):\n if isinstance(value, str):\n try:\n value.decode('ascii')\n except UnicodeDecodeError:\n return unicode(''.join([unichr(ord(c)) for c in value]))\n return value","def serialize_number(n):\n return str(n)","def setUnicodeValue(glyph, glyphList):\n\n if glyph.name in glyphList:\n glyph.unicode = int(glyphList[glyph.name], 16)\n else:\n uvNameMatch = re.match(\"uni([\\dA-F]{4})$\", glyph.name)\n if uvNameMatch:\n glyph.unicode = int(uvNameMatch.group(1), 16)","def FromUnicode(val):\n if sys.version_info[0] >= 3:\n return val\n return val if isinstance(val, str) else val.encode('utf-8')","def to_unicode(text, encoding='utf8', errors='strict'):\n if isinstance(text, unicode):\n return text\n return unicode(text, encoding, errors=errors)","def num2str(num):\n require_type(is_number(num), 'parameter of number->string must be a number')\n return tostr(num)","def _unicodeify(self, value, encoding=\"utf8\"):\n if isinstance(value, str):\n return value\n return str(value, encoding)","def to_unicode(text, encoding='utf8', errors='strict'):\n if isinstance(text, unicode):\n return text\n else:\n return unicode(text, encoding=encoding, errors=errors)","def to_unicode(value, default=u''):\n try:\n if isinstance(value, unicode):\n return value\n return codecs.decode(value or default)\n except Exception:\n return codecs.decode(value or default, 'latin1')","def translate_num(number, lower_bound, upper_bound):\n try:\n value = int(number, 0)\n if value < lower_bound or value > upper_bound:\n raise translate_num_out_of_range(value, lower_bound, upper_bound)\n else:\n return value\n except:\n raise translate_num_error(number)","def apnumber(value):\r\n try:\r\n value = int(value)\r\n except (TypeError, ValueError):\r\n return value\r\n if not 0 < value < 10:\r\n return str(value)\r\n return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'),\r\n _('seven'), _('eight'), _('nine'))[value - 1]","def convertbase(number, base=10):\n\n integer = number\n if not integer:\n return '0'\n sign = 1 if integer > 0 else -1\n alphanum = string.digits + string.ascii_lowercase\n nums = alphanum[:base]\n res = ''\n integer *= sign\n while integer:\n integer, mod = divmod(integer, base)\n res += nums[mod]\n return ('' if sign == 1 else '-') + res[::-1]","def base2str(self, int_number):\r\n return self.format_base % (float(int_number) / self.mult_base)","def transform(s):\r\n return 'digit ' + str(s)","def to_unicode(data):\n if isinstance(data, bytes):\n return data.decode('utf-8')\n else:\n return data","def type_number(number: float):\n # TODO: Allow leading zeros\n for char in str(number):\n actions.key(char)","def _get_unicode_value(value: Union[Text, bytes]) -> Text:\n decoded_value = stats_util.maybe_get_utf8(value)\n # Check if we have a valid utf-8 string. If not, assign a placeholder.\n if decoded_value is None:\n _NON_UTF8_VALUES_COUNTER.inc()\n decoded_value = constants.NON_UTF8_PLACEHOLDER\n return decoded_value","def conv_hex(num):\n\n if num < 10:\n return str(num)\n if num == 10:\n return 'A'\n if num == 11:\n return 'B'\n if num == 12:\n return 'C'\n if num == 13:\n return 'D'\n if num == 14:\n return 'E'\n if num == 15:\n return 'F'","def base10toN(num, base):\n\n converted_string, modstring = \"\", \"\"\n currentnum = num\n if not 1 < base < 37:\n raise ValueError(\"base must be between 2 and 36\")\n if not num:\n return '0'\n while currentnum:\n mod = currentnum % base\n currentnum = currentnum // base\n converted_string = chr(48 + mod + 7*(mod > 10)) + converted_string\n return converted_string","def to_units(number):\n unit = 0\n while number >= 1024.:\n unit += 1\n number = number / 1024.\n if unit == len(UNITS) - 1:\n break\n if unit:\n return '%.2f%s' % (number, UNITS[unit])\n return '%d' % number","def format_number(number):\r\n if number >= 1000 and number % 1000 == 0:\r\n return \"%dk\" % (number/1000)\r\n else:\r\n return str(number)","def base10toN(num, base):\n\n converted_string, modstring = \"\", \"\"\n\n currentnum = num\n\n if not 1 < base < 37:\n raise ValueError(\"base must be between 2 and 36\")\n\n if not num:\n return '0'\n\n while currentnum:\n mod = currentnum % base\n currentnum = currentnum // base\n converted_string = chr(48 + mod + 7*(mod > 10)) + converted_string\n\n return converted_string","def _int2str(num):\n if num<10:\n return '00%s'%str(num)\n elif 10<=num<100:\n return '0%s'%str(num)\n else:\n return '%s'%str(num)","def text_transform(val):\n if CURRENCY == \"USD\":\n return \"$%d\" % val\n if CURRENCY == \"EUR\":\n return \"€%d\" % val\n if CURRENCY == \"GBP\":\n return \"£%d\" % val\n return \"%d\" % val","def transform(s):\n return 'digit ' + str(s)","def integer_to_english_numeral(n, activate_tts=False):\n if activate_tts is None:\n activate_tts = False\n elif not isinstance(activate_tts, bool):\n raise TypeError('Argument \"activate_tts\" is not a boolean')\n if not isinstance(n, int):\n raise TypeError('Not an integer')\n if n < 0:\n raise ValueError('Not a positive integer')\n if n > 999999999999:\n raise OverflowError('Integer greater than 999,999,999,999')\n return cardinal_numerals_eng.integer_to_english(n, activate_tts)","def _format_num(self, value) -> typing.Any:\n return self.num_type(value)","def convert_bytes(num):\n for x in ['_B', 'KB', 'MB', 'GB', 'TB']:\n if num < 1000.0:\n return \"%3.1f%s\" % (num, x)\n num /= 1000.0","def convert_label_num2string(number, num_types):\n dictionary = empty_label_dictionary(num_types)\n all_labels = list(dictionary.keys())\n return all_labels[number]","def _numToOneByteString(inputvalue):\n _checkInt(inputvalue, minvalue=0, maxvalue=0xFF)\n\n return chr(inputvalue)","def u(obj):\n return obj if isinstance(obj, unicode) else unicode(obj) # noqa: F821 pylint: disable=undefined-variable","def int2dec(n: int) -> str:","def english(number):\r\n if number == 0:\r\n return 'zero'\r\n word = ''\r\n for step in itertools.count():\r\n number, rest = divmod(number, 1000)\r\n word = format_num(en3(rest), step) + word\r\n if number == 0:\r\n return word.strip()","def format_num(num):\n if num is None:\n return num\n if (num < 10):\n return '0' + str(num)\n return str(num)","def ltibetanToUnicode(*args):\n import string\n\n # The context variable is of type XScriptContext and is available to\n # all BeanShell scripts executed by the Script Framework\n xModel = XSCRIPTCONTEXT.getDocument()\n\n #the writer controller impl supports the css.view.XSelectionSupplier interface\n xSelectionSupplier = xModel.getCurrentController()\n\n #see section 7.5.1 of developers' guide\n xIndexAccess = xSelectionSupplier.getSelection()\n count = xIndexAccess.getCount();\n if(count>=1): #ie we have a selection\n i=0\n\twhile i < count :\n xTextRange = xIndexAccess.getByIndex(i);\n theString = xTextRange.getString();\n if len(theString)!=0 :\n newString = getNewString( theString );\n if newString:\n xTextRange.setString(newString);\n xSelectionSupplier.select(xTextRange);\n\t i+= 1","def bh2u(x: bytes) -> str:\n return hfu(x).decode('ascii')","def int2text(integer):\n # Numbers 1-99 are handled by simply looking up words in the special_case\n # dictionary.\n if integer < 100:\n return digit2text(integer)\n\n elif integer < 1000:\n # If exactly some hundred, then just return the word for the hundred's\n # place and the word 'hundred'\n if integer%100 == 0:\n return digit2text(integer/100)+'hundred'\n # Otherwise return the word for the hundred's place, the word\n # 'hundredand' and do some composition to make the rest of the words.\n else:\n return digit2text(integer/100)+'hundredand'+\\\n digit2text(integer%100)\n # Special case for 1000.\n elif integer == 1000:\n return \"onethousand\"","def _u2i(number):\n mask = (2 ** 32) - 1\n if number & (1 << 31):\n v = number | ~mask\n else:\n v = number & mask\n if v >= 0:\n return v;\n else:\n if exceptions:\n raise _pigpioError(error(v))\n else:\n return v","def TO_UNICODE(string):\n try:\n # wroks if string is unicode already\n return unicode(string, \"utf-8\")\n except:\n pass\n try:\n # works if string is iso8859-1\n return unicode(string, \"iso-8859-1\")\n except:\n pass\n # try simple coding\n return unicode(string)","def convert_base(num, n):\r\n new_num_string = ''\r\n current = num\r\n while current != 0:\r\n remainder = current % n\r\n if remainder > 9:\r\n remainder_string = HEX_CHARS[remainder]\r\n elif remainder >= 36:\r\n remainder_string = '('+str(remainder)+')'\r\n else:\r\n remainder_string = str(remainder)\r\n new_num_string = remainder_string+new_num_string\r\n current = current//n\r\n return new_num_string","def handle_charref(self, number):\n codepoint = int(number[1:], 16) if number[0] in ('x', 'X') else int(number)\n text = six.unichr(codepoint)\n self.result.append(text)\n return text","def su(value):\n return safe_unicode(value, encoding=get_charset())","def encode_num(num):\n\tsnuml = list(str(num))\n\tif len(snuml)%2 == 1:\n\t\tsnuml += 'f'\n\tfor i in range(len(snuml)):\n\t\tif i % 2 == 0:\n\t\t\tsnuml[i], snuml[i+1] = snuml[i+1], snuml[i]\n\t# Below, ext=1 for some reason; use unknown numbering type, unknown\n\t# numbering plan.\n\tenc_num = (\n\t\tto_hex2(len(snuml)/2 + 1) + \"81\" + ''.join(snuml)\n\t)\n\treturn(enc_num)","def convert_list_to_unicode_str(data):\n string = ''\n for i, val in enumerate(data):\n # string = string + unicode(unichr(int(val)))\n string = string + str(int(val))\n return string","def strftime_to_unicode(self, fmt):\r\n return re.sub(\r\n r'(%[a-zA-Z])',\r\n lambda m: self.STRFTIME_TO_UNICODE.get(m.group(1), m.group(1)),\r\n fmt\r\n )","def number(size, n):\n\n\t# Little endian writing\n\n\ts = \"\"\n\n\twhile size > 0:\n\t\ti = n % 256\n\t\ts = s + chr(i)\n#\t\tn = n / 256\n\t\tn = n >> 8\n\t\tsize = size - 1\n\n\treturn s","def _to_unicode(text):\n # both str and unicode inherit from basestring\n if not isinstance(text, basestring):\n tmpl = 'expected UTF-8 encoded string or unicode, got %s value %s'\n raise TypeError(tmpl % (type(text), text))\n # return unicode strings unchanged\n if isinstance(text, unicode):\n return text\n # otherwise assume UTF-8 encoding, which also works for ASCII\n return unicode(text, 'utf-8')","def number2tikx(num, tik='-'):\n return ''.join([\"{:1x}\".format(num) if x=='0' else tik for x in list(\"{:08b}\".format(num)) ])","def _to_unicode(obj, encoding=\"UTF-8\"):\n if isinstance(obj, basestring):\n if not isinstance(obj, unicode):\n obj = unicode(obj, encoding)\n return obj","def get_num_with_ordinal(num):\n num_with_ordinal = str(num) + ordinal(num)\n return num_with_ordinal","def numbersToLetters(number):\n arr = [number[i:i+2] for i in range(0, len(number), 2)]\n result = ''\n for i in arr:\n i = int(i)\n if(i<=48):\n i = i + 48\n result += chr(i)\n return result","def shorten_number(self, number):\n if number < 1000:\n return number\n elif number >= 1000 and number < 1000000:\n num = self.rounded_number(number, 1000)\n val = \"1M\" if num == \"1000\" else num + \"K\"\n return val\n elif number >= 1000000 and number < 1000000000:\n num = self.rounded_number(number, 1000000)\n val = \"1B\" if num==\"1000\" else num + \"M\"\n return val\n elif number >= 1000000000 and number < 1000000000000:\n num = self.rounded_number(number, 1000000000)\n val = \"1T\" if num==\"1000\" else num + \"B\"\n return val\n else:\n num = self.rounded_number(number, 1000000000000)\n return num + \"T\"","def base_10_to_alphabet(number):\r\n return ''.join(\r\n chr(A_UPPERCASE + part)\r\n for part in _decompose(number)\r\n )","def toChar(integer):\n\tif integer >= 0x80:\n\t\treturn eval(u\"'\\\\x%02X'\"%integer)\n\telse:\n\t\treturn chr(integer)","def utf8tounicode(arg):\n\n try:\n if isinstance(arg, unicode):\n return arg.decode('utf-8')\n except NameError:\n pass # Python 3\n return arg","def force_unicode(value):\n if IS_PY3:\n # Python 3.X\n if isinstance(value, bytes):\n value = value.decode(\"utf-8\", errors=\"replace\")\n elif not isinstance(value, str):\n value = str(value)\n else:\n # Python 2.X\n if isinstance(value, str):\n value = value.decode(\"utf-8\", \"replace\")\n elif not isinstance(value, basestring): # NOQA: F821\n value = unicode(value) # NOQA: F821\n\n return value","def numToStrLabel(self, value):\n zero_count = 3 - len(str(value))\n return zero_count * \"0\" + str(value)","def _format_num(self, value):\n if value is None or value == \"\":\n return None\n return self.num_type(value)","def baseconvert(num, base):\n\n digits = \"0123456789abcdefghijklmnopqrstuvwxyz\"\n\n try:\n num = int(num)\n base = int(base)\n except ValueError:\n return \"\"\n\n if num < 0 or base < 2 or base > 36:\n return \"\"\n\n num_string = \"\"\n while 1:\n remainder = num % base\n num_string = digits[remainder] + num_string\n num = num / base\n if num == 0:\n break\n\n return num_string","def WWRomanNumber(number):\r\n\t\r\n\tif number>4999 or number<1:\r\n\t\traise OverflowError(\"The should be between 1 and 4999, here it is \"+str(number))\r\n\tnumerals = { 1 : \"I\", 4 : \"IV\", 5 : \"V\", 9 : \"IX\", 10 : \"X\", 40 : \"XL\",\r\n\t\t\t\t50 : \"L\", 90 : \"XC\", 100 : \"C\", 400 : \"CD\", 500 : \"D\", 900 : \"CM\", 1000 : \"M\" }\r\n\tresult = \"\"\r\n\tfor value, numeral in sorted(numerals.items(), reverse=True):\r\n\t\twhile number >= value:\r\n\t\t\tresult += numeral\r\n\t\t\tnumber -= value\r\n\treturn result"],"string":"[\n \"def to_u(val, encoding='utf-8'):\\r\\n if isinstance(val, text_type):\\r\\n return val\\r\\n elif isinstance(val, numeric_types):\\r\\n return text_type(val)\\r\\n\\r\\n return val.decode(encoding)\",\n \"def translate_number(number):\\n return NUMBER_TRANSLATOR[number]\",\n \"def _to_cn(number):\\n\\n chinese_numeral_dict = {\\n '0': '零',\\n '1': '一',\\n '2': '二',\\n '3': '三',\\n '4': '四',\\n '5': '五',\\n '6': '六',\\n '7': '七',\\n '8': '八',\\n '9': '九'\\n }\\n chinese_unit_map = [('', '十', '百', '千'),\\n ('万', '十万', '百万', '千万'),\\n ('亿', '十亿', '百亿', '千亿'),\\n ('兆', '十兆', '百兆', '千兆'),\\n ('吉', '十吉', '百吉', '千吉')]\\n chinese_unit_sep = ['万', '亿', '兆', '吉']\\n\\n reversed_n_string = reversed(str(number))\\n\\n result_lst = []\\n unit = 0\\n\\n for integer in reversed_n_string:\\n if integer is not '0':\\n result_lst.append(chinese_unit_map[unit // 4][unit % 4])\\n result_lst.append(chinese_numeral_dict[integer])\\n unit += 1\\n else:\\n if result_lst and result_lst[-1] != '零':\\n result_lst.append('零')\\n unit += 1\\n\\n result_lst.reverse()\\n\\n # clean convert result, make it more natural\\n if result_lst[-1] is '零':\\n result_lst.pop()\\n\\n result_lst = list(''.join(result_lst))\\n\\n for unit_sep in chinese_unit_sep:\\n flag = result_lst.count(unit_sep)\\n while flag > 1:\\n result_lst.pop(result_lst.index(unit_sep))\\n flag -= 1\\n\\n '''\\n length = len(str(number))\\n if 4 < length <= 8:\\n flag = result_lst.count('万')\\n while flag > 1:\\n result_lst.pop(result_lst.index('万'))\\n flag -= 1\\n elif 8 < length <= 12:\\n flag = result_lst.count('亿')\\n while flag > 1:\\n result_lst.pop(result_lst.index('亿'))\\n flag -= 1\\n elif 12 < length <= 16:\\n flag = result_lst.count('兆')\\n while flag > 1:\\n result_lst.pop(result_lst.index('兆'))\\n flag -= 1\\n elif 16 < length <= 20:\\n flag = result_lst.count('吉')\\n while flag > 1:\\n result_lst.pop(result_lst.index('吉'))\\n flag -= 1\\n '''\\n\\n return ''.join(result_lst)\",\n \"def intRender(self, number):\\n\\n data = unicode(number)\\n bites = list()\\n\\n while data:\\n bites.append(data[-3:])\\n data = data[:-3]\\n\\n return \\\" \\\".join(reversed(bites))\",\n \"def convert(num):\\r\\n if len(str(num))==1:\\r\\n return \\\"000%i\\\"%num\\r\\n elif len(str(num)) == 2:\\r\\n return \\\"00%i\\\"%num\\r\\n elif len(str(num)) == 3:\\r\\n return \\\"0%i\\\"%num\\r\\n elif len(str(num)) == 4:\\r\\n return \\\"%i\\\"%num\",\n \"def transforme(n):\\n if n<10 :\\n return '0'+str(n)\\n else :\\n return str(n)\",\n \"def unicode_char(n):\\n try:\\n return unichr(n)\\n except ValueError:\\n # Generate bytes object packed as int.\\n bytes_object = struct.pack('i', n)\\n # Return decoded w/ utf-32 codec.\\n return bytes_object.decode('utf-32')\",\n \"def spell_number(num):\\n tens, units = num / 10, num % 10\\n tens_str = NUMBERS_10[tens]\\n units_str = NUMBERS_1[units]\\n if tens == 1:\\n return NUMBERS_TEEN[units]\\n elif tens:\\n if units:\\n return \\\"{t} {u}\\\".format(t=tens_str, u=units_str)\\n return \\\"{t}\\\".format(t=tens_str)\\n else:\\n return units_str\",\n \"def to_unicode(value):\\r\\n if isinstance(value, _TO_UNICODE_TYPES):\\r\\n return value\\r\\n if not isinstance(value, bytes_type):\\r\\n raise TypeError(\\r\\n \\\"Expected bytes, unicode, or None; got %r\\\" % type(value)\\r\\n )\\r\\n return value.decode(\\\"utf-8\\\")\",\n \"def convert_number(number):\\n return ' ' + ' '.join(list(int_to_roman(number))) + ' '\",\n \"def convert(number):\\n out = \\\"\\\"\\n if number % 3 == 0:\\n out = \\\"Pling\\\"\\n if number % 5 == 0:\\n out = out + \\\"Plang\\\"\\n if number % 7 == 0:\\n out = out + \\\"Plong\\\"\\n if out == \\\"\\\":\\n out = str(number)\\n return out\",\n \"def translateNumber(n):\\r\\n if type(n) != str:\\r\\n return None\\r\\n else:\\r\\n translation = \\\"\\\"\\r\\n word = \\\"\\\"\\r\\n for c in n:\\r\\n if c != ' ':\\r\\n word += c\\r\\n elif word in Numbers:\\r\\n translation += Numbers[word] + \\\" \\\"\\r\\n else:\\r\\n translation += word + \\\" \\\"\\r\\n return translation\",\n \"def zh_num2digit(string):\\n for match in zh_nums_iter(string):\\n num_str = match.group(0)\\n digit_num = parse_zh_num(num_str)\\n if digit_num is None:\\n continue\\n string = string.replace(num_str, str(digit_num), 1)\\n return string\",\n \"def to_us_number(number):\\n number = number.replace('.', '')\\n number = number.replace(',', '.')\\n\\n return float(number)\",\n \"def cvt_to_readable(num):\\n\\n # Find the degree of the number like if it is in thousands or millions, etc.\\n index = int(math.log(num) / math.log(1000))\\n\\n # Converts the number to the human readable format and returns it.\\n newNum = round(num / (1000 ** index), 3)\\n degree = UNITS[index]\\n\\n return (newNum, degree)\",\n \"def format_number(number):\\n return f'{number:8,}'\",\n \"def decode(self, number: int) -> typing.Union[int, str]:\\n return number\",\n \"def utf8(num):\\n # code de la prof louche\\n if num < 8:\\n return 1\\n else:\\n return num//6+1\\n\\n return binary\",\n \"def to_number(self, to_number):\\n self._to_number = to_number\",\n \"def convert_base(num, to_base):\\n\\n\\tdigits = '0123456789ABCDEF'\\n\\tresult = ''\\n\\n\\tif num < to_base:\\n\\t\\treturn digits[num]\\n\\telse:\\n\\t\\tresult += convert_base(num/to_base, to_base) + str(digits[num % to_base])\\n\\n\\treturn result\",\n \"def int_to_unichr(codepoint):\\n if PY2:\\n return unichr(codepoint)\\n return chr(codepoint)\",\n \"def number_conversion(number):\\n units = ['', 'K', 'M', 'G', 'T', 'P']\\n k = 1000.0\\n magnitude = int(floor(log(number, k)))\\n return '%.2f%s' % (number / k**magnitude, units[magnitude])\",\n \"def format_int(self, data):\\n return u'%d' % data\",\n \"def to_unicode(x):\\n try: # This may never fail, but let's be safe\\n encoding = locale.getpreferredencoding()\\n except:\\n encoding = 'utf-8'\\n ret = x.decode(encoding, 'replace').encode('utf-8')\\n return ret\",\n \"def touni(x, enc='utf8', err='strict'):\\r\\n return x if isinstance(x, unicode) else unicode(str(x), enc, err)\",\n \"def to_unicode(data):\\n return to_string(data)\",\n \"def _num2str(self, num):\\n q, mod = divmod(num, 10)\\n suffix = \\\"th\\\" if q == 1 else self.SUFFIX_DICT[mod]\\n return f\\\"{num}{suffix}\\\"\",\n \"def safe_unichr(intval):\\n try:\\n return unichr(intval)\\n except ValueError:\\n # ValueError: unichr() arg not in range(0x10000) (narrow Python build)\\n s = \\\"\\\\\\\\U%08x\\\" % intval\\n # return UTF16 surrogate pair\\n return s.decode('unicode-escape')\",\n \"def ToUnicode(val):\\n if sys.version_info[0] >= 3:\\n return val\\n return val if isinstance(val, unicode) else val.decode('utf-8')\",\n \"def format_number(n):\\n # locale.setlocale(locale.LC_ALL, 'en_US') # commented by me\\n # return locale.format('%d', n, grouping=True)\\n return n\",\n \"def get_number_in_portuguese(self, number, result=\\\"\\\"):\\n number_as_str = str(number)\\n\\n # Check if the first char is a \\\"-\\\" sign\\n first_position = number_as_str[0]\\n if \\\"-\\\" == first_position:\\n result = \\\"menos\\\"\\n # Removes the negative sign from number\\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\\n\\n number_len = len(number_as_str)\\n\\n if number_len > 1 and self._is_zero_sequence(number_as_str):\\n # the rest of the number ends in a zero sequence\\n return result.strip()\\n\\n if first_position == '0':\\n if number_len > 1:\\n # Cut off the leading zero\\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\\n if not result or result == '-':\\n # The number is zero\\n return self.ZERO\\n\\n if number_len > 5:\\n # Out of range\\n raise NotAcceptable(detail=self.MAX_LIMIT_ERROR)\\n\\n if number_len == 5:\\n # Extract the dozen-thounsands\\n first_two_positions = number_as_str[0] + number_as_str[1]\\n result = ' '.join([result, self._get_two_digits_number_in_extension(first_two_positions), 'mil'])\\n\\n if self._is_zero_sequence(number_as_str[2::]):\\n # Number ends in a zero sequence\\n return result.strip()\\n result = ' '.join([result, 'e'])\\n\\n return self.get_number_in_portuguese(number=number_as_str[2::], result=result)\\n\\n if number_len == 4:\\n result = ' '.join([result, self.THOUSANDS[first_position]])\\n\\n if self._is_zero_sequence(number_as_str[1::]):\\n # Number ends in a zero sequence\\n return result.strip()\\n result = ' '.join([result, 'e'])\\n\\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\\n\\n if number_len == 3:\\n is_following_zeros = self._is_zero_sequence(number_as_str[1::])\\n\\n if first_position == '1':\\n # Number ends in 1xx\\n if is_following_zeros:\\n # Number is 100\\n result = ' '.join([result, self.CEM])\\n return result.strip()\\n result = ' '.join([result, 'cento e'])\\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\\n result = ' '.join([result, self.HUNDREDS[first_position]])\\n if is_following_zeros:\\n # Number ends in a zero sequence\\n return result.strip()\\n result = ' '.join([result, 'e'])\\n return self.get_number_in_portuguese(number=number_as_str[1::], result=result)\\n\\n if number_len == 2:\\n result = ' '.join([result, self._get_two_digits_number_in_extension(number_as_str)])\\n return result.strip()\\n\\n if number_len == 1:\\n result = ' '.join([result, self.UNITS[number_as_str]])\\n\\n return result.strip()\",\n \"def _num_to_pword(num):\\n pword = ''\\n for char in num:\\n pword += chr(char)\\n return pword\",\n \"def _index_to_unicode(cls, index: int) -> str:\\n return \\\"\\\".join(cls._unicode_subscripts[int(_)] for _ in str(index))\",\n \"def convert_to_numerals(number):\\n assert number < 4000\\n expression = factorize(int(number), ROMAN_NUMERALS)\\n result = list(numeral(f) * c for c, f in normalize(expression))\\n return \\\"\\\".join(result)\",\n \"def make_unicode():\\r\\n for num in range(300, 320):\\r\\n yield unichr(num)\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\r\\n if isinstance(text, unicode):\\r\\n return text\\r\\n return unicode(text, encoding, errors=errors)\",\n \"def _convertUnicodeForCPS(self, value):\\n try:\\n value = str(value)\\n except UnicodeEncodeError:\\n try:\\n value = str(value.encode('ISO-8859-15'))\\n except UnicodeEncodeError:\\n value = repr(value)\\n return value\",\n \"def Hex(num):\\n return hex(CInt(num))[2:].upper()\",\n \"def parse(cls, value: Union[str, int]) -> 'Unicode':\\n return cls(value)\",\n \"def compact(number):\\n number = clean(number, ' ').upper().strip()\\n for prefix in ('УНП', u'УНП', 'UNP', u'UNP'):\\n if type(number) == type(prefix) and number.startswith(prefix):\\n number = number[len(prefix):]\\n # Replace Cyrillic letters with Latin letters\\n cleaned = ''.join(_cyrillic_to_latin.get(x, x) for x in to_unicode(number))\\n if type(cleaned) != type(number): # pragma: no cover (Python2 only)\\n cleaned = cleaned.encode('utf-8')\\n return cleaned\",\n \"def _process_value(self, value):\\n if isinstance(value, str):\\n try:\\n value.decode('ascii')\\n except UnicodeDecodeError:\\n return unicode(''.join([unichr(ord(c)) for c in value]))\\n return value\",\n \"def serialize_number(n):\\n return str(n)\",\n \"def setUnicodeValue(glyph, glyphList):\\n\\n if glyph.name in glyphList:\\n glyph.unicode = int(glyphList[glyph.name], 16)\\n else:\\n uvNameMatch = re.match(\\\"uni([\\\\dA-F]{4})$\\\", glyph.name)\\n if uvNameMatch:\\n glyph.unicode = int(uvNameMatch.group(1), 16)\",\n \"def FromUnicode(val):\\n if sys.version_info[0] >= 3:\\n return val\\n return val if isinstance(val, str) else val.encode('utf-8')\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\n if isinstance(text, unicode):\\n return text\\n return unicode(text, encoding, errors=errors)\",\n \"def num2str(num):\\n require_type(is_number(num), 'parameter of number->string must be a number')\\n return tostr(num)\",\n \"def _unicodeify(self, value, encoding=\\\"utf8\\\"):\\n if isinstance(value, str):\\n return value\\n return str(value, encoding)\",\n \"def to_unicode(text, encoding='utf8', errors='strict'):\\n if isinstance(text, unicode):\\n return text\\n else:\\n return unicode(text, encoding=encoding, errors=errors)\",\n \"def to_unicode(value, default=u''):\\n try:\\n if isinstance(value, unicode):\\n return value\\n return codecs.decode(value or default)\\n except Exception:\\n return codecs.decode(value or default, 'latin1')\",\n \"def translate_num(number, lower_bound, upper_bound):\\n try:\\n value = int(number, 0)\\n if value < lower_bound or value > upper_bound:\\n raise translate_num_out_of_range(value, lower_bound, upper_bound)\\n else:\\n return value\\n except:\\n raise translate_num_error(number)\",\n \"def apnumber(value):\\r\\n try:\\r\\n value = int(value)\\r\\n except (TypeError, ValueError):\\r\\n return value\\r\\n if not 0 < value < 10:\\r\\n return str(value)\\r\\n return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'),\\r\\n _('seven'), _('eight'), _('nine'))[value - 1]\",\n \"def convertbase(number, base=10):\\n\\n integer = number\\n if not integer:\\n return '0'\\n sign = 1 if integer > 0 else -1\\n alphanum = string.digits + string.ascii_lowercase\\n nums = alphanum[:base]\\n res = ''\\n integer *= sign\\n while integer:\\n integer, mod = divmod(integer, base)\\n res += nums[mod]\\n return ('' if sign == 1 else '-') + res[::-1]\",\n \"def base2str(self, int_number):\\r\\n return self.format_base % (float(int_number) / self.mult_base)\",\n \"def transform(s):\\r\\n return 'digit ' + str(s)\",\n \"def to_unicode(data):\\n if isinstance(data, bytes):\\n return data.decode('utf-8')\\n else:\\n return data\",\n \"def type_number(number: float):\\n # TODO: Allow leading zeros\\n for char in str(number):\\n actions.key(char)\",\n \"def _get_unicode_value(value: Union[Text, bytes]) -> Text:\\n decoded_value = stats_util.maybe_get_utf8(value)\\n # Check if we have a valid utf-8 string. If not, assign a placeholder.\\n if decoded_value is None:\\n _NON_UTF8_VALUES_COUNTER.inc()\\n decoded_value = constants.NON_UTF8_PLACEHOLDER\\n return decoded_value\",\n \"def conv_hex(num):\\n\\n if num < 10:\\n return str(num)\\n if num == 10:\\n return 'A'\\n if num == 11:\\n return 'B'\\n if num == 12:\\n return 'C'\\n if num == 13:\\n return 'D'\\n if num == 14:\\n return 'E'\\n if num == 15:\\n return 'F'\",\n \"def base10toN(num, base):\\n\\n converted_string, modstring = \\\"\\\", \\\"\\\"\\n currentnum = num\\n if not 1 < base < 37:\\n raise ValueError(\\\"base must be between 2 and 36\\\")\\n if not num:\\n return '0'\\n while currentnum:\\n mod = currentnum % base\\n currentnum = currentnum // base\\n converted_string = chr(48 + mod + 7*(mod > 10)) + converted_string\\n return converted_string\",\n \"def to_units(number):\\n unit = 0\\n while number >= 1024.:\\n unit += 1\\n number = number / 1024.\\n if unit == len(UNITS) - 1:\\n break\\n if unit:\\n return '%.2f%s' % (number, UNITS[unit])\\n return '%d' % number\",\n \"def format_number(number):\\r\\n if number >= 1000 and number % 1000 == 0:\\r\\n return \\\"%dk\\\" % (number/1000)\\r\\n else:\\r\\n return str(number)\",\n \"def base10toN(num, base):\\n\\n converted_string, modstring = \\\"\\\", \\\"\\\"\\n\\n currentnum = num\\n\\n if not 1 < base < 37:\\n raise ValueError(\\\"base must be between 2 and 36\\\")\\n\\n if not num:\\n return '0'\\n\\n while currentnum:\\n mod = currentnum % base\\n currentnum = currentnum // base\\n converted_string = chr(48 + mod + 7*(mod > 10)) + converted_string\\n\\n return converted_string\",\n \"def _int2str(num):\\n if num<10:\\n return '00%s'%str(num)\\n elif 10<=num<100:\\n return '0%s'%str(num)\\n else:\\n return '%s'%str(num)\",\n \"def text_transform(val):\\n if CURRENCY == \\\"USD\\\":\\n return \\\"$%d\\\" % val\\n if CURRENCY == \\\"EUR\\\":\\n return \\\"€%d\\\" % val\\n if CURRENCY == \\\"GBP\\\":\\n return \\\"£%d\\\" % val\\n return \\\"%d\\\" % val\",\n \"def transform(s):\\n return 'digit ' + str(s)\",\n \"def integer_to_english_numeral(n, activate_tts=False):\\n if activate_tts is None:\\n activate_tts = False\\n elif not isinstance(activate_tts, bool):\\n raise TypeError('Argument \\\"activate_tts\\\" is not a boolean')\\n if not isinstance(n, int):\\n raise TypeError('Not an integer')\\n if n < 0:\\n raise ValueError('Not a positive integer')\\n if n > 999999999999:\\n raise OverflowError('Integer greater than 999,999,999,999')\\n return cardinal_numerals_eng.integer_to_english(n, activate_tts)\",\n \"def _format_num(self, value) -> typing.Any:\\n return self.num_type(value)\",\n \"def convert_bytes(num):\\n for x in ['_B', 'KB', 'MB', 'GB', 'TB']:\\n if num < 1000.0:\\n return \\\"%3.1f%s\\\" % (num, x)\\n num /= 1000.0\",\n \"def convert_label_num2string(number, num_types):\\n dictionary = empty_label_dictionary(num_types)\\n all_labels = list(dictionary.keys())\\n return all_labels[number]\",\n \"def _numToOneByteString(inputvalue):\\n _checkInt(inputvalue, minvalue=0, maxvalue=0xFF)\\n\\n return chr(inputvalue)\",\n \"def u(obj):\\n return obj if isinstance(obj, unicode) else unicode(obj) # noqa: F821 pylint: disable=undefined-variable\",\n \"def int2dec(n: int) -> str:\",\n \"def english(number):\\r\\n if number == 0:\\r\\n return 'zero'\\r\\n word = ''\\r\\n for step in itertools.count():\\r\\n number, rest = divmod(number, 1000)\\r\\n word = format_num(en3(rest), step) + word\\r\\n if number == 0:\\r\\n return word.strip()\",\n \"def format_num(num):\\n if num is None:\\n return num\\n if (num < 10):\\n return '0' + str(num)\\n return str(num)\",\n \"def ltibetanToUnicode(*args):\\n import string\\n\\n # The context variable is of type XScriptContext and is available to\\n # all BeanShell scripts executed by the Script Framework\\n xModel = XSCRIPTCONTEXT.getDocument()\\n\\n #the writer controller impl supports the css.view.XSelectionSupplier interface\\n xSelectionSupplier = xModel.getCurrentController()\\n\\n #see section 7.5.1 of developers' guide\\n xIndexAccess = xSelectionSupplier.getSelection()\\n count = xIndexAccess.getCount();\\n if(count>=1): #ie we have a selection\\n i=0\\n\\twhile i < count :\\n xTextRange = xIndexAccess.getByIndex(i);\\n theString = xTextRange.getString();\\n if len(theString)!=0 :\\n newString = getNewString( theString );\\n if newString:\\n xTextRange.setString(newString);\\n xSelectionSupplier.select(xTextRange);\\n\\t i+= 1\",\n \"def bh2u(x: bytes) -> str:\\n return hfu(x).decode('ascii')\",\n \"def int2text(integer):\\n # Numbers 1-99 are handled by simply looking up words in the special_case\\n # dictionary.\\n if integer < 100:\\n return digit2text(integer)\\n\\n elif integer < 1000:\\n # If exactly some hundred, then just return the word for the hundred's\\n # place and the word 'hundred'\\n if integer%100 == 0:\\n return digit2text(integer/100)+'hundred'\\n # Otherwise return the word for the hundred's place, the word\\n # 'hundredand' and do some composition to make the rest of the words.\\n else:\\n return digit2text(integer/100)+'hundredand'+\\\\\\n digit2text(integer%100)\\n # Special case for 1000.\\n elif integer == 1000:\\n return \\\"onethousand\\\"\",\n \"def _u2i(number):\\n mask = (2 ** 32) - 1\\n if number & (1 << 31):\\n v = number | ~mask\\n else:\\n v = number & mask\\n if v >= 0:\\n return v;\\n else:\\n if exceptions:\\n raise _pigpioError(error(v))\\n else:\\n return v\",\n \"def TO_UNICODE(string):\\n try:\\n # wroks if string is unicode already\\n return unicode(string, \\\"utf-8\\\")\\n except:\\n pass\\n try:\\n # works if string is iso8859-1\\n return unicode(string, \\\"iso-8859-1\\\")\\n except:\\n pass\\n # try simple coding\\n return unicode(string)\",\n \"def convert_base(num, n):\\r\\n new_num_string = ''\\r\\n current = num\\r\\n while current != 0:\\r\\n remainder = current % n\\r\\n if remainder > 9:\\r\\n remainder_string = HEX_CHARS[remainder]\\r\\n elif remainder >= 36:\\r\\n remainder_string = '('+str(remainder)+')'\\r\\n else:\\r\\n remainder_string = str(remainder)\\r\\n new_num_string = remainder_string+new_num_string\\r\\n current = current//n\\r\\n return new_num_string\",\n \"def handle_charref(self, number):\\n codepoint = int(number[1:], 16) if number[0] in ('x', 'X') else int(number)\\n text = six.unichr(codepoint)\\n self.result.append(text)\\n return text\",\n \"def su(value):\\n return safe_unicode(value, encoding=get_charset())\",\n \"def encode_num(num):\\n\\tsnuml = list(str(num))\\n\\tif len(snuml)%2 == 1:\\n\\t\\tsnuml += 'f'\\n\\tfor i in range(len(snuml)):\\n\\t\\tif i % 2 == 0:\\n\\t\\t\\tsnuml[i], snuml[i+1] = snuml[i+1], snuml[i]\\n\\t# Below, ext=1 for some reason; use unknown numbering type, unknown\\n\\t# numbering plan.\\n\\tenc_num = (\\n\\t\\tto_hex2(len(snuml)/2 + 1) + \\\"81\\\" + ''.join(snuml)\\n\\t)\\n\\treturn(enc_num)\",\n \"def convert_list_to_unicode_str(data):\\n string = ''\\n for i, val in enumerate(data):\\n # string = string + unicode(unichr(int(val)))\\n string = string + str(int(val))\\n return string\",\n \"def strftime_to_unicode(self, fmt):\\r\\n return re.sub(\\r\\n r'(%[a-zA-Z])',\\r\\n lambda m: self.STRFTIME_TO_UNICODE.get(m.group(1), m.group(1)),\\r\\n fmt\\r\\n )\",\n \"def number(size, n):\\n\\n\\t# Little endian writing\\n\\n\\ts = \\\"\\\"\\n\\n\\twhile size > 0:\\n\\t\\ti = n % 256\\n\\t\\ts = s + chr(i)\\n#\\t\\tn = n / 256\\n\\t\\tn = n >> 8\\n\\t\\tsize = size - 1\\n\\n\\treturn s\",\n \"def _to_unicode(text):\\n # both str and unicode inherit from basestring\\n if not isinstance(text, basestring):\\n tmpl = 'expected UTF-8 encoded string or unicode, got %s value %s'\\n raise TypeError(tmpl % (type(text), text))\\n # return unicode strings unchanged\\n if isinstance(text, unicode):\\n return text\\n # otherwise assume UTF-8 encoding, which also works for ASCII\\n return unicode(text, 'utf-8')\",\n \"def number2tikx(num, tik='-'):\\n return ''.join([\\\"{:1x}\\\".format(num) if x=='0' else tik for x in list(\\\"{:08b}\\\".format(num)) ])\",\n \"def _to_unicode(obj, encoding=\\\"UTF-8\\\"):\\n if isinstance(obj, basestring):\\n if not isinstance(obj, unicode):\\n obj = unicode(obj, encoding)\\n return obj\",\n \"def get_num_with_ordinal(num):\\n num_with_ordinal = str(num) + ordinal(num)\\n return num_with_ordinal\",\n \"def numbersToLetters(number):\\n arr = [number[i:i+2] for i in range(0, len(number), 2)]\\n result = ''\\n for i in arr:\\n i = int(i)\\n if(i<=48):\\n i = i + 48\\n result += chr(i)\\n return result\",\n \"def shorten_number(self, number):\\n if number < 1000:\\n return number\\n elif number >= 1000 and number < 1000000:\\n num = self.rounded_number(number, 1000)\\n val = \\\"1M\\\" if num == \\\"1000\\\" else num + \\\"K\\\"\\n return val\\n elif number >= 1000000 and number < 1000000000:\\n num = self.rounded_number(number, 1000000)\\n val = \\\"1B\\\" if num==\\\"1000\\\" else num + \\\"M\\\"\\n return val\\n elif number >= 1000000000 and number < 1000000000000:\\n num = self.rounded_number(number, 1000000000)\\n val = \\\"1T\\\" if num==\\\"1000\\\" else num + \\\"B\\\"\\n return val\\n else:\\n num = self.rounded_number(number, 1000000000000)\\n return num + \\\"T\\\"\",\n \"def base_10_to_alphabet(number):\\r\\n return ''.join(\\r\\n chr(A_UPPERCASE + part)\\r\\n for part in _decompose(number)\\r\\n )\",\n \"def toChar(integer):\\n\\tif integer >= 0x80:\\n\\t\\treturn eval(u\\\"'\\\\\\\\x%02X'\\\"%integer)\\n\\telse:\\n\\t\\treturn chr(integer)\",\n \"def utf8tounicode(arg):\\n\\n try:\\n if isinstance(arg, unicode):\\n return arg.decode('utf-8')\\n except NameError:\\n pass # Python 3\\n return arg\",\n \"def force_unicode(value):\\n if IS_PY3:\\n # Python 3.X\\n if isinstance(value, bytes):\\n value = value.decode(\\\"utf-8\\\", errors=\\\"replace\\\")\\n elif not isinstance(value, str):\\n value = str(value)\\n else:\\n # Python 2.X\\n if isinstance(value, str):\\n value = value.decode(\\\"utf-8\\\", \\\"replace\\\")\\n elif not isinstance(value, basestring): # NOQA: F821\\n value = unicode(value) # NOQA: F821\\n\\n return value\",\n \"def numToStrLabel(self, value):\\n zero_count = 3 - len(str(value))\\n return zero_count * \\\"0\\\" + str(value)\",\n \"def _format_num(self, value):\\n if value is None or value == \\\"\\\":\\n return None\\n return self.num_type(value)\",\n \"def baseconvert(num, base):\\n\\n digits = \\\"0123456789abcdefghijklmnopqrstuvwxyz\\\"\\n\\n try:\\n num = int(num)\\n base = int(base)\\n except ValueError:\\n return \\\"\\\"\\n\\n if num < 0 or base < 2 or base > 36:\\n return \\\"\\\"\\n\\n num_string = \\\"\\\"\\n while 1:\\n remainder = num % base\\n num_string = digits[remainder] + num_string\\n num = num / base\\n if num == 0:\\n break\\n\\n return num_string\",\n \"def WWRomanNumber(number):\\r\\n\\t\\r\\n\\tif number>4999 or number<1:\\r\\n\\t\\traise OverflowError(\\\"The should be between 1 and 4999, here it is \\\"+str(number))\\r\\n\\tnumerals = { 1 : \\\"I\\\", 4 : \\\"IV\\\", 5 : \\\"V\\\", 9 : \\\"IX\\\", 10 : \\\"X\\\", 40 : \\\"XL\\\",\\r\\n\\t\\t\\t\\t50 : \\\"L\\\", 90 : \\\"XC\\\", 100 : \\\"C\\\", 400 : \\\"CD\\\", 500 : \\\"D\\\", 900 : \\\"CM\\\", 1000 : \\\"M\\\" }\\r\\n\\tresult = \\\"\\\"\\r\\n\\tfor value, numeral in sorted(numerals.items(), reverse=True):\\r\\n\\t\\twhile number >= value:\\r\\n\\t\\t\\tresult += numeral\\r\\n\\t\\t\\tnumber -= value\\r\\n\\treturn result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64799064","0.6462614","0.6408784","0.61651","0.6087401","0.59796566","0.5951445","0.58721507","0.58155435","0.5808134","0.57698685","0.5736867","0.57064986","0.5688757","0.5659142","0.56527704","0.56455475","0.56412405","0.5638056","0.56291896","0.5628756","0.5606527","0.56003255","0.55744743","0.55733424","0.55562997","0.55513173","0.5525501","0.5524011","0.55168015","0.5484748","0.5473548","0.5435925","0.5400597","0.5394439","0.5370278","0.5355876","0.5349869","0.5342844","0.53365564","0.53328264","0.53312725","0.5329335","0.5324882","0.5318651","0.5303939","0.5272596","0.5269411","0.52645767","0.52642477","0.52558535","0.5253089","0.52442884","0.5241959","0.5240604","0.52386427","0.5226031","0.5224671","0.52242947","0.52233946","0.5222839","0.5217564","0.51974267","0.5196738","0.5195075","0.5193669","0.5181466","0.51800567","0.5179674","0.51676816","0.5166159","0.51655966","0.5160403","0.51482266","0.51316154","0.5130644","0.5129517","0.51242834","0.51155055","0.51083654","0.5108312","0.5103337","0.510078","0.5100622","0.50908333","0.5082808","0.5069894","0.5060311","0.50585103","0.5050452","0.50457394","0.50376755","0.50330716","0.50327533","0.50254464","0.5022496","0.50220114","0.50146997","0.5013845","0.50120133"],"string":"[\n \"0.64799064\",\n \"0.6462614\",\n \"0.6408784\",\n \"0.61651\",\n \"0.6087401\",\n \"0.59796566\",\n \"0.5951445\",\n \"0.58721507\",\n \"0.58155435\",\n \"0.5808134\",\n \"0.57698685\",\n \"0.5736867\",\n \"0.57064986\",\n \"0.5688757\",\n \"0.5659142\",\n \"0.56527704\",\n \"0.56455475\",\n \"0.56412405\",\n \"0.5638056\",\n \"0.56291896\",\n \"0.5628756\",\n \"0.5606527\",\n \"0.56003255\",\n \"0.55744743\",\n \"0.55733424\",\n \"0.55562997\",\n \"0.55513173\",\n \"0.5525501\",\n \"0.5524011\",\n \"0.55168015\",\n \"0.5484748\",\n \"0.5473548\",\n \"0.5435925\",\n \"0.5400597\",\n \"0.5394439\",\n \"0.5370278\",\n \"0.5355876\",\n \"0.5349869\",\n \"0.5342844\",\n \"0.53365564\",\n \"0.53328264\",\n \"0.53312725\",\n \"0.5329335\",\n \"0.5324882\",\n \"0.5318651\",\n \"0.5303939\",\n \"0.5272596\",\n \"0.5269411\",\n \"0.52645767\",\n \"0.52642477\",\n \"0.52558535\",\n \"0.5253089\",\n \"0.52442884\",\n \"0.5241959\",\n \"0.5240604\",\n \"0.52386427\",\n \"0.5226031\",\n \"0.5224671\",\n \"0.52242947\",\n \"0.52233946\",\n \"0.5222839\",\n \"0.5217564\",\n \"0.51974267\",\n \"0.5196738\",\n \"0.5195075\",\n \"0.5193669\",\n \"0.5181466\",\n \"0.51800567\",\n \"0.5179674\",\n \"0.51676816\",\n \"0.5166159\",\n \"0.51655966\",\n \"0.5160403\",\n \"0.51482266\",\n \"0.51316154\",\n \"0.5130644\",\n \"0.5129517\",\n \"0.51242834\",\n \"0.51155055\",\n \"0.51083654\",\n \"0.5108312\",\n \"0.5103337\",\n \"0.510078\",\n \"0.5100622\",\n \"0.50908333\",\n \"0.5082808\",\n \"0.5069894\",\n \"0.5060311\",\n \"0.50585103\",\n \"0.5050452\",\n \"0.50457394\",\n \"0.50376755\",\n \"0.50330716\",\n \"0.50327533\",\n \"0.50254464\",\n \"0.5022496\",\n \"0.50220114\",\n \"0.50146997\",\n \"0.5013845\",\n \"0.50120133\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7085641"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78496,"cells":{"query":{"kind":"string","value":"Return a function that can be used to draw regular grid lines or tick marks."},"document":{"kind":"string","value":"def regular(step, start=0.):\n\n def output(low, high):\n newstart = math.ceil((low - start)/step) * step + start\n return numpy.arange(newstart, high, step, dtype=numpy.float)\n output.func_name = \"regular(%g, start=%g)\" % (step, start)\n return output"},"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 drawGrid(self,gridLines=True):\n if not self.changed: self.edit()\n cGrid = Fmap.GRID\n cBorder = Fmap.BORDER\n if gridLines: #--Some fools don't want the grid!\n #--Grid\n for uv in range(-25,26,5):\n xy = 512/2 - 9*uv + 4\n self.drawRect(cGrid,0,xy,512,xy+1)\n self.drawRect(cGrid,xy,0,xy+1,512)\n #--Grid axes\n xy = 512/2 + 4\n self.drawRect(cBorder,0,xy,512,xy+1)\n self.drawRect(cBorder,xy,0,xy+1,512)\n #--Border\n self.drawBorder(cBorder,0,0,512,512,4)","def gridlines(self, spacing, stroke=.5):\n # Produce the g element for the gridlines.\n gridline_g = self.doc.createElement('g')\n gridline_g.setAttribute('stroke-width', '%g'%stroke)\n self.centered.appendChild(gridline_g)\n # Produce the g element for the labels.\n labels_g = self.doc.createElement('g')\n attr = {'fill':'black', 'stroke':'none'}\n for k,v in attr.items(): labels_g.setAttribute(k,conv(v))\n self.centered.appendChild(labels_g)\n # Now draw them.\n innermost = 90-spacing if self.northern else -90+spacing\n steps = xrange(innermost, int(math.degrees(self.outer_dec)), -spacing)\n for circle in steps:\n radius = self.dec2radius(math.radians(circle))\n # First create the circle.\n c = self.doc.createElement('circle')\n attr = {'cx':0, 'cy':0, 'r':radius}\n for k,v in attr.items(): c.setAttribute(k,conv(v))\n gridline_g.appendChild(c)\n # Then create the label.\n t = self.make_textelement(\n labels_g, '%d' % circle, ('x',0), ('y',radius-3))\n #labels_g.appendChild(t)","def _render_grid_lines(self, w, h, x2, y2, w2, h2):\n # 1. find sample value of top/bottom pixel coordinate\n # 2. calc sample values that need a line and draw them using pixel-coordinates\n # 3. find time values of left/right pixel coordinate\n # 2. calc time values that need a line and draw them using pixel-coordinates\n gl.glLineWidth(1.)\n gl.glColor4f(0.15, 0.15, 0.15, 1.)\n\n self._render_grid_horlines(w, h, x2, y2, w2, h2)\n self._render_grid_verlines(w, h, x2, y2, w2, h2)","def nicegrid():\n pl.grid(b=True, which='major', color='black', linestyle='-')\n\n pl.grid(b=True, which='minor', color='silver', linestyle=':')","def draw_grid(plt):\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\n alpha, linewidth = 0.3, 0.5\n\n # Vertical Lines\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n\n # Horizontal Lines\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)","def draw_gray_grid(self):\n gray = \"#D3D3D3\"\n # Draw the vertical lines\n for x in range(0, self.width, self.scale):\n self.canvas.create_line(x, 0, x, self.height, fill=gray)\n\n # Draw the horizontal lines\n for y in range(0, self.height, self.scale):\n self.canvas.create_line(0, y, self.width, y, fill=gray)","def drawGrid(self, startrow, endrow):\n self.delete('gridline', 'text')\n rows = len(self.rowrange)\n cols = self.cols\n w = self.cellwidth\n h = self.rowheight\n x_start = self.x_start\n y_start = self.y_start\n x_pos = x_start\n\n if self.vertlines == 1:\n for col in range(cols + 1):\n x = self.col_positions[col]\n self.create_line(x, y_start, x, y_start + rows * h, tag='gridline',\n fill=self.grid_color, width=self.linewidth)\n if self.horizlines == 1:\n for row in range(startrow, endrow + 1):\n y_pos = y_start + row * h\n self.create_line(x_start, y_pos, self.tablewidth, y_pos, tag='gridline',\n fill=self.grid_color, width=self.linewidth)\n return","def drawGrid(self):\n for div in range(NBCELL):\n sec = SSIZE*div\n self.can.create_line(0, sec, GSIZE, sec, width=3, fill=GFILL)\n self.can.create_line(sec, 0, sec, GSIZE, width=3, fill=GFILL)","def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n # Round to nearest integer space\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n for hval in numpy.arange(min_x,\n max_x+x_spacing/100.0,\n x_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%d\" % int(hval+0.5))\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,\n max_y+y_spacing/100.0,\n y_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%d\" % int(vval+0.5))\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def draw_grid(self):\n if self.grid_center == True:\n (n, m) = (self.n, self.m)\n (dx, dy) = (self.dx // 2, self.dy // 2)\n else:\n (n, m) = (self.n + 1, self.m + 1)\n (dx, dy) = (0, 0)\n\n x0 = self.x0 + dx\n y0 = self.y0 + dy\n\n # vertical lines\n for j in range(m):\n p0 = (x0 + j * self.dx, y0)\n p1 = (x0 + j * self.dx, y0 + (n-1) * self.dy)\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d) \n # horizontal lines\n for i in range(n):\n p0 = (x0, y0 + i * self.dy)\n p1 = (x0 + (m-1) * self.dx, y0 + i * self.dy)\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d)","def plot_grid(self, **kwargs):\n if 'ax' in kwargs:\n ax = kwargs.pop('ax')\n else:\n ax = self.ax\n\n col = self.get_grid_line_collection(**kwargs)\n if col is not None:\n ax.add_collection(col)\n ax.set_xlim(self.extent[0], self.extent[1])\n ax.set_ylim(self.extent[2], self.extent[3])\n\n return col","def draw_grid(G: 'Graph') -> None:\n xgrid_precision = 5\n ygrid_precision = 12\n rounding = 3\n for i in range(G.grid_lines):\n pygame.draw.line(screen, black, (0, i * height//G.grid_lines),\n (width, i * height//G.grid_lines), 1)\n pygame.draw.line(screen, black, (i * width//G.grid_lines, 0),\n (i * width//G.grid_lines, height), 1)\n\n for i in range(xgrid_precision):\n x = G.dependant[round(i*len(G.dependant)/xgrid_precision)][0]\n x = grid_coord(str(round(x, rounding)))\n x_rec = x.get_rect()\n x_rec.center = (i*width/xgrid_precision, height//2 + 10)\n screen.blit(x, x_rec)\n pygame.draw.line(screen, gray, (i*width/xgrid_precision, 0),\n (i*width/xgrid_precision, height), 1)\n\n for i in range(ygrid_precision, 0, -1):\n y = i*(G.ymin - G.ymax)/ygrid_precision + G.ymax\n y = grid_coord(str(round(y, rounding)))\n y_rec = y.get_rect()\n y_rec.center = (width//2 + 8, i*height/ygrid_precision)\n screen.blit(y, y_rec)\n pygame.draw.line(screen, gray, (0, i*width/ygrid_precision),\n (width, i*width/ygrid_precision), 1)","def draw_X(self, grid_x, grid_y):\n\n x = self.gtpix(grid_x)\n y = self.gtpix(grid_y)\n delta = self.CELL_SIZE/2*self.SYMBOL_SIZE\n\n self.canvas.create_line(\n x-delta, y-delta,\n x+delta, y+delta,\n width=self.SYMBOL_WIDTH, fill=self.X_COLOR)\n\n self.canvas.create_line(\n x+delta, y-delta,\n x-delta, y+delta,\n width=self.SYMBOL_WIDTH, fill=self.X_COLOR)","def draw_grid(self):\n for i in range(N * N + 1):\n color = \"blue\" if i % N == 0 else \"gray\"\n x0 = MARGIN + i * SIDE\n y0 = MARGIN\n x1 = MARGIN + i * SIDE\n y1 = HEIGHT - MARGIN\n self.canvas.create_line(x0, y0, x1, y1, fill=color)\n\n x0 = MARGIN\n y0 = MARGIN + i * SIDE\n x1 = WIDTH - MARGIN\n y1 = MARGIN + i * SIDE\n self.canvas.create_line(x0, y0, x1, y1, fill=color)","def grid_lines(self):\n # get edges initially in model coordinates\n use_ref_coords = self.use_ref_coords\n self.use_ref_coords = False\n xyedges = self.xyedges\n self.use_ref_coords = use_ref_coords\n\n xmin = xyedges[0][0]\n xmax = xyedges[0][-1]\n ymin = xyedges[1][-1]\n ymax = xyedges[1][0]\n lines = []\n # Vertical lines\n for j in range(self.ncol + 1):\n x0 = xyedges[0][j]\n x1 = x0\n y0 = ymin\n y1 = ymax\n lines.append([(x0, y0), (x1, y1)])\n\n # horizontal lines\n for i in range(self.nrow + 1):\n x0 = xmin\n x1 = xmax\n y0 = xyedges[1][i]\n y1 = y0\n lines.append([(x0, y0), (x1, y1)])\n\n if self._has_ref_coordinates:\n lines_trans = []\n for ln in lines:\n lines_trans.append([self.get_coords(*ln[0]),\n self.get_coords(*ln[1])])\n return lines_trans\n return lines","def drawGrid(self):\n # Add vertical minor grids\n path = QPainterPath()\n minLoc = self.xMinGrid + self.minorGrid\n maxLoc = self.xMaxGrid\n gStep = self.minorGrid\n for i in range(minLoc, maxLoc, gStep):\n path.moveTo(i, self.yMinGrid)\n path.lineTo(i, self.yMaxGrid)\n self.addPath(path, self.minorGridPen)\n # Add horizontal minor grids\n path = QPainterPath()\n for i in range(minLoc, maxLoc, gStep):\n path.moveTo(self.xMinGrid, i)\n path.lineTo(self.xMaxGrid, i)\n self.addPath(path, self.minorGridPen)\n # Add vertical minor grids\n path = QPainterPath()\n minLoc = self.xMinGrid\n maxLoc = self.xMaxGrid\n gStep = self.majorGrid\n for i in range(minLoc, maxLoc, gStep):\n path.moveTo(i, self.yMinGrid)\n path.lineTo(i, self.yMaxGrid)\n self.addPath(path, self.majorGridPen)\n # Add vertical minor grids\n path = QPainterPath()\n for i in range(minLoc, maxLoc, gStep):\n path.moveTo(self.xMinGrid, i)\n path.lineTo(self.xMaxGrid, i)\n self.addPath(path, self.majorGridPen)","def draw_grid_lines(grid_display, screen_width, screen_height, box_width, box_height, line_color):\n\n for x in range(0, screen_width, box_width):\n for y in range(0, screen_height, box_height):\n pygame.draw.line(grid_display, line_color, (x, 0), (x, screen_height))\n pygame.draw.line(grid_display, line_color, (0, y), (screen_width, y))","def draw_grid(self):\n for square in range(COLS+1):\n #vertical lines\n start_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(0))\n end_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(ROWS))\n pygame.draw.line(g.screen,WHITE,start_pos,end_pos)\n for square in range(ROWS+1):\n #horizontal lines\n start_pos = (helpers.get_col_left_p(0),helpers.get_row_top_p(square))\n end_pos = (helpers.get_col_left_p(COLS),helpers.get_row_top_p(square))\n pygame.draw.line(g.screen,WHITE,start_pos,end_pos)","def default_style(func):\n def wrapper(*args, **kwargs):\n fig = plt.figure(figsize=(18,18))\n sns.set_context(\"talk\", font_scale=0.9)\n plt.xlim(-3, 3)\n plt.tick_params(grid_alpha=0.2)\n func(*args, **kwargs)\n plt.clf()\n return wrapper","def drawGrid( posn=(0,0,0), sq=10, H=5, W = 8, normal='z', colour= clr.white ) :\r\n ht = H*sq\r\n wd = W*sq\r\n for i in range( 0, wd + 1, sq ): # FOR EACH VERTICAL LINE\r\n if normal == 'z': vs.curve( pos=[(posn[0]+i, posn[1]+ht, posn[2]),\r\n (posn[0]+i, posn[1], posn[2])], color=colour )\r\n elif normal == 'x': vs.curve( pos=[(posn[0], posn[1]+ht, posn[2]+i),\r\n (posn[0], posn[1], posn[2]+i)], color=colour)\r\n else: vs.curve( pos=[(posn[0]+i, posn[1], posn[2]+ht),\r\n (posn[0]+i, posn[1], posn[2])], color=colour)\r\n for i in range( 0, ht+1, sq ): # FOR EACH HORIZONTAL LINE\r\n if normal == 'z': vs.curve( pos=[(posn[0], posn[1]+i, posn[2]),\r\n (posn[0]+wd, posn[1]+i, posn[2])], color=colour)\r\n elif normal == 'x': vs.curve( pos=[(posn[0], posn[1]+i, posn[2]+wd),\r\n (posn[0], posn[1]+i, posn[2])], color=colour)\r\n else: vs.curve( pos=[(posn[0], posn[1], posn[2]+i),\r\n (posn[0]+wd, posn[1], posn[2]+i)], color=colour)","def test_spans(self):\n fig = plt.figure()\n ax = fig.add_subplot(projection=\"ternary\")\n\n ax.axtline(0.2, c='C0')\n ax.axlline(0.3, c='C1')\n ax.axrline(0.4, c='C2')\n\n ax.axtspan(0.3, 0.5, fc='C0', alpha=0.2)\n ax.axlspan(0.4, 0.6, fc='C1', alpha=0.2)\n ax.axrspan(0.5, 0.7, fc='C2', alpha=0.2)","def draw_grid(self):\n for x in range(0, WIDTH, TILESIZE):\n pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))\n \n for y in range(0, HEIGHT, TILESIZE):\n pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))","def draw(self,ax):\n # remove cell lines if thery are on the plot\n # (if new axes are created the cell lines will be not there)\n for line in self.cell_lines:\n try:\n ax.lines.remove(line)\n except ValueError:\n pass\n # create new list with cell boundaries\n ylims = ax.get_ylim()\n self.cell_lines = [ ax.plot(xx,ylims,'k:')[0] \n for xx in zip(self.xx_cells,self.xx_cells) ]","def get_grid_line_collection(self, **kwargs):\n return self.__cls.get_grid_line_collection(**kwargs)","def DrawLines(*args, **kwargs):\n return _gdi_.PseudoDC_DrawLines(*args, **kwargs)","def SimpleLatLongGrid(min_x,min_y,max_x,max_y,hdeg,hmin,hsec,vdeg,vmin,vsec,\n color=(0.5,1.0,0.5,1.0),xoff=-0.18,yoff=1.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n x_spacing=float(hdeg)+(float(hmin)+(float(hsec)/60.0))/60.0\n y_spacing=float(vdeg)+(float(vmin)+(float(vsec)/60.0))/60.0\n\n\n # Round to nearest integer space\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n for hval in numpy.arange(min_x,\n max_x+x_spacing/100.0,\n x_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n hstr=GetLatLongString(hval,'longitude')\n pshp.set_property('position',hstr)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,\n max_y+y_spacing/100.0,\n y_spacing):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n vstr=GetLatLongString(vval,'latitude')\n pshp.set_property('position',vstr)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True)\n\n return layer","def drawGrid(self):\n\n if self.orientation == \"isometric\":\n for vline in range(0, self.map_array.shape[0]):\n line = self.canvas.create_line(iso(vline*self.cell_width, 0),\n iso(vline*self.cell_width, self.map_array.shape[0]*self.cell_height))\n self.canvas_objects.append(line)\n\n for hline in (range(0, self.map_array.shape[1])):\n line = self.canvas.create_line(iso(0, hline*self.cell_height),\n iso(self.map_array.shape[1]*self.cell_width, hline*self.cell_height))\n self.canvas_objects.append(line)\n self.canvas.bind(\"<Button-1>\", self.paintCells)\n self.canvas.bind(\"<Enter>\", self.drawFrame)\n self.canvas.bind(\"<Leave>\", self.killFrame)\n self.canvas.bind(\"<Motion>\", self.showFrame)","def _draw_component(self, gc, view_bounds=None, mode=\"normal\"):\n # What we're really trying to do with a grid is plot contour lines in\n # the space of the plot. In a rectangular plot, these will always be\n # straight lines.\n if not self.visible:\n return\n\n if not self._cache_valid:\n self._compute_ticks()\n\n if len(self._tick_positions) == 0:\n return\n\n with gc:\n gc.set_line_width(self.line_weight)\n gc.set_line_dash(self.line_style_)\n gc.set_stroke_color(self.line_color_)\n gc.set_antialias(False)\n\n if self.component is not None:\n gc.clip_to_rect(*(self.component.position + self.component.bounds))\n else:\n gc.clip_to_rect(*(self.position + self.bounds))\n\n gc.begin_path()\n if self.orientation == \"horizontal\":\n starts = self._tick_positions.copy()\n starts[:,0] = self._tick_extents[:,0]\n ends = self._tick_positions.copy()\n ends[:,0] = self._tick_extents[:,1]\n else:\n starts = self._tick_positions.copy()\n starts[:,1] = self._tick_extents[:,0]\n ends = self._tick_positions.copy()\n ends[:,1] = self._tick_extents[:,1]\n if self.flip_axis:\n starts, ends = ends, starts\n gc.line_set(starts, ends)\n gc.stroke_path()\n return","def draw( self ):\n\n if self.__drawnGrid == 0:\n draw_grid().draw()\n\n self.__drawnGrid = 1\n\n column = 0\n row = 0\n i = 0\n for mark in self.__grid:\n if row == 0:\n turtle.goto(-60+60*column, 60)\n elif row == 1:\n turtle.goto(-60+60*column, 0)\n elif row == 2:\n turtle.goto(-60+60*column, -60)\n\n if isinstance(mark, str):\n if mark.lower() == 'x': \n drawX(i)\n elif mark.lower() == 'o':\n drawO(i)\n\n column += 1\n\n if column == 3:\n column = 0\n row += 1\n\n i+=1\n\n turtle.goto(-60, 60)","def drawGrid(self):\n\n # get attrs\n self.__setupGridLineOpacity()\n\n # setup GL\n GL.glPolygonMode(GL.GL_FRONT, GL.GL_LINE)\n GL.glLineWidth(1)\n GL.glColor4f(1, 1, 1, 1)\n\n # enable opacity\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n\n # draw grid\n display_type = self.getGridDisplayType()\n if display_type == 0:\n self.drawLines(*self.getAttributes())\n else:\n self.drawIntersection(*self.getAttributes(), display_type)","def DrawLines(*args, **kwargs):\n return _gdi_.GraphicsContext_DrawLines(*args, **kwargs)","def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \n fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size)","def default_wcs_grid(axes):\n axes.coords.grid(color='white', alpha=0.6, linestyle='dotted',\n linewidth=0.5)","def drawGrid(w, rows, surface):\r\n sizeBtwn = w // rows\r\n\r\n x = 0\r\n y = 0\r\n for l in range(rows):\r\n x = x + sizeBtwn\r\n y = y + sizeBtwn\r\n\r\n #line color-white #start end\r\n # pygame.draw.line(surface, (255,255,255), (x,0), (x,w)) #vertical\r\n #pygame.draw.line(surface, (255,255,255), (0,y), (w,y)) #horizontal\r","def drawGrid(self, rect, gridSize, color, painter):\n\n lines = list()\n startX = rect.left() - (rect.left() % gridSize)\n startY = rect.top() - (rect.top() % gridSize)\n\n # add vertical lines\n x = startX\n while x < rect.right():\n lines.append(QLineF(x, rect.top(), x, rect.bottom()))\n x += gridSize\n\n # add horizontal lines\n y = startY\n while y < rect.bottom():\n lines.append(QLineF(rect.left(), y, rect.right(), y))\n y += gridSize\n\n # draw the lines\n painter.setPen(QPen(color))\n painter.drawLines(lines)","def grid_line(object):\n def __init__(self, casenum):\n self.casenum = casenum\n \n def getList(self):\n \"\"\"\n to get the whole list of grid line data\n \"\"\"\n lineList = get_array(self.casenum, 'branch')\n self.lineList = lineList\n return lineList\n \n def getLineNum(self):\n \"\"\"\n :return: number of lines\n \"\"\"\n self.lineNum = len(self.getList())\n return self.lineNum\n \n def getFBus(self):\n \"\"\"\n :return:list of \"from\" bus numbers\n \"\"\"\n FBus = []\n for e in self.getList():\n FBus.append(e[0])\n self.FBus = FBus\n return self.Bus\n \n def getTBus(self):\n \"\"\"\n :return: list of \"to\" bus numbers\n \"\"\"\n TBus = []\n for e in self.getList():\n TBus.append(e[1])\n self.TBus = TBus\n return self.TBus","def drawit(fignum=1,xlabel=\" \",ylabel=\" \",xvar=None,\n yvar=None,title=\" \",ylimit=None,\n xlimit=None):\n fig=plt.figure(fignum)\n fig.clf()\n ax1=fig.add_subplot(111)\n line=ax1.plot(xvar,yvar)\n ax1.set_xlim(xlimit)\n ax1.set_ylim(ylimit)\n ax1.set_title(title)\n ax1.set_xlabel(xlabel)\n ax1.set_ylabel(ylabel)\n fig.tight_layout()\n fig.canvas.draw()\n return fig,ax1,line[0]","def draw_grid(self):\n pygame.draw.rect(self.screen, BLACK,\n (*grid_pos, WIDTH - 150, HEIGHT-150), 2)\n for x in range(9):\n pygame.draw.line(\n self.screen,\n BLACK,\n (grid_pos[0] + (x * cell_size), grid_pos[1]),\n (grid_pos[0] + (x * cell_size), grid_pos[1] + 450),\n 2 if x % 3 == 0 else 1\n )\n pygame.draw.line(\n self.screen,\n BLACK,\n (grid_pos[0], grid_pos[1] + (x * cell_size)),\n (grid_pos[0] + 450, grid_pos[1] + (x * cell_size)),\n 2 if x % 3 == 0 else 1\n )","def undrawGrid(draw,points,coeff2,newColorArray):\r\n ## This is the merge function.\r\n ## If two neighboring regions are considered to be the same color by the comparison function then this function replaces the black line between them by a line of their color (making it invisible).\r\n for j in range(0,coeff2-1):\r\n if comparisonFunction(newColorArray[0][j],newColorArray[0][j+1]):\r\n draw.line((points*0, points*(j+1), points*(0+1)-3, points*(j+1)), fill=newColorArray[0][j], width=lineWidth)\r\n\r\n for i in range(0,coeff2-1):\r\n if comparisonFunction(newColorArray[i][0],newColorArray[i+1][0]):\r\n draw.line((points*(i+1), points*0, points*(i+1), points*1-3), fill=newColorArray[i][0], width=lineWidth)\r\n\r\n for i in range(1,coeff2):\r\n for j in range(1,coeff2):\r\n if comparisonFunction(newColorArray[i][j],newColorArray[i][j-1]):\r\n draw.line((points*i+3, points*j, points*(i+1)-3, points*j), fill=newColorArray[i][j], width=lineWidth)\r\n\r\n if comparisonFunction(newColorArray[i][j],newColorArray[i-1][j]):\r\n draw.line((points*i, points*j+3, points*i, points*(j+1)-3), fill=newColorArray[i][j], width=lineWidth)","def make_grid(self):\n length = self.size / 8\n # draw horizontal lines\n for y in range(0, self.size, length):\n self.window.create_line(0, y, self.size, y, fill = \"blue\")\n \n # draw vertical lines\n for x in range(0, self.size, length):\n self.window.create_line(x, 0, x, self.size, fill = \"blue\")\n\n # draw the axes red\n self.window.create_line(\n 0,\n self.size / 2,\n self.size, \n self.size / 2, \n fill = \"red\"\n )\n self.window.create_line(\n self.size / 2, 0,\n self.size / 2, \n self.size, \n fill = \"red\"\n )\n print(\"Grid Made.\")","def set_ticks(self, ticks, column=None, row=None, minor=False, \n round_two=False, oned=True):\n \n assert (column is not None) or (row is not None), \\\n \"Must supply column or row number!\"\n assert not ((column is not None) and (row is not None)), \\\n \"Must supply column *or* row number!\"\n \n # Could do this more compactly but who cares.\n if column is not None:\n elements = self.elements_by_column\n for j, panel_set in enumerate(elements):\n for k, panel in enumerate(panel_set):\n if j != column:\n continue\n \n self.grid[panel].set_xticks(ticks, minor=minor)\n if (not minor):\n self.grid[panel].set_xticklabels(list(map(str, ticks)))\n \n # Just apply to relevant rows, too.\n if not round_two:\n if (column > 0) or oned:\n self.set_ticks(ticks, row=self.nrows-column-1*oned, minor=minor, \n round_two=True, oned=oned)\n else:\n elements = self.elements_by_row\n for j, panel_set in enumerate(elements):\n for k, panel in enumerate(panel_set):\n if j != row:\n continue\n \n if (panel in self.diag) and oned:\n continue\n \n self.grid[panel].set_yticks(ticks, minor=minor)\n if (not minor):\n self.grid[panel].set_yticklabels(list(map(str, ticks)))\n \n if not round_two:\n if (row > 0) or oned:\n self.set_ticks(ticks, column=self.nrows-row-1*oned, minor=minor, \n round_two=True, oned=oned)\n \n pl.draw()","def powerpoint_style(Axe_tick_size=15,Line_size=3) : \n fig = plt.gcf()\n ax = fig.gca()\n # trouve tous les trucs avec linewidth et les modifie\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n # en particuliers les marqueurs des ticks\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size)\n \n # trouve tous les textes et les modifie\n def myfunc(x):\n return hasattr(x, 'set_fontsize')\n for o in fig.findobj(myfunc):\n o.set_fontsize(Axe_tick_size)\n # les labels un peu plus larges\n ax.set_xlabel(ax.get_xlabel(),fontsize = Axe_tick_size+5,labelpad=2)\n ax.set_ylabel(ax.get_ylabel(),fontsize = Axe_tick_size+5,labelpad=2)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n \n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n \n \n fig.show()","def _render(self, gc, points):\n with gc:\n gc.set_antialias(True)\n self._draw_default_axes(gc)\n self._draw_default_grid(gc)\n if len(points)>0:\n gc.clip_to_rect(self.x, self.y, self.width, self.height)\n gc.set_stroke_color(self.color_)\n gc.set_line_width(self.line_width)\n gc.set_line_dash(self.line_style_)\n\n gc.begin_path()\n gc.lines(points)\n gc.stroke_path()\n\n return","def grid_lineify(f, x_lim=(0.,256) ,y_lim=(0.,256), ntraj = 600,\n max_step = 3000, gamma = 0.02, dt = 9., e0 = 0.1,\n T = 0.1,\n e_thresh = 0.001, h = 2e-1, m = 3, bounce = False\n ):\n lines = []\n nx = int(np.sqrt(ntraj))\n x_starts, y_starts = np.meshgrid(np.linspace(x_lim[0],x_lim[1],nx),\n np.linspace(y_lim[0],y_lim[1],nx))\n x_starts = x_starts.flatten()\n y_starts = y_starts.flatten()\n for traj in range(len(x_starts)):\n x,y = x_starts[traj].item(), y_starts[traj].item()\n PE = f(x, y)\n v0 = np.sqrt(e0/m)\n vx,vy = np.random.normal(0,v0), np.random.normal(0,v0)\n line = []\n step = 0\n while step < max_step and np.sqrt(vx*vx+vy*vy) > e_thresh:\n PE = f(x, y)\n if (np.exp(-PE/.01) > np.random.random()):\n break\n # cdiff grad\n gx = ((f(x+h,y)-f(x-h,y))/(2*h)).item()\n gy = ((f(x,y+h)-f(x,y-h))/(2*h)).item()\n vx += 0.5*dt*(gx - gamma*vx + np.random.normal(0,np.sqrt(gamma*e0)) )/m\n vy += 0.5*dt*(gy - gamma*vy + np.random.normal(0,np.sqrt(gamma*e0)) )/m\n x += vx*dt\n y += vy*dt\n # Bounce off edges.\n if (bounce):\n if (x > x_lim[1]):\n x -= 2.0*np.abs(x-x_lim[1])\n vx *= -1\n if (x < x_lim[0]):\n x += 2.0*np.abs(x-x_lim[0])\n vx *= -1\n if (y > y_lim[1]):\n y -= 2.0*np.abs(y-y_lim[1])\n vy *= -1\n if (y < y_lim[0]):\n y += 2.0*np.abs(y-y_lim[0])\n vy *= -1\n else: # absorb\n if (x > x_lim[1]):\n break\n elif (x < x_lim[0]):\n break\n elif (y > y_lim[1]):\n break\n elif (y < y_lim[0]):\n break\n line.append([x,y])\n gx = ((f(x+h,y)-f(x-h,y))/(2*h)).item()\n gy = ((f(x,y+h)-f(x,y-h))/(2*h)).item()\n vx += 0.5*dt*(gx - gamma*vx + np.random.normal(0,np.sqrt(gamma*e0)) )/m\n vy += 0.5*dt*(gy - gamma*vy + np.random.normal(0,np.sqrt(gamma*e0)) )/m\n step += 1\n lines.append(line)\n return lines","def grid(self):\n def startEndPoints(start, end, num):\n \"\"\"Generate num points between a start and stop point. Assumed to be (t,x) points.\n \"\"\"\n ll = np.linspace(0,1,num)\n xxs = start[0]*(1-ll)+end[0]*ll\n tts = start[1]*(1-ll)+end[1]*ll\n return( np.array([xxs, tts]) )\n \n fig, ax = plt.subplots( figsize=(10,8) )\n # The slope is beta.\n # x' axis, input points in (x,t) S points\n boost = self.boost()\n invboost = np.linalg.inv( boost )\n astart = np.dot(invboost, [0, 0] )\n aend = np.dot(invboost, [0,10] )\n aaxis = startEndPoints( astart, aend, 40 )\n\n ax.plot(aaxis[0], aaxis[1], 'b-')\n \n # t' axis\n astart = np.dot(invboost, [0, 0])\n aend = np.dot(invboost, [10, 0])\n aaxis = startEndPoints( astart, aend, 40 )\n\n ax.plot(aaxis[0], aaxis[1], 'b-')\n \n # light lines on all 45 degrees\n aaxis = startEndPoints( [-10, -10], [10, 10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k--')\n aaxis = startEndPoints( [-10, 10], [10, -10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k--')\n \n # t-hat and x-hat axes\n aaxis = startEndPoints( [0, 0], [10, 0], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k-')\n aaxis = startEndPoints( [0, 0], [0, 10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k-')\n ax.grid(True)\n \n return( (fig, ax) )","def draw_grid(self):\n\n # Draw horizontal lines\n for row in range(self.num_rows + 1):\n left = row_column_to_pixels(row, 0)\n right = row_column_to_pixels(row, self.num_cols)\n pygame.draw.line(self.screen, COLOR_MAP['gray'], left, right)\n\n # Draw vertical lines\n for col in range(self.num_cols + 1):\n top = row_column_to_pixels(0, col)\n bottom = row_column_to_pixels(self.num_rows, col)\n pygame.draw.line(self.screen, COLOR_MAP['gray'], top, bottom)","def _DrawLineList(*args, **kwargs):\n return _gdi_.DC__DrawLineList(*args, **kwargs)","def rstyle(ax):\r\n #set the style of the major and minor grid lines, filled blocks\r\n ax.grid(True, 'major', color='w', linestyle='-', linewidth=1.4)\r\n ax.grid(True, 'minor', color='0.92', linestyle='-', linewidth=0.7)\r\n ax.patch.set_facecolor('0.85')\r\n ax.set_axisbelow(True)\r\n \r\n #set minor tick spacing to 1/2 of the major ticks\r\n ax.xaxis.set_minor_locator(pylab.MultipleLocator( (pylab.xticks()[0][1]-pylab.xticks()[0][0]) / 2.0 ))\r\n ax.yaxis.set_minor_locator(pylab.MultipleLocator( (pylab.yticks()[0][1]-pylab.yticks()[0][0]) / 2.0 ))\r\n \r\n #remove axis border\r\n for child in ax.get_children():\r\n if isinstance(child, matplotlib.spines.Spine):\r\n child.set_alpha(0)\r\n \r\n #restyle the tick lines\r\n for line in ax.get_xticklines() + ax.get_yticklines():\r\n line.set_markersize(5)\r\n line.set_color(\"gray\")\r\n line.set_markeredgewidth(1.4)\r\n \r\n #remove the minor tick lines \r\n for line in ax.xaxis.get_ticklines(minor=True) + ax.yaxis.get_ticklines(minor=True):\r\n line.set_markersize(0)\r\n \r\n #only show bottom left ticks, pointing out of axis\r\n pylab.rcParams['xtick.direction'] = 'out'\r\n pylab.rcParams['ytick.direction'] = 'out'\r\n ax.xaxis.set_ticks_position('bottom')\r\n ax.yaxis.set_ticks_position('left')\r\n \r\n \r\n if ax.legend_ <> None:\r\n lg = ax.legend_\r\n lg.get_frame().set_linewidth(0)\r\n lg.get_frame().set_alpha(0.5)","def DrawLine(*args, **kwargs):\n return _gdi_.PseudoDC_DrawLine(*args, **kwargs)","def _createline(self):\n return self.cv.create_line(0, 0, 0, 0, fill=\"\", width=2,\n capstyle = TK.ROUND)","def draw_grid(self) -> None:\n for x in range(0, WIDTH, TILE_SIZE):\n pg.draw.line(self.screen, LIGHT_GREY, (x, INFO_HEIGHT), (x, HEIGHT))\n for y in range(INFO_HEIGHT, INFO_HEIGHT + HEIGHT, TILE_SIZE):\n pg.draw.line(self.screen, LIGHT_GREY, (0, y), (WIDTH, y))","def newplot(*args, **kwargs):\n\n if 'linewidth' and 'lw' not in kwargs.keys():\n kwargs['linewidth'] = 2\n\n plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI)\n plt.plot(*args, **kwargs)\n\n plt.setp(plt.gca().spines.values(), linewidth=2)\n plt.xticks(fontsize=25, fontname='Times New Roman')\n plt.yticks(fontsize=25, fontname='Times New Roman')\n plt.ticklabel_format(useOffset=False)\n plt.ticklabel_format(style='sci', scilimits=(-3, 3))","def DrawLines(*args, **kwargs):\n return _gdi_.DC_DrawLines(*args, **kwargs)","def _add_gridline_label(self, value, axis, upper_end):\n # Have 3 choices (see Issue #78):\n # 1. lonlines go from -180 to 180, but get double 180 labels at dateline\n # 2. lonlines go from -180 to e.g. 150, but no lines from 150 to dateline\n # 3. lonlines go from lon_0 - 180 to lon_0 + 180 mod 360, but results\n # in non-monotonic array causing double gridlines east of dateline\n # 4. lonlines go from lon_0 - 180 to lon_0 + 180 monotonic, but prevents\n # labels from being drawn outside of range (-180, 180)\n # These monkey patches choose #4 and permit labels being drawn\n # outside of (-180 180)\n if axis == 'x':\n value = (value + 180) % 360 - 180\n return type(self)._add_gridline_label(self, value, axis, upper_end)","def draw_line(self, DISP, side:str, indizes:tuple, pink = False):\r\n offset = 1 #< Just to draw the line nicely\r\n pos = (indizes[0] - 1) * self.grid_size, indizes[1] * self.grid_size\r\n # Check if it's a pink line\r\n if pink:\r\n start_pos = pos[0], pos[1] + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size, pos[1] + self.grid_size // 2\r\n # Check if the line should be vertically. u for up\r\n elif side == 'u':\r\n start_pos = pos[0] + self.width - offset + self.grid_size // 2, pos[1] + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size + offset + self.grid_size // 2 - self.width, pos[1] + self.grid_size // 2\r\n # Check if the line should be horizontally. l for left\r\n elif side == 'l':\r\n start_pos = pos[0] + self.grid_size // 2, pos[1] + self.width - offset + self.grid_size // 2\r\n end_pos = pos[0] + self.grid_size // 2, pos[1] - self.width + self.grid_size + offset + self.grid_size // 2\r\n if not pink:\r\n pg.draw.line(DISP, Colors.colors['BLACK'], start_pos,end_pos, self.width + 2 * offset) \r\n else:\r\n pg.draw.line(DISP, Colors.colors['PINK'], start_pos,end_pos, self.width + 2 * offset)","def _format_apply(\n self, patch_kw, lonlim, latlim, boundinglat,\n lonlines, latlines, latmax, lonarray, latarray\n ):\n import cartopy.feature as cfeature\n import cartopy.crs as ccrs\n from cartopy.mpl import gridliner\n\n # Initial gridliner object, which ProPlot passively modifies\n # TODO: Flexible formatter?\n if not self._gridliners:\n gl = self.gridlines(zorder=2.5) # below text only\n gl._axes_domain = _axes_domain.__get__(gl) # apply monkey patches\n gl._add_gridline_label = _add_gridline_label.__get__(gl)\n gl.xlines = False\n gl.ylines = False\n try:\n lonformat = gridliner.LongitudeFormatter # newer\n latformat = gridliner.LatitudeFormatter\n except AttributeError:\n lonformat = gridliner.LONGITUDE_FORMATTER # older\n latformat = gridliner.LATITUDE_FORMATTER\n gl.xformatter = lonformat\n gl.yformatter = latformat\n gl.xlabels_top = False\n gl.xlabels_bottom = False\n gl.ylabels_left = False\n gl.ylabels_right = False\n\n # Projection extent\n # NOTE: They may add this as part of set_xlim and set_ylim in future\n # See: https://github.com/SciTools/cartopy/blob/master/lib/cartopy/mpl/geoaxes.py#L638 # noqa\n # WARNING: The set_extent method tries to set a *rectangle* between\n # the *4* (x,y) coordinate pairs (each corner), so something like\n # (-180,180,-90,90) will result in *line*, causing error!\n proj = self.projection.proj4_params['proj']\n north = isinstance(self.projection, (\n ccrs.NorthPolarStereo, projs.NorthPolarGnomonic,\n projs.NorthPolarAzimuthalEquidistant,\n projs.NorthPolarLambertAzimuthalEqualArea))\n south = isinstance(self.projection, (\n ccrs.SouthPolarStereo, projs.SouthPolarGnomonic,\n projs.SouthPolarAzimuthalEquidistant,\n projs.SouthPolarLambertAzimuthalEqualArea))\n if north or south:\n if (lonlim is not None or latlim is not None):\n _warn_proplot(\n f'{proj!r} extent is controlled by \"boundinglat\", '\n f'ignoring lonlim={lonlim!r} and latlim={latlim!r}.'\n )\n if self._boundinglat is None:\n if isinstance(self.projection, projs.NorthPolarGnomonic):\n boundinglat = 30\n elif isinstance(self.projection, projs.SouthPolarGnomonic):\n boundinglat = -30\n else:\n boundinglat = 0\n if boundinglat is not None and boundinglat != self._boundinglat:\n eps = 1e-10 # bug with full -180, 180 range when lon_0 != 0\n lat0 = (90 if north else -90)\n lon0 = self.projection.proj4_params.get('lon_0', 0)\n extent = [lon0 - 180 + eps,\n lon0 + 180 - eps, boundinglat, lat0]\n self.set_extent(extent, crs=ccrs.PlateCarree())\n self._boundinglat = boundinglat\n else:\n if boundinglat is not None:\n _warn_proplot(\n f'{proj!r} extent is controlled by \"lonlim\" and \"latlim\", '\n f'ignoring boundinglat={boundinglat!r}.'\n )\n if lonlim is not None or latlim is not None:\n lonlim = lonlim or [None, None]\n latlim = latlim or [None, None]\n lonlim, latlim = [*lonlim], [*latlim]\n lon_0 = self.projection.proj4_params.get('lon_0', 0)\n if lonlim[0] is None:\n lonlim[0] = lon_0 - 180\n if lonlim[1] is None:\n lonlim[1] = lon_0 + 180\n eps = 1e-10 # bug with full -180, 180 range when lon_0 != 0\n lonlim[0] += eps\n if latlim[0] is None:\n latlim[0] = -90\n if latlim[1] is None:\n latlim[1] = 90\n extent = [*lonlim, *latlim]\n self.set_extent(extent, crs=ccrs.PlateCarree())\n\n # Draw gridlines, manage them with one custom gridliner generated\n # by ProPlot, user may want to use griliner API directly\n gl = self._gridliners[0]\n # Collection props, see GoeAxes.gridlines() source code\n kw = rc.fill({\n 'alpha': 'geogrid.alpha',\n 'color': 'geogrid.color',\n 'linewidth': 'geogrid.linewidth',\n 'linestyle': 'geogrid.linestyle',\n }, context=True)\n gl.collection_kwargs.update(kw)\n # Grid locations\n eps = 1e-10\n if lonlines is not None:\n if len(lonlines) == 0:\n gl.xlines = False\n else:\n gl.xlines = True\n gl.xlocator = mticker.FixedLocator(lonlines)\n if latlines is not None:\n if len(latlines) == 0:\n gl.ylines = False\n else:\n gl.ylines = True\n if latlines[0] == -90:\n latlines[0] += eps\n if latlines[-1] == 90:\n latlines[-1] -= eps\n gl.ylocator = mticker.FixedLocator(latlines)\n # Grid label toggling\n # Issue warning instead of error!\n if not isinstance(self.projection, (ccrs.Mercator, ccrs.PlateCarree)):\n if latarray is not None and any(latarray):\n _warn_proplot(\n 'Cannot add gridline labels to cartopy '\n f'{type(self.projection).__name__} projection.'\n )\n latarray = [0] * 4\n if lonarray is not None and any(lonarray):\n _warn_proplot(\n 'Cannot add gridline labels to cartopy '\n f'{type(self.projection).__name__} projection.'\n )\n lonarray = [0] * 4\n if latarray is not None:\n gl.ylabels_left = latarray[0]\n gl.ylabels_right = latarray[1]\n if lonarray is not None:\n gl.xlabels_bottom = lonarray[2]\n gl.xlabels_top = lonarray[3]\n\n # Geographic features\n # WARNING: Seems cartopy features can't be updated!\n # See: https://scitools.org.uk/cartopy/docs/v0.14/_modules/cartopy/feature.html#Feature # noqa\n # Change the _kwargs property also does *nothing*\n # WARNING: Changing linewidth is impossible with cfeature. Bug?\n # See: https://stackoverflow.com/questions/43671240/changing-line-width-of-cartopy-borders # noqa\n # TODO: Editing existing natural features? Creating natural features\n # at __init__ time and hiding them?\n # NOTE: The natural_earth_shp method is deprecated, use add_feature.\n # See: https://cartopy-pelson.readthedocs.io/en/readthedocs/whats_new.html # noqa\n # NOTE: The e.g. cfeature.COASTLINE features are just for convenience,\n # hi res versions. Use cfeature.COASTLINE.name to see how it can be\n # looked up with NaturalEarthFeature.\n reso = rc['reso']\n if reso not in ('lo', 'med', 'hi'):\n raise ValueError(f'Invalid resolution {reso!r}.')\n reso = {\n 'lo': '110m',\n 'med': '50m',\n 'hi': '10m',\n }.get(reso)\n features = {\n 'land': ('physical', 'land'),\n 'ocean': ('physical', 'ocean'),\n 'lakes': ('physical', 'lakes'),\n 'coast': ('physical', 'coastline'),\n 'rivers': ('physical', 'rivers_lake_centerlines'),\n 'borders': ('cultural', 'admin_0_boundary_lines_land'),\n 'innerborders': ('cultural', 'admin_1_states_provinces_lakes'),\n }\n for name, args in features.items():\n # Get feature\n if not rc[name]: # toggled\n continue\n if getattr(self, '_' + name, None): # already drawn\n continue\n feat = cfeature.NaturalEarthFeature(*args, reso)\n # For 'lines', need to specify edgecolor and facecolor\n # See: https://github.com/SciTools/cartopy/issues/803\n kw = rc.category(name) # do not omit uncached props\n if name in ('coast', 'rivers', 'borders', 'innerborders'):\n kw['edgecolor'] = kw.pop('color')\n kw['facecolor'] = 'none'\n else:\n kw['linewidth'] = 0\n if name in ('ocean',):\n kw['zorder'] = 0.5 # below everything!\n self.add_feature(feat, **kw)\n setattr(self, '_' + name, feat)\n\n # Update patch\n kw_face = rc.fill({\n 'facecolor': 'geoaxes.facecolor',\n 'alpha': 'geoaxes.facealpha',\n }, context=True)\n kw_edge = rc.fill({\n 'edgecolor': 'geoaxes.edgecolor',\n 'linewidth': 'geoaxes.linewidth',\n }, context=True)\n kw_face.update(patch_kw or {})\n self.background_patch.update(kw_face)\n self.outline_patch.update(kw_edge)","def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\n label_type=None,shapes_name=\"Grid\"):\n\n shps=gview.GvShapes(name=shapes_name)\n gview.undo_register( shps )\n shps.add_field('position','string',20)\n\n if os.name == 'nt':\n font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n else:\n #font=\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\"\n #font=\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\"\n font=\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\"\n #font=\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\"\n\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n hspc=(max_x-min_x)/x_divisions\n vspc=(max_y-min_y)/y_divisions\n\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(hval,max_y,0,0)\n nshp.set_node(hval,min_y,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(hval,min_y+lyoff)\n pshp.set_property('position',\"%.1f\" % hval)\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\n nshp.set_node(min_x,vval,0,0)\n nshp.set_node(max_x,vval,0,1)\n shps.append(nshp)\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\n pshp.set_node(min_x+lxoff,vval)\n pshp.set_property('position',\"%.1f\" % vval)\n shps.append(pshp)\n\n cstr=gvogrfs.gv_to_ogr_color(color)\n if len(cstr) < 9:\n cstr=cstr+\"FF\"\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\n\n layer=gview.GvShapesLayer(shps)\n layer.set_property('_line_color',clstr)\n layer.set_property('_point_color',clstr)\n # Set antialias property so that lines look nice\n # when rotated.\n layer.set_property('_gl_antialias','1')\n layer.set_property('_gv_ogrfs_point',\n 'LABEL(t:{position},f:\"'+font+'\",c:'+cstr+')')\n layer.set_read_only(True) \n\n return layer","def draw_grids(self, grids):\n\n list_of_grids = is_grids_list_of_grids(grids=grids)\n\n if not list_of_grids:\n\n plt.plot(\n np.asarray(grids)[:, 1],\n np.asarray(grids)[:, 0],\n c=self.colors[0],\n lw=self.width,\n ls=self.style,\n )\n\n else:\n\n color = itertools.cycle(self.colors)\n\n for grid in grids:\n\n if not None in grid:\n if len(grid) != 0:\n plt.plot(\n np.asarray(grid)[:, 1],\n np.asarray(grid)[:, 0],\n c=next(color),\n lw=self.width,\n ls=self.style,\n )","def drawLines(\n self,\n num_columns,\n num_rows,\n pan_x,\n pan_y,\n x_offset,\n y_offset,\n spacing\n ):\n\n # draw vertical lines\n for line in range(-num_columns, num_columns):\n line *= spacing\n grid_number = pan_x - x_offset - line\n\n self.__finalizeGridLineOpacity(grid_number)\n\n GL.glBegin(GL.GL_LINES)\n GL.glVertex3f(((line + x_offset) / self.aspect_ratio), num_rows * spacing, self.GRID_DEPTH)\n GL.glVertex3f(((line + x_offset) / self.aspect_ratio), -num_rows * spacing, self.GRID_DEPTH)\n GL.glEnd()\n # draw horizontal lines\n for line in range(-num_rows, num_rows):\n\n line *= spacing\n grid_number = pan_y + line - y_offset\n self.__finalizeGridLineOpacity(grid_number)\n\n GL.glBegin(GL.GL_LINES)\n GL.glVertex3f((num_columns * spacing) / self.aspect_ratio, line - y_offset, self.GRID_DEPTH)\n GL.glVertex3f((-num_columns * spacing) / self.aspect_ratio, line - y_offset, self.GRID_DEPTH)\n GL.glEnd()","def draw_grid(self):\n buf = self.__hbar\n for rInd in range(self.row):\n line = '\\t|'\n for cInd in range(self.col):\n this = ((rInd * self.col) + cInd)\n cell = self.get_cell(this)\n if not cell:\n line += '%s|' % ' '.center(5)\n else:\n if this == self.new_cell:\n tmp = green(str(cell).center(5))\n else:\n tmp = str(cell).center(5)\n line += '%s|' % tmp\n buf += line + '\\n' + self.__hbar\n print(buf)","def make_grid(self):\n for k in range(0, NUM + 1):\n self.create_line(k * UNIT, 0, k * UNIT, SIZE, width=THICKNESS)\n self.create_line(0, k * UNIT, SIZE, k * UNIT, width=THICKNESS)","def __finalizeGridLineOpacity(self, grid_number, multiplier=2):\n opacity_list = [5, 10, 25, 50, 100, 500]\n opacity = self.getGridLineOpacity()\n if grid_number == 0.0:\n GL.glLineWidth(2)\n GL.glColor4f(*self.getGridColor(), 1)\n\n else:\n GL.glLineWidth(1)\n for n in opacity_list:\n if grid_number % n == 0:\n opacity *= multiplier\n GL.glColor4f(*self.getGridColor(), opacity)","def render(self):\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\n print(''.join(map[i] for i in self.grid[0:3]))\n print(''.join(map[i] for i in self.grid[3:6]))\n print(''.join(map[i] for i in self.grid[6:9]))\n print('====')","def render(self):\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\n print(''.join(map[i] for i in self.grid[0:3]))\n print(''.join(map[i] for i in self.grid[3:6]))\n print(''.join(map[i] for i in self.grid[6:9]))\n print('====')","def grid_init(self):\n # draw.line(surface, color, start_pos, end_pos, width/thickness)\n pygame.draw.line(\n self.game_screen,\n GameData.line_color,\n (0, GameData.square_size),\n (GameData.screen_dim, GameData.square_size),\n GameData.line_width\n )\n # # 2 horizontal\n pygame.draw.line(\n self.game_screen,\n GameData.line_color,\n (0, 2 * GameData.square_size),\n (GameData.screen_dim,2 * GameData.square_size),\n GameData.line_width\n )\n\n # # 1 vertical\n pygame.draw.line(\n self.game_screen,\n GameData.line_color,\n (GameData.square_size, 0),\n (GameData.square_size, GameData.screen_dim),\n GameData.line_width\n )\n # # 2 vertical\n pygame.draw.line(\n self.game_screen,\n GameData.line_color,\n (2 * GameData.square_size, 0),\n (2 * GameData.square_size, GameData.screen_dim),\n GameData.line_width)","def draw_grid(self, verbosity=0):\n log.debug(\"Drawing grid\")\n (x0, y0) = self.origin\n color = (191, 191, 191)\n\n (w, h) = self.surface.get_size()\n\n i = x0\n while True:\n (x, ignore) = self.map_to_screen((i, 0))\n if x > w:\n break\n pygame.draw.line(self.surface, color, (x, 0), (x, h), 1)\n i += 10\n\n j = y0\n while True:\n (ignore, y) = self.map_to_screen((0, j))\n if y > h:\n break\n pygame.draw.line(self.surface, color, (0, y), (w, y), 1)\n j -= 10","def separator_line(parent, dims, flag, packvalue=Tk.TOP, bgcol='#d9d9d9'):\n lincanvas = Tk.Canvas(parent, height=dims[1], width=dims[0])\n lincanvas.config(bg=bgcol)\n try:\n lincanvas.pack(side=packvalue, fill=Tk.BOTH, expand=Tk.YES)\n except:\n return None\n if flag:\n lincanvas.create_line(dims[2], dims[1]/2, dims[0] - dims[2],\n dims[1]/2)\n else:\n lincanvas.create_line(dims[0]/2, dims[2], dims[0]/2,\n dims[1] - dims[2])\n return lincanvas","def draw(self, special_cases={}):\n # Order and direction of axis chosen for intuitive controls.\n # Current setup mimics a grid of grids: the outer rows and columns are the\n # z and w dimensions, the inner ones are y and x (respectively).\n\n # Example 3x3x3x3\n # ... ... ...\n # ... ... ... \n # ... ... ... z\n # +\n # ...y... ... |\n # ...+... ... |\n # ...|... ... |\n # -+x\n # ... ... ...\n # ... ... ...\n # ... ... ...\n # ----------+ w\n output = []\n for z in reversed(range(self.size[2])):\n for y in reversed(range(self.size[1])):\n for w in reversed(range(self.size[3])):\n for x in range(self.size[0]):\n cell = (x, y, z, w)\n o = self.get_object_at(cell)\n if o:\n output.append(o.char)\n elif cell in special_cases:\n output.append(special_cases[cell])\n else:\n output.append('.')\n output.append(' ')\n output.append('\\n')\n output.append('\\n')\n\n return ''.join(output)","def test_grdimage_over_dateline(xrgrid):\n fig = Figure()\n assert xrgrid.gmt.registration == 0 # gridline registration\n xrgrid.gmt.gtype = 1 # geographic coordinate system\n fig.grdimage(grid=xrgrid, region=\"g\", projection=\"A0/0/1c\")\n return fig","def drawAGrid(self, DeltaX=10, DeltaY=10, Height=200, Width=200, CenterX=0, CenterY=0, Pen=None, Brush=None,\n SubGrid=None):\n height = self.scene.sceneRect().height() if Height is None else Height\n width = self.scene.sceneRect().width() if Width is None else Width\n left = self.scene.sceneRect().left() if CenterX is None else (CenterX - width / 2.0)\n right = self.scene.sceneRect().right() if CenterX is None else (CenterX + width / 2.0)\n top = self.scene.sceneRect().top() if CenterY is None else (CenterY - height / 2.0)\n bottom = self.scene.sceneRect().bottom() if CenterY is None else (CenterY + height / 2.0)\n Dx = DeltaX\n Dy = DeltaY\n pen = qtg.QPen() if Pen is None else Pen\n\n # make the background rectangle first\n if Brush is not None:\n rect = qtw.QGraphicsRectItem(left, top, width, height)\n rect.setBrush(Brush)\n rect.setPen(pen)\n self.scene.addItem(rect)\n # draw the vertical grid lines\n x = left\n while x <= right:\n lVert = qtw.QGraphicsLineItem(x, top, x, bottom)\n lVert.setPen(pen)\n self.scene.addItem(lVert)\n x += Dx\n # draw the horizontal grid lines\n y = top\n while y <= bottom:\n lHor = qtw.QGraphicsLineItem(left, y, right, y)\n lHor.setPen(pen)\n self.scene.addItem(lHor)\n y += Dy","def make_line(self, name, selection, prescale, postscale, **kwargs):\n # Only create the line with positive pre- and postscales\n # You can disable each line by setting either to a negative value\n if prescale > 0 and postscale > 0:\n line = StrippingLine(\n name,\n selection=selection,\n prescale=prescale,\n postscale=postscale,\n **kwargs\n )\n self.registerLine(line)\n return line\n else:\n return False","def draw_grid(grid):\n rows = grid.shape[0]\n cols = grid.shape[1]\n for row in range(rows):\n for col in range(cols):\n if grid[row, col] == 0: # empty\n sys.stdout.write(\" . \")\n elif grid[row, col] == 1: # path\n sys.stdout.write(\" X \")\n elif grid[row, col] == 2:\n sys.stdout.write(\" O \")\n else:\n sys.stdout.write(\" @ \")\n\n if col % cols == cols - 1:\n sys.stdout.write(\"\\n\")","def DrawGrid(self, count):\n for i in range(0, self.width, self.incr):\n self.canvas.create_line(i, 100, i, 700, fill = \"#696969\", width = 1)\n for i in range(100, 800, 100):\n self.canvas.create_line(0, i, self.width, i, fill = \"#696969\", width = 1)\n self.canvas.create_rectangle(self.incr * 4, self.height - self.incr * 3.5,\n self.width - self.incr * 4, self.height, fill = \"black\", width = 3)\n for i in range(int(self.height - self.incr * 3.5), self.height, int(self.incr / 4)):\n self.canvas.create_line(self.incr * 4, i, self.width - self.incr * 4,\n i, fill = \"#696969\", width = 1)\n for i in range(self.incr * 4, self.width - self.incr * 4 + 1, int(self.incr / 4)):\n self.canvas.create_line(i, self.height - self.incr * 3.5, i, self.height,\n fill = \"#696969\", width = 1)","def DrawSpline(*args, **kwargs):\n return _gdi_.PseudoDC_DrawSpline(*args, **kwargs)","def draw_x(row, column):\n\n # adjusting the column and rows to fit the grid\n if column != 1:\n column *= 2\n column -= 1\n\n if row != 1:\n row *= 2\n row -= 1\n\n # calculating the center position of the circle\n x_center = row * 100\n y_center = column * 77\n\n radius = 40\n\n # from top left to bottom right\n x0 = x_center - radius\n y0 = y_center - radius\n\n x1 = x_center + radius\n y1 = y_center + radius\n\n canvas.create_line(x0, y0, x1, y1, fill=\"blue\")\n\n # from bottom left to top right\n x2 = x_center + radius - 80\n y2 = y_center + radius\n\n x3 = x_center - radius + 80\n y3 = y_center - radius\n\n canvas.create_line(x2, y2, x3, y3, fill=\"blue\")\n\n return None","def draw_line(tick_length, tick_label=''):\n line = \"_\" * tick_length\n if tick_label:\n line += ' ' + tick_label\n print(line)","def is_gridlines_visible(self):\n return self.container['is_gridlines_visible']","def tickmarks(major=-10, minor=True, logbase=0, format=unicode_number):\n\n if not callable(format):\n tmp = format\n format = lambda x: tmp % x\n format.func_name = tmp\n\n def linear_tickmarks(low, high):\n if low >= high:\n raise ValueError, \"To compute tick-marks, 'low' must be lower than 'high'.\"\n\n major_ticks = _compute_majorticks(low, high, major, format)\n if minor:\n minor_ticks = _compute_minorticks(low, high, major_ticks)\n else:\n minor_ticks = {}\n minor_ticks.update(major_ticks)\n return minor_ticks\n\n def logarithmic_tickmarks(low, high):\n if low >= high:\n raise ValueError, \"To compute tick-marks, 'low' must be lower than 'high'.\"\n\n major_ticks = _compute_logmajorticks(low, high, logbase, major, format)\n if minor:\n minor_ticks = _compute_logminorticks(low, high, logbase)\n else:\n minor_ticks = {}\n minor_ticks.update(major_ticks)\n return minor_ticks\n\n if logbase == 0: output = linear_tickmarks\n else: output = logarithmic_tickmarks\n\n output.func_name = \"tickmarks(major=%d, minor=%s, logbase=%d, format=%s)\" % (major, repr(minor), logbase, format.func_name)\n return output","def create_grid(self):\n\n # If called when a grid already exists create a new grid\n if self.grid:\n self.grid = []\n\n grid_pen = QPen(QColor(215, 215, 215), 1)\n w = 10000\n h = 10000\n self.addLine(-10000, 0, 10000, 0, QPen(QColor(0, 0, 0), 2))\n self.addLine(0, -10000, 0, 10000, QPen(QColor(0, 0, 0), 2))\n\n w = int(w / self.grid_spacing) * self.grid_spacing\n h = int(h / self.grid_spacing) * self.grid_spacing\n for i in range(-w, w, self.grid_spacing):\n if i == 0:\n pass\n else:\n line = self.addLine(-w, i, w, i, grid_pen)\n line.setZValue(-1)\n self.grid.append(line)\n for i in range(-h, h, self.grid_spacing):\n if i == 0:\n pass\n else:\n line = self.addLine(i, -h, i, h, grid_pen)\n line.setZValue(-1)\n self.grid.append(line)\n\n self.grid_built = True","def grid_00():\n plot = {\"Walls\": [\"N\", \"W\"], \"TARDIS\": False, \"Transmat\": False,\n \"Plot\": \"\\nThe writings on some of these blueprints look Gallifreyan. Could it be the Master?\\n\"\n \"Is he crazy enough to help the DALEKS and others build a TARDIS?\\n\"\n \"The room continues to the SOUTH and EAST.\\n\"}\n return plot","def test_sizergrid():\n regular_grid(8, 3)\n mpl.show()","def linestyles(colors=_colors, lines=_lines,\n markers=_markers, hollow_styles=_marker_types):\n return linestyle_generator(colors, lines, markers, hollow_styles)","def draw_grid():\r\n screen.fill((0,0,0))\r\n pygame.draw.line(screen, (255,255,255),(WIDTH/3,0),(WIDTH/3,HEIGHT))\r\n pygame.draw.line(screen, (255,255,255),(2*WIDTH/3,0),(2*WIDTH/3,HEIGHT))\r\n pygame.draw.line(screen, (255,255,255),(0,HEIGHT/3),(WIDTH,HEIGHT/3))\r\n pygame.draw.line(screen, (255,255,255),(0,2*HEIGHT/3),(WIDTH,2*HEIGHT/3))","def _line(x,m,c):\n return m*x+c","def _line(x,m,c):\n return m*x+c","def drawLines_region(t0, t1, t2, t3):\r\n t0.pd()\r\n t1.pd()\r\n t2.pd()\r\n t3.pd()\r\n t0.pencolor(\"blue\")\r\n t0.pensize(3)\r\n t1.pensize(3)\r\n t2.pensize(3)\r\n t3.pensize(3)\r\n t1.pencolor(\"red\")\r\n t2.pencolor(\"green\")\r\n t3.pencolor(\"gold\")\r\n t0.rt(90)\r\n t1.rt(90)\r\n t2.rt(90)\r\n t3.rt(90)\r\n t0.fd(70)\r\n t1.fd(70)\r\n t2.fd(70)\r\n t3.fd(70)","def plot_nicer(ax, grid=False):\r\n alpha=0.7\r\n for spine in ax.spines.values():\r\n spine.set_color(\"white\")\r\n # Make text grey\r\n plt.setp(ax.get_yticklabels(), alpha=alpha)\r\n plt.setp(ax.get_xticklabels(), alpha=alpha)\r\n ax.set_xlabel(ax.get_xlabel(), alpha=alpha)\r\n ax.set_ylabel(ax.get_ylabel(), alpha=alpha)\r\n ax.set_title(ax.get_title(), alpha=alpha)\r\n if grid:\r\n ax.grid(\"lightgrey\")\r\n ax.tick_params(axis=u'y', which=u'both',color=\"#676767\")\r\n ax.tick_params(axis=u'x', which=u'both',color=\"#676767\")","def line_graph():\r\n #create the data in an array\r\n xval = np.arange(0,6,(np.pi*(1./10)))\r\n yval = np.cos(xval)\r\n data = np.array([xval,yval])\r\n data = data.transpose()\r\n y = np.arange(-1,1.5,0.5)\r\n #convert the data to a pd DataFrame\r\n df = pd.DataFrame(data,columns=[\"x\",\"y\"])\r\n #tell the DataFrame to plot the data\r\n ax = df.plot(x=\"x\",y=\"y\",label=\"0\",ylim=(-1,1),yticks=y,title=\"Cosine Approximated at Intervals of 1/(10pi)\")\r\n ax.set(xlabel=\"\",ylabel=\"\")\r\n\t#get the figure from the axes and save it\r\n fig = ax.get_figure()\r\n fig.savefig(\"my_line_graph.png\")","def get_gridline_values(self, x=None, y=None):\n if (x and y) or not (x or y):\n print('[error] use either x or y keyword arguments '\n 'to define the gridline position')\n return\n elif x:\n return self.get_vertical_gridline_values(x)\n elif y:\n return self.get_horizontal_gridline_values(y)","def DrawSpline(*args, **kwargs):\n return _gdi_.DC_DrawSpline(*args, **kwargs)","def test_show_gridlines(self):\n\n def are_gridlines_hidden():\n res = self.spreadsheet.fetch_sheet_metadata()\n sheets = res[\"sheets\"]\n sheet = utils.finditem(\n lambda x: x[\"properties\"][\"sheetId\"] == self.sheet.id,\n sheets,\n )\n return (\n sheet[\"properties\"]\n .get(\"gridProperties\", {})\n .get(\"hideGridlines\", False)\n )\n\n hidden_before = are_gridlines_hidden()\n hidden_before_property = self.sheet.is_gridlines_hidden\n\n self.sheet.hide_gridlines()\n self.sheet.show_gridlines()\n\n hidden_after = are_gridlines_hidden()\n hidden_after_property = self.sheet.is_gridlines_hidden\n\n self.assertFalse(hidden_before)\n self.assertFalse(hidden_before_property)\n self.assertFalse(hidden_after)\n self.assertFalse(hidden_after_property)","def draw(self):\n return group()","def draw(iiter):\n from matplotlib import pyplot as plt\n fig = plt.gcf()\n fig.canvas.draw()","def _set_axes(self):\n self += helper.line(stroke=\"black\", x1=self.__dict__['x'], x2=self.__dict__['x'], y1=0, y2=self.__dict__['y']*2)\n self += helper.line(stroke=\"black\", x1=0, x2=self.__dict__['x']*2, y1=self.__dict__['y'], y2=self.__dict__['y'])","def my_simple_line(master, name, r, c, rsp, csp, px, py) -> object:\n line = tk.Label(master=master, text=name, anchor='w')\n line.grid(row=r, column=c, rowspan=rsp, columnspan=csp, padx=px, pady=py)\n return line","def get_lines(self) -> list[str]:\n\n chars = self.get_char(\"border\")\n assert isinstance(chars, list)\n left_border, _, right_border, _ = chars\n\n lines = super().get_lines()\n last_line = lines.pop()\n\n for line in range(256 // self.grid_cols):\n buff = left_border\n\n for num in range(self.grid_cols):\n col = str(line * self.grid_cols + num)\n if col == \"0\":\n buff += \" \"\n continue\n\n buff += self._layer_functions[self.layer](f\"{col:>3}\", col) + \" \"\n\n buff = buff[:-1]\n lines.append(buff + \"\" + right_border)\n\n lines.append(last_line)\n\n return lines","def preparePlot(xticks, yticks, figsize=(10.5, 6), hideLabels=False, gridColor='#999999',\n gridWidth=1.0):\n plt.close()\n fig, ax = plt.subplots(figsize=figsize, facecolor='white', edgecolor='white')\n ax.axes.tick_params(labelcolor='#999999', labelsize='10')\n for axis, ticks in [(ax.get_xaxis(), xticks), (ax.get_yaxis(), yticks)]:\n axis.set_ticks_position('none')\n axis.set_ticks(ticks)\n axis.label.set_color('#999999')\n if hideLabels: axis.set_ticklabels([])\n plt.grid(color=gridColor, linewidth=gridWidth, linestyle='-')\n map(lambda position: ax.spines[position].set_visible(False), ['bottom', 'top', 'left', 'right'])\n return fig, ax","def preparePlot(xticks, yticks, figsize=(10.5, 6), hideLabels=False, gridColor='#999999',\n gridWidth=1.0):\n plt.close()\n fig, ax = plt.subplots(figsize=figsize, facecolor='white', edgecolor='white')\n ax.axes.tick_params(labelcolor='#999999', labelsize='10')\n for axis, ticks in [(ax.get_xaxis(), xticks), (ax.get_yaxis(), yticks)]:\n axis.set_ticks_position('none')\n axis.set_ticks(ticks)\n axis.label.set_color('#999999')\n if hideLabels: axis.set_ticklabels([])\n plt.grid(color=gridColor, linewidth=gridWidth, linestyle='-')\n map(lambda position: ax.spines[position].set_visible(False), ['bottom', 'top', 'left', 'right'])\n return fig, ax","def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \n #fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size) \n \n \n \n #fig.show()","def draw(self, ctx):\n self.set_size(self.width, self.available_height) \n #Drawing cell lines\n for i in range(0, (max(self.available_width,int(self.width)) / self.cell_width) + 1):\n ctx.move_to(i * self.cell_width, 0)\n ctx.line_to(i * self.cell_width, self.available_height)\n ctx.set_line_width(1)\n red = float(self.get_style().fg[gtk.STATE_INSENSITIVE].red) / 65535\n green = float(self.get_style().fg[gtk.STATE_INSENSITIVE].green) / 65535\n blue = float(self.get_style().fg[gtk.STATE_INSENSITIVE].blue) / 65535\n ctx.set_source_rgba(red, green, blue, 0.3)\n ctx.stroke()\n greatest = self.calculate_greatest() \n # Drawing scale lines\n step = greatest / 5\n ctx.save()\n ctx.set_dash([5],5)\n for i in range(int(step), int(greatest),5):\n ctx.move_to(0, self.available_height - (self.available_height - 20) * i / greatest)\n ctx.line_to(max(self.available_width,int(self.width)), self.available_height - (self.available_height - 20) * i / greatest)\n ctx.set_source_rgba(red,green,blue,0.3)\n ctx.stroke()\n\n ctx.restore()\n # Drawing the diagram\n loadingCopy = copy.deepcopy(self.loading)\n colorIndex = 0\n loadingKeys = loadingCopy.keys()\n loadingKeys.sort()\n for key in loadingKeys:\n while loadingCopy[key] != []:\n x1, y1 = loadingCopy[key].pop(0)\n if loadingCopy[key] != []:\n x2, y2 = loadingCopy[key][0]\n else:\n x2 = self.duration\n ctx.line_to (x1 * self.cell_width, self.available_height - (self.available_height - 20) * y1 / greatest)\n ctx.line_to (x2 * self.cell_width, self.available_height - (self.available_height - 20) * y1 / greatest)\n \n ctx.set_line_width(2)\n ctx.set_source_rgba(self.colors[colorIndex][0], self.colors[colorIndex][1], self.colors[colorIndex][2],0.5)\n ctx.stroke()\n colorIndex = (colorIndex + 1) % 11","def testGridFloatingPoint(self):\n self.chart.bottom.min = 0\n self.chart.bottom.max = 8\n self.chart.bottom.grid_spacing = 1\n self.assertEqual(self.Param('chg'), '12.5,0,1,0')\n self.chart.bottom.max = 3\n self.assertEqual(self.Param('chg'), '33.3,0,1,0')"],"string":"[\n \"def drawGrid(self,gridLines=True):\\n if not self.changed: self.edit()\\n cGrid = Fmap.GRID\\n cBorder = Fmap.BORDER\\n if gridLines: #--Some fools don't want the grid!\\n #--Grid\\n for uv in range(-25,26,5):\\n xy = 512/2 - 9*uv + 4\\n self.drawRect(cGrid,0,xy,512,xy+1)\\n self.drawRect(cGrid,xy,0,xy+1,512)\\n #--Grid axes\\n xy = 512/2 + 4\\n self.drawRect(cBorder,0,xy,512,xy+1)\\n self.drawRect(cBorder,xy,0,xy+1,512)\\n #--Border\\n self.drawBorder(cBorder,0,0,512,512,4)\",\n \"def gridlines(self, spacing, stroke=.5):\\n # Produce the g element for the gridlines.\\n gridline_g = self.doc.createElement('g')\\n gridline_g.setAttribute('stroke-width', '%g'%stroke)\\n self.centered.appendChild(gridline_g)\\n # Produce the g element for the labels.\\n labels_g = self.doc.createElement('g')\\n attr = {'fill':'black', 'stroke':'none'}\\n for k,v in attr.items(): labels_g.setAttribute(k,conv(v))\\n self.centered.appendChild(labels_g)\\n # Now draw them.\\n innermost = 90-spacing if self.northern else -90+spacing\\n steps = xrange(innermost, int(math.degrees(self.outer_dec)), -spacing)\\n for circle in steps:\\n radius = self.dec2radius(math.radians(circle))\\n # First create the circle.\\n c = self.doc.createElement('circle')\\n attr = {'cx':0, 'cy':0, 'r':radius}\\n for k,v in attr.items(): c.setAttribute(k,conv(v))\\n gridline_g.appendChild(c)\\n # Then create the label.\\n t = self.make_textelement(\\n labels_g, '%d' % circle, ('x',0), ('y',radius-3))\\n #labels_g.appendChild(t)\",\n \"def _render_grid_lines(self, w, h, x2, y2, w2, h2):\\n # 1. find sample value of top/bottom pixel coordinate\\n # 2. calc sample values that need a line and draw them using pixel-coordinates\\n # 3. find time values of left/right pixel coordinate\\n # 2. calc time values that need a line and draw them using pixel-coordinates\\n gl.glLineWidth(1.)\\n gl.glColor4f(0.15, 0.15, 0.15, 1.)\\n\\n self._render_grid_horlines(w, h, x2, y2, w2, h2)\\n self._render_grid_verlines(w, h, x2, y2, w2, h2)\",\n \"def nicegrid():\\n pl.grid(b=True, which='major', color='black', linestyle='-')\\n\\n pl.grid(b=True, which='minor', color='silver', linestyle=':')\",\n \"def draw_grid(plt):\\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\\n alpha, linewidth = 0.3, 0.5\\n\\n # Vertical Lines\\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n\\n # Horizontal Lines\\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)\",\n \"def draw_gray_grid(self):\\n gray = \\\"#D3D3D3\\\"\\n # Draw the vertical lines\\n for x in range(0, self.width, self.scale):\\n self.canvas.create_line(x, 0, x, self.height, fill=gray)\\n\\n # Draw the horizontal lines\\n for y in range(0, self.height, self.scale):\\n self.canvas.create_line(0, y, self.width, y, fill=gray)\",\n \"def drawGrid(self, startrow, endrow):\\n self.delete('gridline', 'text')\\n rows = len(self.rowrange)\\n cols = self.cols\\n w = self.cellwidth\\n h = self.rowheight\\n x_start = self.x_start\\n y_start = self.y_start\\n x_pos = x_start\\n\\n if self.vertlines == 1:\\n for col in range(cols + 1):\\n x = self.col_positions[col]\\n self.create_line(x, y_start, x, y_start + rows * h, tag='gridline',\\n fill=self.grid_color, width=self.linewidth)\\n if self.horizlines == 1:\\n for row in range(startrow, endrow + 1):\\n y_pos = y_start + row * h\\n self.create_line(x_start, y_pos, self.tablewidth, y_pos, tag='gridline',\\n fill=self.grid_color, width=self.linewidth)\\n return\",\n \"def drawGrid(self):\\n for div in range(NBCELL):\\n sec = SSIZE*div\\n self.can.create_line(0, sec, GSIZE, sec, width=3, fill=GFILL)\\n self.can.create_line(sec, 0, sec, GSIZE, width=3, fill=GFILL)\",\n \"def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n # Round to nearest integer space\\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n for hval in numpy.arange(min_x,\\n max_x+x_spacing/100.0,\\n x_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%d\\\" % int(hval+0.5))\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,\\n max_y+y_spacing/100.0,\\n y_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%d\\\" % int(vval+0.5))\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def draw_grid(self):\\n if self.grid_center == True:\\n (n, m) = (self.n, self.m)\\n (dx, dy) = (self.dx // 2, self.dy // 2)\\n else:\\n (n, m) = (self.n + 1, self.m + 1)\\n (dx, dy) = (0, 0)\\n\\n x0 = self.x0 + dx\\n y0 = self.y0 + dy\\n\\n # vertical lines\\n for j in range(m):\\n p0 = (x0 + j * self.dx, y0)\\n p1 = (x0 + j * self.dx, y0 + (n-1) * self.dy)\\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d) \\n # horizontal lines\\n for i in range(n):\\n p0 = (x0, y0 + i * self.dy)\\n p1 = (x0 + (m-1) * self.dx, y0 + i * self.dy)\\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d)\",\n \"def plot_grid(self, **kwargs):\\n if 'ax' in kwargs:\\n ax = kwargs.pop('ax')\\n else:\\n ax = self.ax\\n\\n col = self.get_grid_line_collection(**kwargs)\\n if col is not None:\\n ax.add_collection(col)\\n ax.set_xlim(self.extent[0], self.extent[1])\\n ax.set_ylim(self.extent[2], self.extent[3])\\n\\n return col\",\n \"def draw_grid(G: 'Graph') -> None:\\n xgrid_precision = 5\\n ygrid_precision = 12\\n rounding = 3\\n for i in range(G.grid_lines):\\n pygame.draw.line(screen, black, (0, i * height//G.grid_lines),\\n (width, i * height//G.grid_lines), 1)\\n pygame.draw.line(screen, black, (i * width//G.grid_lines, 0),\\n (i * width//G.grid_lines, height), 1)\\n\\n for i in range(xgrid_precision):\\n x = G.dependant[round(i*len(G.dependant)/xgrid_precision)][0]\\n x = grid_coord(str(round(x, rounding)))\\n x_rec = x.get_rect()\\n x_rec.center = (i*width/xgrid_precision, height//2 + 10)\\n screen.blit(x, x_rec)\\n pygame.draw.line(screen, gray, (i*width/xgrid_precision, 0),\\n (i*width/xgrid_precision, height), 1)\\n\\n for i in range(ygrid_precision, 0, -1):\\n y = i*(G.ymin - G.ymax)/ygrid_precision + G.ymax\\n y = grid_coord(str(round(y, rounding)))\\n y_rec = y.get_rect()\\n y_rec.center = (width//2 + 8, i*height/ygrid_precision)\\n screen.blit(y, y_rec)\\n pygame.draw.line(screen, gray, (0, i*width/ygrid_precision),\\n (width, i*width/ygrid_precision), 1)\",\n \"def draw_X(self, grid_x, grid_y):\\n\\n x = self.gtpix(grid_x)\\n y = self.gtpix(grid_y)\\n delta = self.CELL_SIZE/2*self.SYMBOL_SIZE\\n\\n self.canvas.create_line(\\n x-delta, y-delta,\\n x+delta, y+delta,\\n width=self.SYMBOL_WIDTH, fill=self.X_COLOR)\\n\\n self.canvas.create_line(\\n x+delta, y-delta,\\n x-delta, y+delta,\\n width=self.SYMBOL_WIDTH, fill=self.X_COLOR)\",\n \"def draw_grid(self):\\n for i in range(N * N + 1):\\n color = \\\"blue\\\" if i % N == 0 else \\\"gray\\\"\\n x0 = MARGIN + i * SIDE\\n y0 = MARGIN\\n x1 = MARGIN + i * SIDE\\n y1 = HEIGHT - MARGIN\\n self.canvas.create_line(x0, y0, x1, y1, fill=color)\\n\\n x0 = MARGIN\\n y0 = MARGIN + i * SIDE\\n x1 = WIDTH - MARGIN\\n y1 = MARGIN + i * SIDE\\n self.canvas.create_line(x0, y0, x1, y1, fill=color)\",\n \"def grid_lines(self):\\n # get edges initially in model coordinates\\n use_ref_coords = self.use_ref_coords\\n self.use_ref_coords = False\\n xyedges = self.xyedges\\n self.use_ref_coords = use_ref_coords\\n\\n xmin = xyedges[0][0]\\n xmax = xyedges[0][-1]\\n ymin = xyedges[1][-1]\\n ymax = xyedges[1][0]\\n lines = []\\n # Vertical lines\\n for j in range(self.ncol + 1):\\n x0 = xyedges[0][j]\\n x1 = x0\\n y0 = ymin\\n y1 = ymax\\n lines.append([(x0, y0), (x1, y1)])\\n\\n # horizontal lines\\n for i in range(self.nrow + 1):\\n x0 = xmin\\n x1 = xmax\\n y0 = xyedges[1][i]\\n y1 = y0\\n lines.append([(x0, y0), (x1, y1)])\\n\\n if self._has_ref_coordinates:\\n lines_trans = []\\n for ln in lines:\\n lines_trans.append([self.get_coords(*ln[0]),\\n self.get_coords(*ln[1])])\\n return lines_trans\\n return lines\",\n \"def drawGrid(self):\\n # Add vertical minor grids\\n path = QPainterPath()\\n minLoc = self.xMinGrid + self.minorGrid\\n maxLoc = self.xMaxGrid\\n gStep = self.minorGrid\\n for i in range(minLoc, maxLoc, gStep):\\n path.moveTo(i, self.yMinGrid)\\n path.lineTo(i, self.yMaxGrid)\\n self.addPath(path, self.minorGridPen)\\n # Add horizontal minor grids\\n path = QPainterPath()\\n for i in range(minLoc, maxLoc, gStep):\\n path.moveTo(self.xMinGrid, i)\\n path.lineTo(self.xMaxGrid, i)\\n self.addPath(path, self.minorGridPen)\\n # Add vertical minor grids\\n path = QPainterPath()\\n minLoc = self.xMinGrid\\n maxLoc = self.xMaxGrid\\n gStep = self.majorGrid\\n for i in range(minLoc, maxLoc, gStep):\\n path.moveTo(i, self.yMinGrid)\\n path.lineTo(i, self.yMaxGrid)\\n self.addPath(path, self.majorGridPen)\\n # Add vertical minor grids\\n path = QPainterPath()\\n for i in range(minLoc, maxLoc, gStep):\\n path.moveTo(self.xMinGrid, i)\\n path.lineTo(self.xMaxGrid, i)\\n self.addPath(path, self.majorGridPen)\",\n \"def draw_grid_lines(grid_display, screen_width, screen_height, box_width, box_height, line_color):\\n\\n for x in range(0, screen_width, box_width):\\n for y in range(0, screen_height, box_height):\\n pygame.draw.line(grid_display, line_color, (x, 0), (x, screen_height))\\n pygame.draw.line(grid_display, line_color, (0, y), (screen_width, y))\",\n \"def draw_grid(self):\\n for square in range(COLS+1):\\n #vertical lines\\n start_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(0))\\n end_pos = (helpers.get_col_left_p(square),helpers.get_row_top_p(ROWS))\\n pygame.draw.line(g.screen,WHITE,start_pos,end_pos)\\n for square in range(ROWS+1):\\n #horizontal lines\\n start_pos = (helpers.get_col_left_p(0),helpers.get_row_top_p(square))\\n end_pos = (helpers.get_col_left_p(COLS),helpers.get_row_top_p(square))\\n pygame.draw.line(g.screen,WHITE,start_pos,end_pos)\",\n \"def default_style(func):\\n def wrapper(*args, **kwargs):\\n fig = plt.figure(figsize=(18,18))\\n sns.set_context(\\\"talk\\\", font_scale=0.9)\\n plt.xlim(-3, 3)\\n plt.tick_params(grid_alpha=0.2)\\n func(*args, **kwargs)\\n plt.clf()\\n return wrapper\",\n \"def drawGrid( posn=(0,0,0), sq=10, H=5, W = 8, normal='z', colour= clr.white ) :\\r\\n ht = H*sq\\r\\n wd = W*sq\\r\\n for i in range( 0, wd + 1, sq ): # FOR EACH VERTICAL LINE\\r\\n if normal == 'z': vs.curve( pos=[(posn[0]+i, posn[1]+ht, posn[2]),\\r\\n (posn[0]+i, posn[1], posn[2])], color=colour )\\r\\n elif normal == 'x': vs.curve( pos=[(posn[0], posn[1]+ht, posn[2]+i),\\r\\n (posn[0], posn[1], posn[2]+i)], color=colour)\\r\\n else: vs.curve( pos=[(posn[0]+i, posn[1], posn[2]+ht),\\r\\n (posn[0]+i, posn[1], posn[2])], color=colour)\\r\\n for i in range( 0, ht+1, sq ): # FOR EACH HORIZONTAL LINE\\r\\n if normal == 'z': vs.curve( pos=[(posn[0], posn[1]+i, posn[2]),\\r\\n (posn[0]+wd, posn[1]+i, posn[2])], color=colour)\\r\\n elif normal == 'x': vs.curve( pos=[(posn[0], posn[1]+i, posn[2]+wd),\\r\\n (posn[0], posn[1]+i, posn[2])], color=colour)\\r\\n else: vs.curve( pos=[(posn[0], posn[1], posn[2]+i),\\r\\n (posn[0]+wd, posn[1], posn[2]+i)], color=colour)\",\n \"def test_spans(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(projection=\\\"ternary\\\")\\n\\n ax.axtline(0.2, c='C0')\\n ax.axlline(0.3, c='C1')\\n ax.axrline(0.4, c='C2')\\n\\n ax.axtspan(0.3, 0.5, fc='C0', alpha=0.2)\\n ax.axlspan(0.4, 0.6, fc='C1', alpha=0.2)\\n ax.axrspan(0.5, 0.7, fc='C2', alpha=0.2)\",\n \"def draw_grid(self):\\n for x in range(0, WIDTH, TILESIZE):\\n pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))\\n \\n for y in range(0, HEIGHT, TILESIZE):\\n pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))\",\n \"def draw(self,ax):\\n # remove cell lines if thery are on the plot\\n # (if new axes are created the cell lines will be not there)\\n for line in self.cell_lines:\\n try:\\n ax.lines.remove(line)\\n except ValueError:\\n pass\\n # create new list with cell boundaries\\n ylims = ax.get_ylim()\\n self.cell_lines = [ ax.plot(xx,ylims,'k:')[0] \\n for xx in zip(self.xx_cells,self.xx_cells) ]\",\n \"def get_grid_line_collection(self, **kwargs):\\n return self.__cls.get_grid_line_collection(**kwargs)\",\n \"def DrawLines(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawLines(*args, **kwargs)\",\n \"def SimpleLatLongGrid(min_x,min_y,max_x,max_y,hdeg,hmin,hsec,vdeg,vmin,vsec,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.18,yoff=1.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n x_spacing=float(hdeg)+(float(hmin)+(float(hsec)/60.0))/60.0\\n y_spacing=float(vdeg)+(float(vmin)+(float(vsec)/60.0))/60.0\\n\\n\\n # Round to nearest integer space\\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n for hval in numpy.arange(min_x,\\n max_x+x_spacing/100.0,\\n x_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n hstr=GetLatLongString(hval,'longitude')\\n pshp.set_property('position',hstr)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,\\n max_y+y_spacing/100.0,\\n y_spacing):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n vstr=GetLatLongString(vval,'latitude')\\n pshp.set_property('position',vstr)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True)\\n\\n return layer\",\n \"def drawGrid(self):\\n\\n if self.orientation == \\\"isometric\\\":\\n for vline in range(0, self.map_array.shape[0]):\\n line = self.canvas.create_line(iso(vline*self.cell_width, 0),\\n iso(vline*self.cell_width, self.map_array.shape[0]*self.cell_height))\\n self.canvas_objects.append(line)\\n\\n for hline in (range(0, self.map_array.shape[1])):\\n line = self.canvas.create_line(iso(0, hline*self.cell_height),\\n iso(self.map_array.shape[1]*self.cell_width, hline*self.cell_height))\\n self.canvas_objects.append(line)\\n self.canvas.bind(\\\"<Button-1>\\\", self.paintCells)\\n self.canvas.bind(\\\"<Enter>\\\", self.drawFrame)\\n self.canvas.bind(\\\"<Leave>\\\", self.killFrame)\\n self.canvas.bind(\\\"<Motion>\\\", self.showFrame)\",\n \"def _draw_component(self, gc, view_bounds=None, mode=\\\"normal\\\"):\\n # What we're really trying to do with a grid is plot contour lines in\\n # the space of the plot. In a rectangular plot, these will always be\\n # straight lines.\\n if not self.visible:\\n return\\n\\n if not self._cache_valid:\\n self._compute_ticks()\\n\\n if len(self._tick_positions) == 0:\\n return\\n\\n with gc:\\n gc.set_line_width(self.line_weight)\\n gc.set_line_dash(self.line_style_)\\n gc.set_stroke_color(self.line_color_)\\n gc.set_antialias(False)\\n\\n if self.component is not None:\\n gc.clip_to_rect(*(self.component.position + self.component.bounds))\\n else:\\n gc.clip_to_rect(*(self.position + self.bounds))\\n\\n gc.begin_path()\\n if self.orientation == \\\"horizontal\\\":\\n starts = self._tick_positions.copy()\\n starts[:,0] = self._tick_extents[:,0]\\n ends = self._tick_positions.copy()\\n ends[:,0] = self._tick_extents[:,1]\\n else:\\n starts = self._tick_positions.copy()\\n starts[:,1] = self._tick_extents[:,0]\\n ends = self._tick_positions.copy()\\n ends[:,1] = self._tick_extents[:,1]\\n if self.flip_axis:\\n starts, ends = ends, starts\\n gc.line_set(starts, ends)\\n gc.stroke_path()\\n return\",\n \"def draw( self ):\\n\\n if self.__drawnGrid == 0:\\n draw_grid().draw()\\n\\n self.__drawnGrid = 1\\n\\n column = 0\\n row = 0\\n i = 0\\n for mark in self.__grid:\\n if row == 0:\\n turtle.goto(-60+60*column, 60)\\n elif row == 1:\\n turtle.goto(-60+60*column, 0)\\n elif row == 2:\\n turtle.goto(-60+60*column, -60)\\n\\n if isinstance(mark, str):\\n if mark.lower() == 'x': \\n drawX(i)\\n elif mark.lower() == 'o':\\n drawO(i)\\n\\n column += 1\\n\\n if column == 3:\\n column = 0\\n row += 1\\n\\n i+=1\\n\\n turtle.goto(-60, 60)\",\n \"def drawGrid(self):\\n\\n # get attrs\\n self.__setupGridLineOpacity()\\n\\n # setup GL\\n GL.glPolygonMode(GL.GL_FRONT, GL.GL_LINE)\\n GL.glLineWidth(1)\\n GL.glColor4f(1, 1, 1, 1)\\n\\n # enable opacity\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n\\n # draw grid\\n display_type = self.getGridDisplayType()\\n if display_type == 0:\\n self.drawLines(*self.getAttributes())\\n else:\\n self.drawIntersection(*self.getAttributes(), display_type)\",\n \"def DrawLines(*args, **kwargs):\\n return _gdi_.GraphicsContext_DrawLines(*args, **kwargs)\",\n \"def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \\n fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size)\",\n \"def default_wcs_grid(axes):\\n axes.coords.grid(color='white', alpha=0.6, linestyle='dotted',\\n linewidth=0.5)\",\n \"def drawGrid(w, rows, surface):\\r\\n sizeBtwn = w // rows\\r\\n\\r\\n x = 0\\r\\n y = 0\\r\\n for l in range(rows):\\r\\n x = x + sizeBtwn\\r\\n y = y + sizeBtwn\\r\\n\\r\\n #line color-white #start end\\r\\n # pygame.draw.line(surface, (255,255,255), (x,0), (x,w)) #vertical\\r\\n #pygame.draw.line(surface, (255,255,255), (0,y), (w,y)) #horizontal\\r\",\n \"def drawGrid(self, rect, gridSize, color, painter):\\n\\n lines = list()\\n startX = rect.left() - (rect.left() % gridSize)\\n startY = rect.top() - (rect.top() % gridSize)\\n\\n # add vertical lines\\n x = startX\\n while x < rect.right():\\n lines.append(QLineF(x, rect.top(), x, rect.bottom()))\\n x += gridSize\\n\\n # add horizontal lines\\n y = startY\\n while y < rect.bottom():\\n lines.append(QLineF(rect.left(), y, rect.right(), y))\\n y += gridSize\\n\\n # draw the lines\\n painter.setPen(QPen(color))\\n painter.drawLines(lines)\",\n \"def grid_line(object):\\n def __init__(self, casenum):\\n self.casenum = casenum\\n \\n def getList(self):\\n \\\"\\\"\\\"\\n to get the whole list of grid line data\\n \\\"\\\"\\\"\\n lineList = get_array(self.casenum, 'branch')\\n self.lineList = lineList\\n return lineList\\n \\n def getLineNum(self):\\n \\\"\\\"\\\"\\n :return: number of lines\\n \\\"\\\"\\\"\\n self.lineNum = len(self.getList())\\n return self.lineNum\\n \\n def getFBus(self):\\n \\\"\\\"\\\"\\n :return:list of \\\"from\\\" bus numbers\\n \\\"\\\"\\\"\\n FBus = []\\n for e in self.getList():\\n FBus.append(e[0])\\n self.FBus = FBus\\n return self.Bus\\n \\n def getTBus(self):\\n \\\"\\\"\\\"\\n :return: list of \\\"to\\\" bus numbers\\n \\\"\\\"\\\"\\n TBus = []\\n for e in self.getList():\\n TBus.append(e[1])\\n self.TBus = TBus\\n return self.TBus\",\n \"def drawit(fignum=1,xlabel=\\\" \\\",ylabel=\\\" \\\",xvar=None,\\n yvar=None,title=\\\" \\\",ylimit=None,\\n xlimit=None):\\n fig=plt.figure(fignum)\\n fig.clf()\\n ax1=fig.add_subplot(111)\\n line=ax1.plot(xvar,yvar)\\n ax1.set_xlim(xlimit)\\n ax1.set_ylim(ylimit)\\n ax1.set_title(title)\\n ax1.set_xlabel(xlabel)\\n ax1.set_ylabel(ylabel)\\n fig.tight_layout()\\n fig.canvas.draw()\\n return fig,ax1,line[0]\",\n \"def draw_grid(self):\\n pygame.draw.rect(self.screen, BLACK,\\n (*grid_pos, WIDTH - 150, HEIGHT-150), 2)\\n for x in range(9):\\n pygame.draw.line(\\n self.screen,\\n BLACK,\\n (grid_pos[0] + (x * cell_size), grid_pos[1]),\\n (grid_pos[0] + (x * cell_size), grid_pos[1] + 450),\\n 2 if x % 3 == 0 else 1\\n )\\n pygame.draw.line(\\n self.screen,\\n BLACK,\\n (grid_pos[0], grid_pos[1] + (x * cell_size)),\\n (grid_pos[0] + 450, grid_pos[1] + (x * cell_size)),\\n 2 if x % 3 == 0 else 1\\n )\",\n \"def undrawGrid(draw,points,coeff2,newColorArray):\\r\\n ## This is the merge function.\\r\\n ## If two neighboring regions are considered to be the same color by the comparison function then this function replaces the black line between them by a line of their color (making it invisible).\\r\\n for j in range(0,coeff2-1):\\r\\n if comparisonFunction(newColorArray[0][j],newColorArray[0][j+1]):\\r\\n draw.line((points*0, points*(j+1), points*(0+1)-3, points*(j+1)), fill=newColorArray[0][j], width=lineWidth)\\r\\n\\r\\n for i in range(0,coeff2-1):\\r\\n if comparisonFunction(newColorArray[i][0],newColorArray[i+1][0]):\\r\\n draw.line((points*(i+1), points*0, points*(i+1), points*1-3), fill=newColorArray[i][0], width=lineWidth)\\r\\n\\r\\n for i in range(1,coeff2):\\r\\n for j in range(1,coeff2):\\r\\n if comparisonFunction(newColorArray[i][j],newColorArray[i][j-1]):\\r\\n draw.line((points*i+3, points*j, points*(i+1)-3, points*j), fill=newColorArray[i][j], width=lineWidth)\\r\\n\\r\\n if comparisonFunction(newColorArray[i][j],newColorArray[i-1][j]):\\r\\n draw.line((points*i, points*j+3, points*i, points*(j+1)-3), fill=newColorArray[i][j], width=lineWidth)\",\n \"def make_grid(self):\\n length = self.size / 8\\n # draw horizontal lines\\n for y in range(0, self.size, length):\\n self.window.create_line(0, y, self.size, y, fill = \\\"blue\\\")\\n \\n # draw vertical lines\\n for x in range(0, self.size, length):\\n self.window.create_line(x, 0, x, self.size, fill = \\\"blue\\\")\\n\\n # draw the axes red\\n self.window.create_line(\\n 0,\\n self.size / 2,\\n self.size, \\n self.size / 2, \\n fill = \\\"red\\\"\\n )\\n self.window.create_line(\\n self.size / 2, 0,\\n self.size / 2, \\n self.size, \\n fill = \\\"red\\\"\\n )\\n print(\\\"Grid Made.\\\")\",\n \"def set_ticks(self, ticks, column=None, row=None, minor=False, \\n round_two=False, oned=True):\\n \\n assert (column is not None) or (row is not None), \\\\\\n \\\"Must supply column or row number!\\\"\\n assert not ((column is not None) and (row is not None)), \\\\\\n \\\"Must supply column *or* row number!\\\"\\n \\n # Could do this more compactly but who cares.\\n if column is not None:\\n elements = self.elements_by_column\\n for j, panel_set in enumerate(elements):\\n for k, panel in enumerate(panel_set):\\n if j != column:\\n continue\\n \\n self.grid[panel].set_xticks(ticks, minor=minor)\\n if (not minor):\\n self.grid[panel].set_xticklabels(list(map(str, ticks)))\\n \\n # Just apply to relevant rows, too.\\n if not round_two:\\n if (column > 0) or oned:\\n self.set_ticks(ticks, row=self.nrows-column-1*oned, minor=minor, \\n round_two=True, oned=oned)\\n else:\\n elements = self.elements_by_row\\n for j, panel_set in enumerate(elements):\\n for k, panel in enumerate(panel_set):\\n if j != row:\\n continue\\n \\n if (panel in self.diag) and oned:\\n continue\\n \\n self.grid[panel].set_yticks(ticks, minor=minor)\\n if (not minor):\\n self.grid[panel].set_yticklabels(list(map(str, ticks)))\\n \\n if not round_two:\\n if (row > 0) or oned:\\n self.set_ticks(ticks, column=self.nrows-row-1*oned, minor=minor, \\n round_two=True, oned=oned)\\n \\n pl.draw()\",\n \"def powerpoint_style(Axe_tick_size=15,Line_size=3) : \\n fig = plt.gcf()\\n ax = fig.gca()\\n # trouve tous les trucs avec linewidth et les modifie\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n # en particuliers les marqueurs des ticks\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size)\\n \\n # trouve tous les textes et les modifie\\n def myfunc(x):\\n return hasattr(x, 'set_fontsize')\\n for o in fig.findobj(myfunc):\\n o.set_fontsize(Axe_tick_size)\\n # les labels un peu plus larges\\n ax.set_xlabel(ax.get_xlabel(),fontsize = Axe_tick_size+5,labelpad=2)\\n ax.set_ylabel(ax.get_ylabel(),fontsize = Axe_tick_size+5,labelpad=2)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n \\n \\n fig.show()\",\n \"def _render(self, gc, points):\\n with gc:\\n gc.set_antialias(True)\\n self._draw_default_axes(gc)\\n self._draw_default_grid(gc)\\n if len(points)>0:\\n gc.clip_to_rect(self.x, self.y, self.width, self.height)\\n gc.set_stroke_color(self.color_)\\n gc.set_line_width(self.line_width)\\n gc.set_line_dash(self.line_style_)\\n\\n gc.begin_path()\\n gc.lines(points)\\n gc.stroke_path()\\n\\n return\",\n \"def grid_lineify(f, x_lim=(0.,256) ,y_lim=(0.,256), ntraj = 600,\\n max_step = 3000, gamma = 0.02, dt = 9., e0 = 0.1,\\n T = 0.1,\\n e_thresh = 0.001, h = 2e-1, m = 3, bounce = False\\n ):\\n lines = []\\n nx = int(np.sqrt(ntraj))\\n x_starts, y_starts = np.meshgrid(np.linspace(x_lim[0],x_lim[1],nx),\\n np.linspace(y_lim[0],y_lim[1],nx))\\n x_starts = x_starts.flatten()\\n y_starts = y_starts.flatten()\\n for traj in range(len(x_starts)):\\n x,y = x_starts[traj].item(), y_starts[traj].item()\\n PE = f(x, y)\\n v0 = np.sqrt(e0/m)\\n vx,vy = np.random.normal(0,v0), np.random.normal(0,v0)\\n line = []\\n step = 0\\n while step < max_step and np.sqrt(vx*vx+vy*vy) > e_thresh:\\n PE = f(x, y)\\n if (np.exp(-PE/.01) > np.random.random()):\\n break\\n # cdiff grad\\n gx = ((f(x+h,y)-f(x-h,y))/(2*h)).item()\\n gy = ((f(x,y+h)-f(x,y-h))/(2*h)).item()\\n vx += 0.5*dt*(gx - gamma*vx + np.random.normal(0,np.sqrt(gamma*e0)) )/m\\n vy += 0.5*dt*(gy - gamma*vy + np.random.normal(0,np.sqrt(gamma*e0)) )/m\\n x += vx*dt\\n y += vy*dt\\n # Bounce off edges.\\n if (bounce):\\n if (x > x_lim[1]):\\n x -= 2.0*np.abs(x-x_lim[1])\\n vx *= -1\\n if (x < x_lim[0]):\\n x += 2.0*np.abs(x-x_lim[0])\\n vx *= -1\\n if (y > y_lim[1]):\\n y -= 2.0*np.abs(y-y_lim[1])\\n vy *= -1\\n if (y < y_lim[0]):\\n y += 2.0*np.abs(y-y_lim[0])\\n vy *= -1\\n else: # absorb\\n if (x > x_lim[1]):\\n break\\n elif (x < x_lim[0]):\\n break\\n elif (y > y_lim[1]):\\n break\\n elif (y < y_lim[0]):\\n break\\n line.append([x,y])\\n gx = ((f(x+h,y)-f(x-h,y))/(2*h)).item()\\n gy = ((f(x,y+h)-f(x,y-h))/(2*h)).item()\\n vx += 0.5*dt*(gx - gamma*vx + np.random.normal(0,np.sqrt(gamma*e0)) )/m\\n vy += 0.5*dt*(gy - gamma*vy + np.random.normal(0,np.sqrt(gamma*e0)) )/m\\n step += 1\\n lines.append(line)\\n return lines\",\n \"def grid(self):\\n def startEndPoints(start, end, num):\\n \\\"\\\"\\\"Generate num points between a start and stop point. Assumed to be (t,x) points.\\n \\\"\\\"\\\"\\n ll = np.linspace(0,1,num)\\n xxs = start[0]*(1-ll)+end[0]*ll\\n tts = start[1]*(1-ll)+end[1]*ll\\n return( np.array([xxs, tts]) )\\n \\n fig, ax = plt.subplots( figsize=(10,8) )\\n # The slope is beta.\\n # x' axis, input points in (x,t) S points\\n boost = self.boost()\\n invboost = np.linalg.inv( boost )\\n astart = np.dot(invboost, [0, 0] )\\n aend = np.dot(invboost, [0,10] )\\n aaxis = startEndPoints( astart, aend, 40 )\\n\\n ax.plot(aaxis[0], aaxis[1], 'b-')\\n \\n # t' axis\\n astart = np.dot(invboost, [0, 0])\\n aend = np.dot(invboost, [10, 0])\\n aaxis = startEndPoints( astart, aend, 40 )\\n\\n ax.plot(aaxis[0], aaxis[1], 'b-')\\n \\n # light lines on all 45 degrees\\n aaxis = startEndPoints( [-10, -10], [10, 10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k--')\\n aaxis = startEndPoints( [-10, 10], [10, -10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k--')\\n \\n # t-hat and x-hat axes\\n aaxis = startEndPoints( [0, 0], [10, 0], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k-')\\n aaxis = startEndPoints( [0, 0], [0, 10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k-')\\n ax.grid(True)\\n \\n return( (fig, ax) )\",\n \"def draw_grid(self):\\n\\n # Draw horizontal lines\\n for row in range(self.num_rows + 1):\\n left = row_column_to_pixels(row, 0)\\n right = row_column_to_pixels(row, self.num_cols)\\n pygame.draw.line(self.screen, COLOR_MAP['gray'], left, right)\\n\\n # Draw vertical lines\\n for col in range(self.num_cols + 1):\\n top = row_column_to_pixels(0, col)\\n bottom = row_column_to_pixels(self.num_rows, col)\\n pygame.draw.line(self.screen, COLOR_MAP['gray'], top, bottom)\",\n \"def _DrawLineList(*args, **kwargs):\\n return _gdi_.DC__DrawLineList(*args, **kwargs)\",\n \"def rstyle(ax):\\r\\n #set the style of the major and minor grid lines, filled blocks\\r\\n ax.grid(True, 'major', color='w', linestyle='-', linewidth=1.4)\\r\\n ax.grid(True, 'minor', color='0.92', linestyle='-', linewidth=0.7)\\r\\n ax.patch.set_facecolor('0.85')\\r\\n ax.set_axisbelow(True)\\r\\n \\r\\n #set minor tick spacing to 1/2 of the major ticks\\r\\n ax.xaxis.set_minor_locator(pylab.MultipleLocator( (pylab.xticks()[0][1]-pylab.xticks()[0][0]) / 2.0 ))\\r\\n ax.yaxis.set_minor_locator(pylab.MultipleLocator( (pylab.yticks()[0][1]-pylab.yticks()[0][0]) / 2.0 ))\\r\\n \\r\\n #remove axis border\\r\\n for child in ax.get_children():\\r\\n if isinstance(child, matplotlib.spines.Spine):\\r\\n child.set_alpha(0)\\r\\n \\r\\n #restyle the tick lines\\r\\n for line in ax.get_xticklines() + ax.get_yticklines():\\r\\n line.set_markersize(5)\\r\\n line.set_color(\\\"gray\\\")\\r\\n line.set_markeredgewidth(1.4)\\r\\n \\r\\n #remove the minor tick lines \\r\\n for line in ax.xaxis.get_ticklines(minor=True) + ax.yaxis.get_ticklines(minor=True):\\r\\n line.set_markersize(0)\\r\\n \\r\\n #only show bottom left ticks, pointing out of axis\\r\\n pylab.rcParams['xtick.direction'] = 'out'\\r\\n pylab.rcParams['ytick.direction'] = 'out'\\r\\n ax.xaxis.set_ticks_position('bottom')\\r\\n ax.yaxis.set_ticks_position('left')\\r\\n \\r\\n \\r\\n if ax.legend_ <> None:\\r\\n lg = ax.legend_\\r\\n lg.get_frame().set_linewidth(0)\\r\\n lg.get_frame().set_alpha(0.5)\",\n \"def DrawLine(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawLine(*args, **kwargs)\",\n \"def _createline(self):\\n return self.cv.create_line(0, 0, 0, 0, fill=\\\"\\\", width=2,\\n capstyle = TK.ROUND)\",\n \"def draw_grid(self) -> None:\\n for x in range(0, WIDTH, TILE_SIZE):\\n pg.draw.line(self.screen, LIGHT_GREY, (x, INFO_HEIGHT), (x, HEIGHT))\\n for y in range(INFO_HEIGHT, INFO_HEIGHT + HEIGHT, TILE_SIZE):\\n pg.draw.line(self.screen, LIGHT_GREY, (0, y), (WIDTH, y))\",\n \"def newplot(*args, **kwargs):\\n\\n if 'linewidth' and 'lw' not in kwargs.keys():\\n kwargs['linewidth'] = 2\\n\\n plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI)\\n plt.plot(*args, **kwargs)\\n\\n plt.setp(plt.gca().spines.values(), linewidth=2)\\n plt.xticks(fontsize=25, fontname='Times New Roman')\\n plt.yticks(fontsize=25, fontname='Times New Roman')\\n plt.ticklabel_format(useOffset=False)\\n plt.ticklabel_format(style='sci', scilimits=(-3, 3))\",\n \"def DrawLines(*args, **kwargs):\\n return _gdi_.DC_DrawLines(*args, **kwargs)\",\n \"def _add_gridline_label(self, value, axis, upper_end):\\n # Have 3 choices (see Issue #78):\\n # 1. lonlines go from -180 to 180, but get double 180 labels at dateline\\n # 2. lonlines go from -180 to e.g. 150, but no lines from 150 to dateline\\n # 3. lonlines go from lon_0 - 180 to lon_0 + 180 mod 360, but results\\n # in non-monotonic array causing double gridlines east of dateline\\n # 4. lonlines go from lon_0 - 180 to lon_0 + 180 monotonic, but prevents\\n # labels from being drawn outside of range (-180, 180)\\n # These monkey patches choose #4 and permit labels being drawn\\n # outside of (-180 180)\\n if axis == 'x':\\n value = (value + 180) % 360 - 180\\n return type(self)._add_gridline_label(self, value, axis, upper_end)\",\n \"def draw_line(self, DISP, side:str, indizes:tuple, pink = False):\\r\\n offset = 1 #< Just to draw the line nicely\\r\\n pos = (indizes[0] - 1) * self.grid_size, indizes[1] * self.grid_size\\r\\n # Check if it's a pink line\\r\\n if pink:\\r\\n start_pos = pos[0], pos[1] + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size, pos[1] + self.grid_size // 2\\r\\n # Check if the line should be vertically. u for up\\r\\n elif side == 'u':\\r\\n start_pos = pos[0] + self.width - offset + self.grid_size // 2, pos[1] + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size + offset + self.grid_size // 2 - self.width, pos[1] + self.grid_size // 2\\r\\n # Check if the line should be horizontally. l for left\\r\\n elif side == 'l':\\r\\n start_pos = pos[0] + self.grid_size // 2, pos[1] + self.width - offset + self.grid_size // 2\\r\\n end_pos = pos[0] + self.grid_size // 2, pos[1] - self.width + self.grid_size + offset + self.grid_size // 2\\r\\n if not pink:\\r\\n pg.draw.line(DISP, Colors.colors['BLACK'], start_pos,end_pos, self.width + 2 * offset) \\r\\n else:\\r\\n pg.draw.line(DISP, Colors.colors['PINK'], start_pos,end_pos, self.width + 2 * offset)\",\n \"def _format_apply(\\n self, patch_kw, lonlim, latlim, boundinglat,\\n lonlines, latlines, latmax, lonarray, latarray\\n ):\\n import cartopy.feature as cfeature\\n import cartopy.crs as ccrs\\n from cartopy.mpl import gridliner\\n\\n # Initial gridliner object, which ProPlot passively modifies\\n # TODO: Flexible formatter?\\n if not self._gridliners:\\n gl = self.gridlines(zorder=2.5) # below text only\\n gl._axes_domain = _axes_domain.__get__(gl) # apply monkey patches\\n gl._add_gridline_label = _add_gridline_label.__get__(gl)\\n gl.xlines = False\\n gl.ylines = False\\n try:\\n lonformat = gridliner.LongitudeFormatter # newer\\n latformat = gridliner.LatitudeFormatter\\n except AttributeError:\\n lonformat = gridliner.LONGITUDE_FORMATTER # older\\n latformat = gridliner.LATITUDE_FORMATTER\\n gl.xformatter = lonformat\\n gl.yformatter = latformat\\n gl.xlabels_top = False\\n gl.xlabels_bottom = False\\n gl.ylabels_left = False\\n gl.ylabels_right = False\\n\\n # Projection extent\\n # NOTE: They may add this as part of set_xlim and set_ylim in future\\n # See: https://github.com/SciTools/cartopy/blob/master/lib/cartopy/mpl/geoaxes.py#L638 # noqa\\n # WARNING: The set_extent method tries to set a *rectangle* between\\n # the *4* (x,y) coordinate pairs (each corner), so something like\\n # (-180,180,-90,90) will result in *line*, causing error!\\n proj = self.projection.proj4_params['proj']\\n north = isinstance(self.projection, (\\n ccrs.NorthPolarStereo, projs.NorthPolarGnomonic,\\n projs.NorthPolarAzimuthalEquidistant,\\n projs.NorthPolarLambertAzimuthalEqualArea))\\n south = isinstance(self.projection, (\\n ccrs.SouthPolarStereo, projs.SouthPolarGnomonic,\\n projs.SouthPolarAzimuthalEquidistant,\\n projs.SouthPolarLambertAzimuthalEqualArea))\\n if north or south:\\n if (lonlim is not None or latlim is not None):\\n _warn_proplot(\\n f'{proj!r} extent is controlled by \\\"boundinglat\\\", '\\n f'ignoring lonlim={lonlim!r} and latlim={latlim!r}.'\\n )\\n if self._boundinglat is None:\\n if isinstance(self.projection, projs.NorthPolarGnomonic):\\n boundinglat = 30\\n elif isinstance(self.projection, projs.SouthPolarGnomonic):\\n boundinglat = -30\\n else:\\n boundinglat = 0\\n if boundinglat is not None and boundinglat != self._boundinglat:\\n eps = 1e-10 # bug with full -180, 180 range when lon_0 != 0\\n lat0 = (90 if north else -90)\\n lon0 = self.projection.proj4_params.get('lon_0', 0)\\n extent = [lon0 - 180 + eps,\\n lon0 + 180 - eps, boundinglat, lat0]\\n self.set_extent(extent, crs=ccrs.PlateCarree())\\n self._boundinglat = boundinglat\\n else:\\n if boundinglat is not None:\\n _warn_proplot(\\n f'{proj!r} extent is controlled by \\\"lonlim\\\" and \\\"latlim\\\", '\\n f'ignoring boundinglat={boundinglat!r}.'\\n )\\n if lonlim is not None or latlim is not None:\\n lonlim = lonlim or [None, None]\\n latlim = latlim or [None, None]\\n lonlim, latlim = [*lonlim], [*latlim]\\n lon_0 = self.projection.proj4_params.get('lon_0', 0)\\n if lonlim[0] is None:\\n lonlim[0] = lon_0 - 180\\n if lonlim[1] is None:\\n lonlim[1] = lon_0 + 180\\n eps = 1e-10 # bug with full -180, 180 range when lon_0 != 0\\n lonlim[0] += eps\\n if latlim[0] is None:\\n latlim[0] = -90\\n if latlim[1] is None:\\n latlim[1] = 90\\n extent = [*lonlim, *latlim]\\n self.set_extent(extent, crs=ccrs.PlateCarree())\\n\\n # Draw gridlines, manage them with one custom gridliner generated\\n # by ProPlot, user may want to use griliner API directly\\n gl = self._gridliners[0]\\n # Collection props, see GoeAxes.gridlines() source code\\n kw = rc.fill({\\n 'alpha': 'geogrid.alpha',\\n 'color': 'geogrid.color',\\n 'linewidth': 'geogrid.linewidth',\\n 'linestyle': 'geogrid.linestyle',\\n }, context=True)\\n gl.collection_kwargs.update(kw)\\n # Grid locations\\n eps = 1e-10\\n if lonlines is not None:\\n if len(lonlines) == 0:\\n gl.xlines = False\\n else:\\n gl.xlines = True\\n gl.xlocator = mticker.FixedLocator(lonlines)\\n if latlines is not None:\\n if len(latlines) == 0:\\n gl.ylines = False\\n else:\\n gl.ylines = True\\n if latlines[0] == -90:\\n latlines[0] += eps\\n if latlines[-1] == 90:\\n latlines[-1] -= eps\\n gl.ylocator = mticker.FixedLocator(latlines)\\n # Grid label toggling\\n # Issue warning instead of error!\\n if not isinstance(self.projection, (ccrs.Mercator, ccrs.PlateCarree)):\\n if latarray is not None and any(latarray):\\n _warn_proplot(\\n 'Cannot add gridline labels to cartopy '\\n f'{type(self.projection).__name__} projection.'\\n )\\n latarray = [0] * 4\\n if lonarray is not None and any(lonarray):\\n _warn_proplot(\\n 'Cannot add gridline labels to cartopy '\\n f'{type(self.projection).__name__} projection.'\\n )\\n lonarray = [0] * 4\\n if latarray is not None:\\n gl.ylabels_left = latarray[0]\\n gl.ylabels_right = latarray[1]\\n if lonarray is not None:\\n gl.xlabels_bottom = lonarray[2]\\n gl.xlabels_top = lonarray[3]\\n\\n # Geographic features\\n # WARNING: Seems cartopy features can't be updated!\\n # See: https://scitools.org.uk/cartopy/docs/v0.14/_modules/cartopy/feature.html#Feature # noqa\\n # Change the _kwargs property also does *nothing*\\n # WARNING: Changing linewidth is impossible with cfeature. Bug?\\n # See: https://stackoverflow.com/questions/43671240/changing-line-width-of-cartopy-borders # noqa\\n # TODO: Editing existing natural features? Creating natural features\\n # at __init__ time and hiding them?\\n # NOTE: The natural_earth_shp method is deprecated, use add_feature.\\n # See: https://cartopy-pelson.readthedocs.io/en/readthedocs/whats_new.html # noqa\\n # NOTE: The e.g. cfeature.COASTLINE features are just for convenience,\\n # hi res versions. Use cfeature.COASTLINE.name to see how it can be\\n # looked up with NaturalEarthFeature.\\n reso = rc['reso']\\n if reso not in ('lo', 'med', 'hi'):\\n raise ValueError(f'Invalid resolution {reso!r}.')\\n reso = {\\n 'lo': '110m',\\n 'med': '50m',\\n 'hi': '10m',\\n }.get(reso)\\n features = {\\n 'land': ('physical', 'land'),\\n 'ocean': ('physical', 'ocean'),\\n 'lakes': ('physical', 'lakes'),\\n 'coast': ('physical', 'coastline'),\\n 'rivers': ('physical', 'rivers_lake_centerlines'),\\n 'borders': ('cultural', 'admin_0_boundary_lines_land'),\\n 'innerborders': ('cultural', 'admin_1_states_provinces_lakes'),\\n }\\n for name, args in features.items():\\n # Get feature\\n if not rc[name]: # toggled\\n continue\\n if getattr(self, '_' + name, None): # already drawn\\n continue\\n feat = cfeature.NaturalEarthFeature(*args, reso)\\n # For 'lines', need to specify edgecolor and facecolor\\n # See: https://github.com/SciTools/cartopy/issues/803\\n kw = rc.category(name) # do not omit uncached props\\n if name in ('coast', 'rivers', 'borders', 'innerborders'):\\n kw['edgecolor'] = kw.pop('color')\\n kw['facecolor'] = 'none'\\n else:\\n kw['linewidth'] = 0\\n if name in ('ocean',):\\n kw['zorder'] = 0.5 # below everything!\\n self.add_feature(feat, **kw)\\n setattr(self, '_' + name, feat)\\n\\n # Update patch\\n kw_face = rc.fill({\\n 'facecolor': 'geoaxes.facecolor',\\n 'alpha': 'geoaxes.facealpha',\\n }, context=True)\\n kw_edge = rc.fill({\\n 'edgecolor': 'geoaxes.edgecolor',\\n 'linewidth': 'geoaxes.linewidth',\\n }, context=True)\\n kw_face.update(patch_kw or {})\\n self.background_patch.update(kw_face)\\n self.outline_patch.update(kw_edge)\",\n \"def SimpleReferenceGrid(min_x,min_y,max_x,max_y,x_divisions,y_divisions,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.15,yoff=-0.04,\\n label_type=None,shapes_name=\\\"Grid\\\"):\\n\\n shps=gview.GvShapes(name=shapes_name)\\n gview.undo_register( shps )\\n shps.add_field('position','string',20)\\n\\n if os.name == 'nt':\\n font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n else:\\n #font=\\\"-adobe-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*\\\"\\n #font=\\\"-urw-helvetica-medium-r-normal-*-9-*-*-*-p-*-iso8859-2\\\"\\n font=\\\"-adobe-helvetica-medium-r-normal-*-8-*-*-*-p-*-iso10646-1\\\"\\n #font=\\\"-misc-fixed-medium-r-*-*-9-*-*-*-*-*-*-*\\\"\\n\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n hspc=(max_x-min_x)/x_divisions\\n vspc=(max_y-min_y)/y_divisions\\n\\n for hval in numpy.arange(min_x,max_x+hspc/100.0,hspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(hval,max_y,0,0)\\n nshp.set_node(hval,min_y,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(hval,min_y+lyoff)\\n pshp.set_property('position',\\\"%.1f\\\" % hval)\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,max_y+vspc/100.0,vspc):\\n nshp=gview.GvShape(type=gview.GVSHAPE_LINE)\\n nshp.set_node(min_x,vval,0,0)\\n nshp.set_node(max_x,vval,0,1)\\n shps.append(nshp)\\n pshp=gview.GvShape(type=gview.GVSHAPE_POINT)\\n pshp.set_node(min_x+lxoff,vval)\\n pshp.set_property('position',\\\"%.1f\\\" % vval)\\n shps.append(pshp)\\n\\n cstr=gvogrfs.gv_to_ogr_color(color)\\n if len(cstr) < 9:\\n cstr=cstr+\\\"FF\\\"\\n clstr=str(color[0])+' '+str(color[1])+' '+str(color[2])+' '+str(color[3])\\n\\n layer=gview.GvShapesLayer(shps)\\n layer.set_property('_line_color',clstr)\\n layer.set_property('_point_color',clstr)\\n # Set antialias property so that lines look nice\\n # when rotated.\\n layer.set_property('_gl_antialias','1')\\n layer.set_property('_gv_ogrfs_point',\\n 'LABEL(t:{position},f:\\\"'+font+'\\\",c:'+cstr+')')\\n layer.set_read_only(True) \\n\\n return layer\",\n \"def draw_grids(self, grids):\\n\\n list_of_grids = is_grids_list_of_grids(grids=grids)\\n\\n if not list_of_grids:\\n\\n plt.plot(\\n np.asarray(grids)[:, 1],\\n np.asarray(grids)[:, 0],\\n c=self.colors[0],\\n lw=self.width,\\n ls=self.style,\\n )\\n\\n else:\\n\\n color = itertools.cycle(self.colors)\\n\\n for grid in grids:\\n\\n if not None in grid:\\n if len(grid) != 0:\\n plt.plot(\\n np.asarray(grid)[:, 1],\\n np.asarray(grid)[:, 0],\\n c=next(color),\\n lw=self.width,\\n ls=self.style,\\n )\",\n \"def drawLines(\\n self,\\n num_columns,\\n num_rows,\\n pan_x,\\n pan_y,\\n x_offset,\\n y_offset,\\n spacing\\n ):\\n\\n # draw vertical lines\\n for line in range(-num_columns, num_columns):\\n line *= spacing\\n grid_number = pan_x - x_offset - line\\n\\n self.__finalizeGridLineOpacity(grid_number)\\n\\n GL.glBegin(GL.GL_LINES)\\n GL.glVertex3f(((line + x_offset) / self.aspect_ratio), num_rows * spacing, self.GRID_DEPTH)\\n GL.glVertex3f(((line + x_offset) / self.aspect_ratio), -num_rows * spacing, self.GRID_DEPTH)\\n GL.glEnd()\\n # draw horizontal lines\\n for line in range(-num_rows, num_rows):\\n\\n line *= spacing\\n grid_number = pan_y + line - y_offset\\n self.__finalizeGridLineOpacity(grid_number)\\n\\n GL.glBegin(GL.GL_LINES)\\n GL.glVertex3f((num_columns * spacing) / self.aspect_ratio, line - y_offset, self.GRID_DEPTH)\\n GL.glVertex3f((-num_columns * spacing) / self.aspect_ratio, line - y_offset, self.GRID_DEPTH)\\n GL.glEnd()\",\n \"def draw_grid(self):\\n buf = self.__hbar\\n for rInd in range(self.row):\\n line = '\\\\t|'\\n for cInd in range(self.col):\\n this = ((rInd * self.col) + cInd)\\n cell = self.get_cell(this)\\n if not cell:\\n line += '%s|' % ' '.center(5)\\n else:\\n if this == self.new_cell:\\n tmp = green(str(cell).center(5))\\n else:\\n tmp = str(cell).center(5)\\n line += '%s|' % tmp\\n buf += line + '\\\\n' + self.__hbar\\n print(buf)\",\n \"def make_grid(self):\\n for k in range(0, NUM + 1):\\n self.create_line(k * UNIT, 0, k * UNIT, SIZE, width=THICKNESS)\\n self.create_line(0, k * UNIT, SIZE, k * UNIT, width=THICKNESS)\",\n \"def __finalizeGridLineOpacity(self, grid_number, multiplier=2):\\n opacity_list = [5, 10, 25, 50, 100, 500]\\n opacity = self.getGridLineOpacity()\\n if grid_number == 0.0:\\n GL.glLineWidth(2)\\n GL.glColor4f(*self.getGridColor(), 1)\\n\\n else:\\n GL.glLineWidth(1)\\n for n in opacity_list:\\n if grid_number % n == 0:\\n opacity *= multiplier\\n GL.glColor4f(*self.getGridColor(), opacity)\",\n \"def render(self):\\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\\n print(''.join(map[i] for i in self.grid[0:3]))\\n print(''.join(map[i] for i in self.grid[3:6]))\\n print(''.join(map[i] for i in self.grid[6:9]))\\n print('====')\",\n \"def render(self):\\n map = {0:'.', 1:'x', 2:'o'} # grid label vs how to plot\\n print(''.join(map[i] for i in self.grid[0:3]))\\n print(''.join(map[i] for i in self.grid[3:6]))\\n print(''.join(map[i] for i in self.grid[6:9]))\\n print('====')\",\n \"def grid_init(self):\\n # draw.line(surface, color, start_pos, end_pos, width/thickness)\\n pygame.draw.line(\\n self.game_screen,\\n GameData.line_color,\\n (0, GameData.square_size),\\n (GameData.screen_dim, GameData.square_size),\\n GameData.line_width\\n )\\n # # 2 horizontal\\n pygame.draw.line(\\n self.game_screen,\\n GameData.line_color,\\n (0, 2 * GameData.square_size),\\n (GameData.screen_dim,2 * GameData.square_size),\\n GameData.line_width\\n )\\n\\n # # 1 vertical\\n pygame.draw.line(\\n self.game_screen,\\n GameData.line_color,\\n (GameData.square_size, 0),\\n (GameData.square_size, GameData.screen_dim),\\n GameData.line_width\\n )\\n # # 2 vertical\\n pygame.draw.line(\\n self.game_screen,\\n GameData.line_color,\\n (2 * GameData.square_size, 0),\\n (2 * GameData.square_size, GameData.screen_dim),\\n GameData.line_width)\",\n \"def draw_grid(self, verbosity=0):\\n log.debug(\\\"Drawing grid\\\")\\n (x0, y0) = self.origin\\n color = (191, 191, 191)\\n\\n (w, h) = self.surface.get_size()\\n\\n i = x0\\n while True:\\n (x, ignore) = self.map_to_screen((i, 0))\\n if x > w:\\n break\\n pygame.draw.line(self.surface, color, (x, 0), (x, h), 1)\\n i += 10\\n\\n j = y0\\n while True:\\n (ignore, y) = self.map_to_screen((0, j))\\n if y > h:\\n break\\n pygame.draw.line(self.surface, color, (0, y), (w, y), 1)\\n j -= 10\",\n \"def separator_line(parent, dims, flag, packvalue=Tk.TOP, bgcol='#d9d9d9'):\\n lincanvas = Tk.Canvas(parent, height=dims[1], width=dims[0])\\n lincanvas.config(bg=bgcol)\\n try:\\n lincanvas.pack(side=packvalue, fill=Tk.BOTH, expand=Tk.YES)\\n except:\\n return None\\n if flag:\\n lincanvas.create_line(dims[2], dims[1]/2, dims[0] - dims[2],\\n dims[1]/2)\\n else:\\n lincanvas.create_line(dims[0]/2, dims[2], dims[0]/2,\\n dims[1] - dims[2])\\n return lincanvas\",\n \"def draw(self, special_cases={}):\\n # Order and direction of axis chosen for intuitive controls.\\n # Current setup mimics a grid of grids: the outer rows and columns are the\\n # z and w dimensions, the inner ones are y and x (respectively).\\n\\n # Example 3x3x3x3\\n # ... ... ...\\n # ... ... ... \\n # ... ... ... z\\n # +\\n # ...y... ... |\\n # ...+... ... |\\n # ...|... ... |\\n # -+x\\n # ... ... ...\\n # ... ... ...\\n # ... ... ...\\n # ----------+ w\\n output = []\\n for z in reversed(range(self.size[2])):\\n for y in reversed(range(self.size[1])):\\n for w in reversed(range(self.size[3])):\\n for x in range(self.size[0]):\\n cell = (x, y, z, w)\\n o = self.get_object_at(cell)\\n if o:\\n output.append(o.char)\\n elif cell in special_cases:\\n output.append(special_cases[cell])\\n else:\\n output.append('.')\\n output.append(' ')\\n output.append('\\\\n')\\n output.append('\\\\n')\\n\\n return ''.join(output)\",\n \"def test_grdimage_over_dateline(xrgrid):\\n fig = Figure()\\n assert xrgrid.gmt.registration == 0 # gridline registration\\n xrgrid.gmt.gtype = 1 # geographic coordinate system\\n fig.grdimage(grid=xrgrid, region=\\\"g\\\", projection=\\\"A0/0/1c\\\")\\n return fig\",\n \"def drawAGrid(self, DeltaX=10, DeltaY=10, Height=200, Width=200, CenterX=0, CenterY=0, Pen=None, Brush=None,\\n SubGrid=None):\\n height = self.scene.sceneRect().height() if Height is None else Height\\n width = self.scene.sceneRect().width() if Width is None else Width\\n left = self.scene.sceneRect().left() if CenterX is None else (CenterX - width / 2.0)\\n right = self.scene.sceneRect().right() if CenterX is None else (CenterX + width / 2.0)\\n top = self.scene.sceneRect().top() if CenterY is None else (CenterY - height / 2.0)\\n bottom = self.scene.sceneRect().bottom() if CenterY is None else (CenterY + height / 2.0)\\n Dx = DeltaX\\n Dy = DeltaY\\n pen = qtg.QPen() if Pen is None else Pen\\n\\n # make the background rectangle first\\n if Brush is not None:\\n rect = qtw.QGraphicsRectItem(left, top, width, height)\\n rect.setBrush(Brush)\\n rect.setPen(pen)\\n self.scene.addItem(rect)\\n # draw the vertical grid lines\\n x = left\\n while x <= right:\\n lVert = qtw.QGraphicsLineItem(x, top, x, bottom)\\n lVert.setPen(pen)\\n self.scene.addItem(lVert)\\n x += Dx\\n # draw the horizontal grid lines\\n y = top\\n while y <= bottom:\\n lHor = qtw.QGraphicsLineItem(left, y, right, y)\\n lHor.setPen(pen)\\n self.scene.addItem(lHor)\\n y += Dy\",\n \"def make_line(self, name, selection, prescale, postscale, **kwargs):\\n # Only create the line with positive pre- and postscales\\n # You can disable each line by setting either to a negative value\\n if prescale > 0 and postscale > 0:\\n line = StrippingLine(\\n name,\\n selection=selection,\\n prescale=prescale,\\n postscale=postscale,\\n **kwargs\\n )\\n self.registerLine(line)\\n return line\\n else:\\n return False\",\n \"def draw_grid(grid):\\n rows = grid.shape[0]\\n cols = grid.shape[1]\\n for row in range(rows):\\n for col in range(cols):\\n if grid[row, col] == 0: # empty\\n sys.stdout.write(\\\" . \\\")\\n elif grid[row, col] == 1: # path\\n sys.stdout.write(\\\" X \\\")\\n elif grid[row, col] == 2:\\n sys.stdout.write(\\\" O \\\")\\n else:\\n sys.stdout.write(\\\" @ \\\")\\n\\n if col % cols == cols - 1:\\n sys.stdout.write(\\\"\\\\n\\\")\",\n \"def DrawGrid(self, count):\\n for i in range(0, self.width, self.incr):\\n self.canvas.create_line(i, 100, i, 700, fill = \\\"#696969\\\", width = 1)\\n for i in range(100, 800, 100):\\n self.canvas.create_line(0, i, self.width, i, fill = \\\"#696969\\\", width = 1)\\n self.canvas.create_rectangle(self.incr * 4, self.height - self.incr * 3.5,\\n self.width - self.incr * 4, self.height, fill = \\\"black\\\", width = 3)\\n for i in range(int(self.height - self.incr * 3.5), self.height, int(self.incr / 4)):\\n self.canvas.create_line(self.incr * 4, i, self.width - self.incr * 4,\\n i, fill = \\\"#696969\\\", width = 1)\\n for i in range(self.incr * 4, self.width - self.incr * 4 + 1, int(self.incr / 4)):\\n self.canvas.create_line(i, self.height - self.incr * 3.5, i, self.height,\\n fill = \\\"#696969\\\", width = 1)\",\n \"def DrawSpline(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawSpline(*args, **kwargs)\",\n \"def draw_x(row, column):\\n\\n # adjusting the column and rows to fit the grid\\n if column != 1:\\n column *= 2\\n column -= 1\\n\\n if row != 1:\\n row *= 2\\n row -= 1\\n\\n # calculating the center position of the circle\\n x_center = row * 100\\n y_center = column * 77\\n\\n radius = 40\\n\\n # from top left to bottom right\\n x0 = x_center - radius\\n y0 = y_center - radius\\n\\n x1 = x_center + radius\\n y1 = y_center + radius\\n\\n canvas.create_line(x0, y0, x1, y1, fill=\\\"blue\\\")\\n\\n # from bottom left to top right\\n x2 = x_center + radius - 80\\n y2 = y_center + radius\\n\\n x3 = x_center - radius + 80\\n y3 = y_center - radius\\n\\n canvas.create_line(x2, y2, x3, y3, fill=\\\"blue\\\")\\n\\n return None\",\n \"def draw_line(tick_length, tick_label=''):\\n line = \\\"_\\\" * tick_length\\n if tick_label:\\n line += ' ' + tick_label\\n print(line)\",\n \"def is_gridlines_visible(self):\\n return self.container['is_gridlines_visible']\",\n \"def tickmarks(major=-10, minor=True, logbase=0, format=unicode_number):\\n\\n if not callable(format):\\n tmp = format\\n format = lambda x: tmp % x\\n format.func_name = tmp\\n\\n def linear_tickmarks(low, high):\\n if low >= high:\\n raise ValueError, \\\"To compute tick-marks, 'low' must be lower than 'high'.\\\"\\n\\n major_ticks = _compute_majorticks(low, high, major, format)\\n if minor:\\n minor_ticks = _compute_minorticks(low, high, major_ticks)\\n else:\\n minor_ticks = {}\\n minor_ticks.update(major_ticks)\\n return minor_ticks\\n\\n def logarithmic_tickmarks(low, high):\\n if low >= high:\\n raise ValueError, \\\"To compute tick-marks, 'low' must be lower than 'high'.\\\"\\n\\n major_ticks = _compute_logmajorticks(low, high, logbase, major, format)\\n if minor:\\n minor_ticks = _compute_logminorticks(low, high, logbase)\\n else:\\n minor_ticks = {}\\n minor_ticks.update(major_ticks)\\n return minor_ticks\\n\\n if logbase == 0: output = linear_tickmarks\\n else: output = logarithmic_tickmarks\\n\\n output.func_name = \\\"tickmarks(major=%d, minor=%s, logbase=%d, format=%s)\\\" % (major, repr(minor), logbase, format.func_name)\\n return output\",\n \"def create_grid(self):\\n\\n # If called when a grid already exists create a new grid\\n if self.grid:\\n self.grid = []\\n\\n grid_pen = QPen(QColor(215, 215, 215), 1)\\n w = 10000\\n h = 10000\\n self.addLine(-10000, 0, 10000, 0, QPen(QColor(0, 0, 0), 2))\\n self.addLine(0, -10000, 0, 10000, QPen(QColor(0, 0, 0), 2))\\n\\n w = int(w / self.grid_spacing) * self.grid_spacing\\n h = int(h / self.grid_spacing) * self.grid_spacing\\n for i in range(-w, w, self.grid_spacing):\\n if i == 0:\\n pass\\n else:\\n line = self.addLine(-w, i, w, i, grid_pen)\\n line.setZValue(-1)\\n self.grid.append(line)\\n for i in range(-h, h, self.grid_spacing):\\n if i == 0:\\n pass\\n else:\\n line = self.addLine(i, -h, i, h, grid_pen)\\n line.setZValue(-1)\\n self.grid.append(line)\\n\\n self.grid_built = True\",\n \"def grid_00():\\n plot = {\\\"Walls\\\": [\\\"N\\\", \\\"W\\\"], \\\"TARDIS\\\": False, \\\"Transmat\\\": False,\\n \\\"Plot\\\": \\\"\\\\nThe writings on some of these blueprints look Gallifreyan. Could it be the Master?\\\\n\\\"\\n \\\"Is he crazy enough to help the DALEKS and others build a TARDIS?\\\\n\\\"\\n \\\"The room continues to the SOUTH and EAST.\\\\n\\\"}\\n return plot\",\n \"def test_sizergrid():\\n regular_grid(8, 3)\\n mpl.show()\",\n \"def linestyles(colors=_colors, lines=_lines,\\n markers=_markers, hollow_styles=_marker_types):\\n return linestyle_generator(colors, lines, markers, hollow_styles)\",\n \"def draw_grid():\\r\\n screen.fill((0,0,0))\\r\\n pygame.draw.line(screen, (255,255,255),(WIDTH/3,0),(WIDTH/3,HEIGHT))\\r\\n pygame.draw.line(screen, (255,255,255),(2*WIDTH/3,0),(2*WIDTH/3,HEIGHT))\\r\\n pygame.draw.line(screen, (255,255,255),(0,HEIGHT/3),(WIDTH,HEIGHT/3))\\r\\n pygame.draw.line(screen, (255,255,255),(0,2*HEIGHT/3),(WIDTH,2*HEIGHT/3))\",\n \"def _line(x,m,c):\\n return m*x+c\",\n \"def _line(x,m,c):\\n return m*x+c\",\n \"def drawLines_region(t0, t1, t2, t3):\\r\\n t0.pd()\\r\\n t1.pd()\\r\\n t2.pd()\\r\\n t3.pd()\\r\\n t0.pencolor(\\\"blue\\\")\\r\\n t0.pensize(3)\\r\\n t1.pensize(3)\\r\\n t2.pensize(3)\\r\\n t3.pensize(3)\\r\\n t1.pencolor(\\\"red\\\")\\r\\n t2.pencolor(\\\"green\\\")\\r\\n t3.pencolor(\\\"gold\\\")\\r\\n t0.rt(90)\\r\\n t1.rt(90)\\r\\n t2.rt(90)\\r\\n t3.rt(90)\\r\\n t0.fd(70)\\r\\n t1.fd(70)\\r\\n t2.fd(70)\\r\\n t3.fd(70)\",\n \"def plot_nicer(ax, grid=False):\\r\\n alpha=0.7\\r\\n for spine in ax.spines.values():\\r\\n spine.set_color(\\\"white\\\")\\r\\n # Make text grey\\r\\n plt.setp(ax.get_yticklabels(), alpha=alpha)\\r\\n plt.setp(ax.get_xticklabels(), alpha=alpha)\\r\\n ax.set_xlabel(ax.get_xlabel(), alpha=alpha)\\r\\n ax.set_ylabel(ax.get_ylabel(), alpha=alpha)\\r\\n ax.set_title(ax.get_title(), alpha=alpha)\\r\\n if grid:\\r\\n ax.grid(\\\"lightgrey\\\")\\r\\n ax.tick_params(axis=u'y', which=u'both',color=\\\"#676767\\\")\\r\\n ax.tick_params(axis=u'x', which=u'both',color=\\\"#676767\\\")\",\n \"def line_graph():\\r\\n #create the data in an array\\r\\n xval = np.arange(0,6,(np.pi*(1./10)))\\r\\n yval = np.cos(xval)\\r\\n data = np.array([xval,yval])\\r\\n data = data.transpose()\\r\\n y = np.arange(-1,1.5,0.5)\\r\\n #convert the data to a pd DataFrame\\r\\n df = pd.DataFrame(data,columns=[\\\"x\\\",\\\"y\\\"])\\r\\n #tell the DataFrame to plot the data\\r\\n ax = df.plot(x=\\\"x\\\",y=\\\"y\\\",label=\\\"0\\\",ylim=(-1,1),yticks=y,title=\\\"Cosine Approximated at Intervals of 1/(10pi)\\\")\\r\\n ax.set(xlabel=\\\"\\\",ylabel=\\\"\\\")\\r\\n\\t#get the figure from the axes and save it\\r\\n fig = ax.get_figure()\\r\\n fig.savefig(\\\"my_line_graph.png\\\")\",\n \"def get_gridline_values(self, x=None, y=None):\\n if (x and y) or not (x or y):\\n print('[error] use either x or y keyword arguments '\\n 'to define the gridline position')\\n return\\n elif x:\\n return self.get_vertical_gridline_values(x)\\n elif y:\\n return self.get_horizontal_gridline_values(y)\",\n \"def DrawSpline(*args, **kwargs):\\n return _gdi_.DC_DrawSpline(*args, **kwargs)\",\n \"def test_show_gridlines(self):\\n\\n def are_gridlines_hidden():\\n res = self.spreadsheet.fetch_sheet_metadata()\\n sheets = res[\\\"sheets\\\"]\\n sheet = utils.finditem(\\n lambda x: x[\\\"properties\\\"][\\\"sheetId\\\"] == self.sheet.id,\\n sheets,\\n )\\n return (\\n sheet[\\\"properties\\\"]\\n .get(\\\"gridProperties\\\", {})\\n .get(\\\"hideGridlines\\\", False)\\n )\\n\\n hidden_before = are_gridlines_hidden()\\n hidden_before_property = self.sheet.is_gridlines_hidden\\n\\n self.sheet.hide_gridlines()\\n self.sheet.show_gridlines()\\n\\n hidden_after = are_gridlines_hidden()\\n hidden_after_property = self.sheet.is_gridlines_hidden\\n\\n self.assertFalse(hidden_before)\\n self.assertFalse(hidden_before_property)\\n self.assertFalse(hidden_after)\\n self.assertFalse(hidden_after_property)\",\n \"def draw(self):\\n return group()\",\n \"def draw(iiter):\\n from matplotlib import pyplot as plt\\n fig = plt.gcf()\\n fig.canvas.draw()\",\n \"def _set_axes(self):\\n self += helper.line(stroke=\\\"black\\\", x1=self.__dict__['x'], x2=self.__dict__['x'], y1=0, y2=self.__dict__['y']*2)\\n self += helper.line(stroke=\\\"black\\\", x1=0, x2=self.__dict__['x']*2, y1=self.__dict__['y'], y2=self.__dict__['y'])\",\n \"def my_simple_line(master, name, r, c, rsp, csp, px, py) -> object:\\n line = tk.Label(master=master, text=name, anchor='w')\\n line.grid(row=r, column=c, rowspan=rsp, columnspan=csp, padx=px, pady=py)\\n return line\",\n \"def get_lines(self) -> list[str]:\\n\\n chars = self.get_char(\\\"border\\\")\\n assert isinstance(chars, list)\\n left_border, _, right_border, _ = chars\\n\\n lines = super().get_lines()\\n last_line = lines.pop()\\n\\n for line in range(256 // self.grid_cols):\\n buff = left_border\\n\\n for num in range(self.grid_cols):\\n col = str(line * self.grid_cols + num)\\n if col == \\\"0\\\":\\n buff += \\\" \\\"\\n continue\\n\\n buff += self._layer_functions[self.layer](f\\\"{col:>3}\\\", col) + \\\" \\\"\\n\\n buff = buff[:-1]\\n lines.append(buff + \\\"\\\" + right_border)\\n\\n lines.append(last_line)\\n\\n return lines\",\n \"def preparePlot(xticks, yticks, figsize=(10.5, 6), hideLabels=False, gridColor='#999999',\\n gridWidth=1.0):\\n plt.close()\\n fig, ax = plt.subplots(figsize=figsize, facecolor='white', edgecolor='white')\\n ax.axes.tick_params(labelcolor='#999999', labelsize='10')\\n for axis, ticks in [(ax.get_xaxis(), xticks), (ax.get_yaxis(), yticks)]:\\n axis.set_ticks_position('none')\\n axis.set_ticks(ticks)\\n axis.label.set_color('#999999')\\n if hideLabels: axis.set_ticklabels([])\\n plt.grid(color=gridColor, linewidth=gridWidth, linestyle='-')\\n map(lambda position: ax.spines[position].set_visible(False), ['bottom', 'top', 'left', 'right'])\\n return fig, ax\",\n \"def preparePlot(xticks, yticks, figsize=(10.5, 6), hideLabels=False, gridColor='#999999',\\n gridWidth=1.0):\\n plt.close()\\n fig, ax = plt.subplots(figsize=figsize, facecolor='white', edgecolor='white')\\n ax.axes.tick_params(labelcolor='#999999', labelsize='10')\\n for axis, ticks in [(ax.get_xaxis(), xticks), (ax.get_yaxis(), yticks)]:\\n axis.set_ticks_position('none')\\n axis.set_ticks(ticks)\\n axis.label.set_color('#999999')\\n if hideLabels: axis.set_ticklabels([])\\n plt.grid(color=gridColor, linewidth=gridWidth, linestyle='-')\\n map(lambda position: ax.spines[position].set_visible(False), ['bottom', 'top', 'left', 'right'])\\n return fig, ax\",\n \"def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \\n #fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size) \\n \\n \\n \\n #fig.show()\",\n \"def draw(self, ctx):\\n self.set_size(self.width, self.available_height) \\n #Drawing cell lines\\n for i in range(0, (max(self.available_width,int(self.width)) / self.cell_width) + 1):\\n ctx.move_to(i * self.cell_width, 0)\\n ctx.line_to(i * self.cell_width, self.available_height)\\n ctx.set_line_width(1)\\n red = float(self.get_style().fg[gtk.STATE_INSENSITIVE].red) / 65535\\n green = float(self.get_style().fg[gtk.STATE_INSENSITIVE].green) / 65535\\n blue = float(self.get_style().fg[gtk.STATE_INSENSITIVE].blue) / 65535\\n ctx.set_source_rgba(red, green, blue, 0.3)\\n ctx.stroke()\\n greatest = self.calculate_greatest() \\n # Drawing scale lines\\n step = greatest / 5\\n ctx.save()\\n ctx.set_dash([5],5)\\n for i in range(int(step), int(greatest),5):\\n ctx.move_to(0, self.available_height - (self.available_height - 20) * i / greatest)\\n ctx.line_to(max(self.available_width,int(self.width)), self.available_height - (self.available_height - 20) * i / greatest)\\n ctx.set_source_rgba(red,green,blue,0.3)\\n ctx.stroke()\\n\\n ctx.restore()\\n # Drawing the diagram\\n loadingCopy = copy.deepcopy(self.loading)\\n colorIndex = 0\\n loadingKeys = loadingCopy.keys()\\n loadingKeys.sort()\\n for key in loadingKeys:\\n while loadingCopy[key] != []:\\n x1, y1 = loadingCopy[key].pop(0)\\n if loadingCopy[key] != []:\\n x2, y2 = loadingCopy[key][0]\\n else:\\n x2 = self.duration\\n ctx.line_to (x1 * self.cell_width, self.available_height - (self.available_height - 20) * y1 / greatest)\\n ctx.line_to (x2 * self.cell_width, self.available_height - (self.available_height - 20) * y1 / greatest)\\n \\n ctx.set_line_width(2)\\n ctx.set_source_rgba(self.colors[colorIndex][0], self.colors[colorIndex][1], self.colors[colorIndex][2],0.5)\\n ctx.stroke()\\n colorIndex = (colorIndex + 1) % 11\",\n \"def testGridFloatingPoint(self):\\n self.chart.bottom.min = 0\\n self.chart.bottom.max = 8\\n self.chart.bottom.grid_spacing = 1\\n self.assertEqual(self.Param('chg'), '12.5,0,1,0')\\n self.chart.bottom.max = 3\\n self.assertEqual(self.Param('chg'), '33.3,0,1,0')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61834234","0.6008772","0.59259754","0.5909034","0.5832352","0.57928234","0.5755209","0.5727162","0.5662317","0.56454045","0.56073934","0.5587352","0.5586233","0.5584013","0.555687","0.5555793","0.5554617","0.5530118","0.55236983","0.5503275","0.55012906","0.54957783","0.54845685","0.5484549","0.5471476","0.54567254","0.54546314","0.5450836","0.54388446","0.54357946","0.54262793","0.54120314","0.53996056","0.53937215","0.53789335","0.53298694","0.5320529","0.5316353","0.5315512","0.5314142","0.53091717","0.5272829","0.52697426","0.5268316","0.5260338","0.52444106","0.5222303","0.5205119","0.5205071","0.5204286","0.51930964","0.5192876","0.51903355","0.51870286","0.51828325","0.5155056","0.5154425","0.51478684","0.51454234","0.51439464","0.51361513","0.51301336","0.5128534","0.5128534","0.5117136","0.51019365","0.5096427","0.50589234","0.50565904","0.505562","0.5054709","0.505188","0.5042999","0.5039763","0.5037317","0.50300026","0.5027925","0.50080574","0.50061643","0.5005323","0.49974477","0.4995157","0.49853176","0.49821723","0.49821723","0.49750644","0.4973823","0.495224","0.49426973","0.49367422","0.49345946","0.49228317","0.49195606","0.4918142","0.49141464","0.4906299","0.48979515","0.48979515","0.4894024","0.48906973","0.48900595"],"string":"[\n \"0.61834234\",\n \"0.6008772\",\n \"0.59259754\",\n \"0.5909034\",\n \"0.5832352\",\n \"0.57928234\",\n \"0.5755209\",\n \"0.5727162\",\n \"0.5662317\",\n \"0.56454045\",\n \"0.56073934\",\n \"0.5587352\",\n \"0.5586233\",\n \"0.5584013\",\n \"0.555687\",\n \"0.5555793\",\n \"0.5554617\",\n \"0.5530118\",\n \"0.55236983\",\n \"0.5503275\",\n \"0.55012906\",\n \"0.54957783\",\n \"0.54845685\",\n \"0.5484549\",\n \"0.5471476\",\n \"0.54567254\",\n \"0.54546314\",\n \"0.5450836\",\n \"0.54388446\",\n \"0.54357946\",\n \"0.54262793\",\n \"0.54120314\",\n \"0.53996056\",\n \"0.53937215\",\n \"0.53789335\",\n \"0.53298694\",\n \"0.5320529\",\n \"0.5316353\",\n \"0.5315512\",\n \"0.5314142\",\n \"0.53091717\",\n \"0.5272829\",\n \"0.52697426\",\n \"0.5268316\",\n \"0.5260338\",\n \"0.52444106\",\n \"0.5222303\",\n \"0.5205119\",\n \"0.5205071\",\n \"0.5204286\",\n \"0.51930964\",\n \"0.5192876\",\n \"0.51903355\",\n \"0.51870286\",\n \"0.51828325\",\n \"0.5155056\",\n \"0.5154425\",\n \"0.51478684\",\n \"0.51454234\",\n \"0.51439464\",\n \"0.51361513\",\n \"0.51301336\",\n \"0.5128534\",\n \"0.5128534\",\n \"0.5117136\",\n \"0.51019365\",\n \"0.5096427\",\n \"0.50589234\",\n \"0.50565904\",\n \"0.505562\",\n \"0.5054709\",\n \"0.505188\",\n \"0.5042999\",\n \"0.5039763\",\n \"0.5037317\",\n \"0.50300026\",\n \"0.5027925\",\n \"0.50080574\",\n \"0.50061643\",\n \"0.5005323\",\n \"0.49974477\",\n \"0.4995157\",\n \"0.49853176\",\n \"0.49821723\",\n \"0.49821723\",\n \"0.49750644\",\n \"0.4973823\",\n \"0.495224\",\n \"0.49426973\",\n \"0.49367422\",\n \"0.49345946\",\n \"0.49228317\",\n \"0.49195606\",\n \"0.4918142\",\n \"0.49141464\",\n \"0.4906299\",\n \"0.48979515\",\n \"0.48979515\",\n \"0.4894024\",\n \"0.48906973\",\n \"0.48900595\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78497,"cells":{"query":{"kind":"string","value":"Return a function that can be used to set standard tick marks."},"document":{"kind":"string","value":"def tickmarks(major=-10, minor=True, logbase=0, format=unicode_number):\n\n if not callable(format):\n tmp = format\n format = lambda x: tmp % x\n format.func_name = tmp\n\n def linear_tickmarks(low, high):\n if low >= high:\n raise ValueError, \"To compute tick-marks, 'low' must be lower than 'high'.\"\n\n major_ticks = _compute_majorticks(low, high, major, format)\n if minor:\n minor_ticks = _compute_minorticks(low, high, major_ticks)\n else:\n minor_ticks = {}\n minor_ticks.update(major_ticks)\n return minor_ticks\n\n def logarithmic_tickmarks(low, high):\n if low >= high:\n raise ValueError, \"To compute tick-marks, 'low' must be lower than 'high'.\"\n\n major_ticks = _compute_logmajorticks(low, high, logbase, major, format)\n if minor:\n minor_ticks = _compute_logminorticks(low, high, logbase)\n else:\n minor_ticks = {}\n minor_ticks.update(major_ticks)\n return minor_ticks\n\n if logbase == 0: output = linear_tickmarks\n else: output = logarithmic_tickmarks\n\n output.func_name = \"tickmarks(major=%d, minor=%s, logbase=%d, format=%s)\" % (major, repr(minor), logbase, format.func_name)\n return output"},"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 default_style(func):\n def wrapper(*args, **kwargs):\n fig = plt.figure(figsize=(18,18))\n sns.set_context(\"talk\", font_scale=0.9)\n plt.xlim(-3, 3)\n plt.tick_params(grid_alpha=0.2)\n func(*args, **kwargs)\n plt.clf()\n return wrapper","def create_tick_mark(\n fmin: float,\n fmax: float,\n *,\n amplitude: float | None = None,\n) -> float:\n return amplitude if amplitude is not None else max(abs(fmin), abs(fmax))","def py_apply_ticks(self, plot):\n if self.x_ticks is not None:\n plot.set_xticks(self.x_ticks)\n if self.x_labels is not None:\n plot.set_xticklabels(self.x_labels)\n if self.y_ticks is not None:\n plot.set_yticks(self.y_ticks)\n if self.y_labels is not None:\n plot.set_yticklabels(self.y_labels)","def update_ticks_format( axis, scale ):\n axis.set_major_formatter( ticker.FuncFormatter( lambda x,pos: \"%d\" % (x*scale+0.5)) )\n if linlog != 'linear':\n grid = np.arange(np.log10(sf/2))[2:]\n locs = 10**grid/scale_freq\n axis.set_major_locator(ticker.FixedLocator(locs))\n else:\n if scale == 1.0: # freq_cut \n multbin_major = 10\n multbin_minor = 1\n elif sf > 19000: # time_cut 5kHz ticks\n multbin_major = 5000/scale\n multbin_minor = multbin_major / 5\n else: # time_cut 1KHz ticks\n multbin_major = 1000/scale\n multbin_minor = multbin_major / 10\n axis.set_major_locator(ticker.MultipleLocator(multbin_major))\n axis.set_minor_locator(ticker.MultipleLocator(multbin_minor))","def _log_decade_ticks(ax,min_log,max_log,ax_set_func,num=None,**kw_ticks):\n if (num is None):\n num = max_log - min_log + 1\n ax_set_func(np.logspace(min_log, max_log, base=10, num=num))\n return tickAxisFont(ax=ax,**kw_ticks)","def set_axes_ticks(\n ax: object,\n xticks:Union[List, None]=None,\n xticks_str:Union[List, None]=None,\n xticks_pad:Union[List, None]=None,\n x_minor:Union[List, None] = None,\n x_rotation:float=0., \n major_length: float=3.0,\n minor_length: float=1.5,\n yticks:Union[List, None]=None,\n yticks_str:Union[List, None]=None, \n yticks_pad:Union[List, None]=None,\n y_minor:Union[List, None] = None,\n y_rotation:float=0., \n fontsize:int=8,\n): \n\n \n if yticks is not None:\n ax.set_yticks(yticks, yticks_str, fontsize=fontsize)\n if yticks_pad is not None:\n ylabels = ax.get_yticklabels()\n for i, tick in enumerate(ax.get_yaxis().get_major_ticks()):\n tick.set_pad(yticks_pad[i])\n if tick.get_pad() < 0:\n ax.get_yaxis().set_tick_params(direction=\"out\")\n tick.label1 = ylabels[i]\n ax.tick_params(axis='y', which='major', direction='out', length=major_length, labelrotation=y_rotation)\n if y_minor is not None:\n ax.set_yticks(y_minor, minor=True)\n ax.tick_params(axis='y', which='minor', direction='out', length=minor_length)\n if xticks is not None:\n ax.set_xticks(xticks, xticks_str, fontsize=8)\n if xticks_pad is not None:\n xlabels = ax.get_xticklabels()\n for i, tick in enumerate(ax.get_xaxis().get_major_ticks()):\n tick.set_pad(xticks_pad[i])\n tick.label1 = xlabels[i]\n ax.tick_params(axis='x', which='major', direction='out', length=major_length, labelrotation=x_rotation)\n if x_minor is not None:\n ax.set_xticks(x_minor, minor=True)\n ax.tick_params(axis='x', which='minor', direction='out', length=minor_length)","def set_axes_ticks(\n ax: object,\n xticks:Union[List, None]=None,\n xticks_str:Union[List, None]=None,\n xticks_pad:Union[List, None]=None,\n x_minor:Union[List, None] = None,\n x_rotation:float=0., \n major_length: float=3.0,\n minor_length: float=1.5,\n yticks:Union[List, None]=None,\n yticks_str:Union[List, None]=None, \n yticks_pad:Union[List, None]=None,\n y_minor:Union[List, None] = None,\n y_rotation:float=0., \n fontsize:int=8,\n): \n\n \n if yticks is not None:\n ax.set_yticks(yticks, yticks_str, fontsize=fontsize)\n if yticks_pad is not None:\n ylabels = ax.get_yticklabels()\n for i, tick in enumerate(ax.get_yaxis().get_major_ticks()):\n tick.set_pad(yticks_pad[i])\n if tick.get_pad() < 0:\n ax.tick_params(direction=\"out\") # reset direction\n tick.label1 = ylabels[i]\n ax.tick_params(axis='y', which='major', direction='out', length=major_length, labelrotation=y_rotation)\n if y_minor is not None:\n ax.set_yticks(y_minor, minor=True)\n ax.tick_params(axis='y', which='minor', direction='out', length=minor_length)\n if xticks is not None:\n ax.set_xticks(xticks, xticks_str, fontsize=8)\n if xticks_pad is not None:\n xlabels = ax.get_xticklabels()\n for i, tick in enumerate(ax.get_xaxis().get_major_ticks()):\n tick.set_pad(xticks_pad[i])\n tick.label1 = xlabels[i]\n ax.tick_params(axis='x', which='major', direction='out', length=major_length, labelrotation=x_rotation)\n if x_minor is not None:\n ax.set_xticks(x_minor, minor=True)\n ax.tick_params(axis='x', which='minor', direction='out', length=minor_length)","def tom_ticks(ax=None,num_major=4,num_minor=0,fontsize=g_font_label,**kwargs):\n ax = gca(ax)\n tick_axis_number(ax=ax,\n num_x_major=num_major,\n num_x_minor=num_minor,\n num_y_major=num_major,\n num_y_minor=num_minor,**kwargs)\n if (num_minor == 0):\n ax.tick_params(which='minor', right=False, left=False,top=False,\n bottom = False, axis = 'both')\n tickAxisFont(ax=ax,fontsize=fontsize)","def powerpoint_style(Axe_tick_size=15,Line_size=3) : \n fig = plt.gcf()\n ax = fig.gca()\n # trouve tous les trucs avec linewidth et les modifie\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n # en particuliers les marqueurs des ticks\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size)\n \n # trouve tous les textes et les modifie\n def myfunc(x):\n return hasattr(x, 'set_fontsize')\n for o in fig.findobj(myfunc):\n o.set_fontsize(Axe_tick_size)\n # les labels un peu plus larges\n ax.set_xlabel(ax.get_xlabel(),fontsize = Axe_tick_size+5,labelpad=2)\n ax.set_ylabel(ax.get_ylabel(),fontsize = Axe_tick_size+5,labelpad=2)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n \n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n \n \n fig.show()","def format_xaxis (self, axes, \n n_ticks = 10, # Number of ticks we would like\n timestamp_formatting = '(%Y-%m-%d)%H:%M', # Specified formatting \n xaxis_mode = None): # Several automatic modes\n if (self.X_type == \"categorical\"):\n axes.set_xticks(self.X[self.start_indx:self.end_indx], minor=False)\n axes.set_xticklabels(self.Xcategories[self.start_indx:self.end_indx][:,0], minor=False)\n \n elif(self.X_type == \"numerical\"):\n # If regular numerical we just plot the values\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\n# ax.get_xaxis().get_major_formatter().set_useOffset(False)\n \n elif(self.X_type == \"timestamp\"):\n axes.xaxis.set_major_formatter(mdates.DateFormatter(timestamp_formatting))\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\n axes.xaxis_date()\n # ax.xaxis.set_major_formatter(FuncFormatter(self.ticklabels[val:val + wsize]))\n self.figure.autofmt_xdate()\n# print (type(self.X), type(self.X[0]))\n \n elif(self.formatXaxis == \"intraday\"):\n # If the data is intraday and we want to apply the Gap Remover !!! \n gap_remover_flag = 1;\n if (gap_remover_flag):\n formatter = FuncFormatter(ul.detransformer_Formatter)\n axes.xaxis.set_major_formatter(formatter) \n # mdates.DateFormatter(formatting)\n \n else:\n axes.xaxis.set_major_formatter(mdates.DateFormatter(formatting))\n \n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))","def tickLabelFormatter(ticks, style):\n \n from hep.draw.latex import scientificNotation\n\n # Compute the absolute size of the largest tick.\n largest = max(map(abs, ticks))\n if largest == 0:\n # All zero.\n return lambda v: \"none\"\n\n # Find the scale factor.\n range = max(ticks) - min(ticks)\n scale = min(largest, range)\n if scale == 0:\n scale = 1\n else:\n scale = log10(scale)\n if scale > 5:\n # Format using scientific notation.\n return lambda v: \"$\" + scientificNotation(v, 2) + \"$\"\n elif scale > 2:\n # Format as an integer.\n return lambda v: \"%d\" % v\n elif scale > -3:\n # Format as a floating-point number.\n return lambda v: \"%.*f\" % (int(2.5 - scale), v)\n else:\n # Format using scientific notation.\n return lambda v: \"$\" + scientificNotation(v, 2) + \"$\"","def ticks(self, domain_min, domain_max):\n raise NotImplementedError()","def default_config(self):\n return {\n \"xtype\": \"scalar\",\n \"ytype\": \"scalar\",\n \"xtick-delta\": 50, \n \"ytick-delta\": 20, \n \"xtick-format\": '{:g}', \n \"ytick-format\": '{:g}',\n }","def test_manual_ticklabels(self):\n fix_text_kerning_factor()\n\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n\n # Specify tick positions manually.\n ticks = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]\n labels = [\"0/5\", \"1/5\", \"2/5\", \"3/5\", \"4/5\", \"5/5\"]\n ax.taxis.set_ticks(ticks, labels=labels)\n ax.laxis.set_ticks(ticks, labels=labels)\n ax.raxis.set_ticks(ticks, labels=labels)","def _set_ticks(lims, num_ticks):\n range_ = lims[1] - lims[0]\n interval = range_ / num_ticks\n ticks = np.arange(lims[0], lims[1] + interval / 2, interval)\n return ticks","def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \n fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size)","def ticker_wrapper(ticker):","def x_formatter_cb( self, ax ):\n ax.set_xlim( xmin=self.begin_num,xmax=self.end_num )\n dl = common.PrettyDateLocator()\n df = common.PrettyDateFormatter( dl )\n ax.xaxis.set_major_locator( dl )\n ax.xaxis.set_major_formatter( df )\n ax.xaxis.set_clip_on(False)\n sf = common.PrettyScalarFormatter( )\n ax.yaxis.set_major_formatter( sf )\n labels = ax.get_xticklabels()","def change_axis_ticks(plot, stylesheet=None):\n from PyQt5 import QtGui\n\n font = QtGui.QFont()\n font.setPointSize(stylesheet[\"pixelsize\"])\n plot.getAxis(\"bottom\").tickFont = font\n plot.getAxis(\"top\").tickFont = font\n plot.getAxis(\"right\").tickFont = font\n plot.getAxis(\"left\").tickFont = font","def get_mark(hist, mark, yaxis):\n from rplot.fixes import ROOT\n limits = get_limits(hist, xaxis=yaxis)\n if yaxis:\n return ROOT.TGaxis(limits[0], mark, limits[1], mark, 0, 0, 0)\n else:\n return ROOT.TGaxis(mark, limits[0], mark, 1.05*limits[1], 0, 0, 0)","def set_integer_xticks(self, set_ticks = False):\n self._x_integer_ticks = True","def format_ticks(ax, **kwargs):\n add_minor_x = kwargs.get('add_minor_x', True)\n add_minor_y = kwargs.get('add_minor_y', True)\n tickdirection = kwargs.get('tickdirection', 'in') \n # Default to minor tick every 1/2 of space between\n # major ticks \n\n if add_minor_x:\n xmajorspace = np.diff(ax.get_xticks())[0] \n xminorspace = np.abs(xmajorspace/2)\n xminorspace = kwargs.get('xminorspace', xminorspace)\n ax.xaxis.set_minor_locator(MultipleLocator(xminorspace))\n if add_minor_y:\n ymajorspace = np.diff(ax.get_yticks())[0]\n yminorspace = np.abs(ymajorspace/2)\n yminorspace = kwargs.get('yminorspace', yminorspace)\n ax.yaxis.set_minor_locator(MultipleLocator(yminorspace))\n\n for ticktype in ['minor', 'major']:\n ax.tick_params(axis=\"y\", which=ticktype, direction=tickdirection)\n ax.tick_params(axis=\"x\", which=ticktype, direction=tickdirection)","def set_hgps_style(f):\n #f.set_tick_labels_font(size='small')\n #f.set_axis_labels_font(size='small')\n f.ticks.set_xspacing(2)\n f.ticks.set_yspacing(2)\n f.ticks.set_linewidth(1.5)\n f.tick_labels.set_xformat('dd')\n f.tick_labels.set_yformat('dd')\n f.tick_labels.set_style('colons')\n #f.tick_labels.set_font(size='small')\n f.axis_labels.set_xtext('Right Ascension (deg)')\n f.axis_labels.set_ytext('Declination (deg)')","def fix_ticks(self, noxticks=False, noyticks=False, style=None, N=None,\n rotate_x=False, rotate_y=False, xticklabels=None, yticklabels=None, \n oned=True):\n \n pl.draw()\n \n self.fix_axes_labels()\n \n self.fix_axes_ticks(axis='x', N=N, rotate_x=rotate_x) \n self.fix_axes_ticks(axis='y', N=N, rotate_y=rotate_y)\n \n \n if self.diagonal == 'lower' and oned:\n self.grid[np.intersect1d(self.left, self.top)[0]].set_yticklabels([])\n \n self.remove_all_ticks(noxticks, noyticks)\n \n pl.draw()","def test_manual_ticks(self):\n fix_text_kerning_factor()\n\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n\n ax.plot(*get_spiral())\n\n ax.grid()\n\n ax.set_tlabel('Top')\n ax.set_llabel('Left')\n ax.set_rlabel('Right')\n\n # Specify tick positions manually.\n ax.taxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])\n ax.laxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])\n ax.raxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])","def fix_axes_ticks(self, axis='x', style=None, dtype=float, N=None, \n rotate_x=False, rotate_y=False):\n \n # Grab functions we need by name\n get_lim = \"get_{!s}lim\".format(axis)\n get_ticks = \"get_{!s}ticks\".format(axis)\n get_ticklabels = \"get_{!s}ticklabels\".format(axis)\n set_ticks = \"set_{!s}ticks\".format(axis)\n set_ticklabels = \"set_{!s}ticklabels\".format(axis)\n shared = eval(\"self.share_{!s}\".format(axis))\n \n # Get locations of ticks on bottom row\n if axis is 'x':\n ticks_by_col = []\n for i in self.bottom:\n ticks_by_col.append(self.grid[i].get_xticks())\n \n # Get locations of ticks on left column\n if axis is 'y':\n ticks_by_row = []\n for i in self.left:\n ticks_by_row.append(self.grid[i].get_xticks())\n \n # Figure out if axes are shared or not\n if axis == 'x':\n j = 0\n if shared:\n axes = self.xaxes\n else:\n axes = np.arange(self.N)\n elif axis == 'y':\n j = 1\n if shared:\n axes = self.yaxes\n else:\n axes = np.arange(self.N)\n else:\n raise ValueError('axis must be set to \\'x\\' or \\'y\\'')\n \n if not shared:\n return\n \n # Loop over axes and make corrections\n for i in axes:\n \n # Skip non-existent elements\n if self.diagonal:\n if self.above_diagonal(i):\n continue\n \n if self.grid[i] is None:\n continue\n\n # Retrieve current ticks, tick-spacings, and axis limits\n ticks = eval(\"list(self.grid[{0}].{1!s}())\".format(i, get_ticks))\n\n if not ticks:\n continue\n \n # Get all the info for current set of ticks\n ticklabels = eval((\"[tick for tick in \" +\\\n \"self.grid[{0}].{1!s}()]\").format(i, get_ticklabels))\n \n labels = [] \n for tick in ticklabels: \n l = tick.get_text()\n \n # Minus signs are weird in unicode...\n try:\n assert isinstance(l, unicode)\n except:\n new = l\n else:\n if u'\\u2212' in l:\n new = '-' + l.encode('ascii', 'ignore')\n else:\n new = l.encode('ascii', 'ignore') \n \n labels.append(new)\n \n Nticks = len(labels) \n dt = np.diff(ticks)[0] \n \n # Axes limits\n limits = eval(\"self.grid[{0}].{1!s}()\".format(i, get_lim))\n \n # column or row number. Need this to know whether or not to...?\n pos = self.axis_position(i)[j]\n\n # Determine if we're chopping off the first and/or last tick mark\n # e.g., if the axes are adjoined\n ul = None\n if shared and pos < (self.dims[int(not j)] - 1):\n ul = -1\n \n ll = 0 \n \n # If number of ticks was specified by hand \n if N is not None:\n mi, ma = round(limits[0], 1), round(limits[1], 1)\n \n prec = 2\n while mi == ma:\n mi, ma = round(limits[0], prec), round(limits[1], prec)\n prec += 1\n\n dt = (ma - mi) / float(N)\n\n if dt < 1:\n dt = np.round(dt, abs(int(np.log10(dt))) + 1)\n ticks = np.arange(mi, mi + (N+1)*dt, dt)\n else:\n ticks = np.round(np.linspace(mi, ma, N), 1)\n \n labels = ['{0:g}'.format(val) for val in ticks]\n \n if (axis == 'x' and rotate_x):\n rotate = rotate_x\n elif (axis == 'y' and rotate_y):\n rotate = rotate_y\n else:\n rotate = False\n \n if ul is None:\n eval(\"self.grid[{0}].{1!s}(ticks)\".format(i, set_ticks))\n \n if rotate:\n if type(rotate) == bool:\n eval((\"self.grid[{0}].{1!s}(labels, \" +\\\n \"rotation=90)\").format(i, set_ticklabels))\n else:\n eval((\"self.grid[{0}].{1!s}(labels, \" +\\\n \"rotation={2:g})\").format(i, set_ticklabels,\\\n rotate)) \n else:\n eval(\"self.grid[{0}].{1!s}(labels)\".format(i,\\\n set_ticklabels))\n else:\n eval(\"self.grid[{0}].{1!s}(ticks[{2}:{3}])\".format(i,\\\n set_ticks, ll, ul))\n\n if rotate:\n if type(rotate) == bool:\n eval((\"self.grid[{0}].{1!s}(labels[{2}:{3}], \" +\\\n \"rotation=90)\").format(i, set_ticklabels, ll, ul))\n else:\n eval((\"self.grid[{0}].{1!s}(labels[{2}:{3}], \" +\\\n \"rotation={4:g})\").format(i, set_ticklabels, ll,\\\n ul, rotate)) \n else:\n eval(\"self.grid[{0}].{1!s}(labels[{2}:{3}])\".format(i,\\\n set_ticklabels, ll, ul))\n \n if style is not None: \n self.grid[i].ticklabel_format(style=style)\n \n # Loop over columns, force those not in row 0 to share ticks with \n # whatever tick marks there are in row #0\n if axis == 'x':\n for k in range(len(self.elements_by_column)):\n loc = self.axis_number(0, k)\n xticks = self.grid[loc].get_xticks()\n xticks = [round(tick, 3) for tick in xticks]\n xlim = [round(lim, 3) for lim in self.grid[loc].get_xlim()]\n \n xticks = [0 if abs(tick) < 1e-8 * max(np.abs(xticks)) else tick \\\n for tick in xticks]\n \n for h, element in enumerate(self.elements_by_column[k]):\n if element in self.bottom:\n continue \n \n self.grid[element].set_xticks(xticks)\n self.grid[element].set_xlim(xlim)\n \n # Same deal for y ticks\n if axis == 'y':\n for k in range(len(self.elements_by_row)):\n loc = self.axis_number(k, 0)\n yticks = self.grid[loc].get_yticks()\n yticks = [round(tick, 3) for tick in yticks]\n ylim = [round(lim, 3) for lim in self.grid[loc].get_ylim()]\n \n yticks = [0 if abs(tick) < 1e-8 * max(np.abs(yticks)) else tick \\\n for tick in yticks]\n \n for h, element in enumerate(self.elements_by_row[k]):\n if element in self.left:\n continue \n if self.diag is not None:\n if element in self.diag:\n continue \n \n self.grid[element].set_yticks(yticks)\n self.grid[element].set_ylim(ylim)\n \n # Remove ticklabels of interior panels completely\n if shared:\n for k in range(self.N):\n if self.grid[k] is None:\n continue\n \n if (self.diagonal is not None):\n if self.above_diagonal(k):\n continue\n \n if k not in axes:\n eval(\"self.grid[{0}].{1!s}([])\".format(k, set_ticklabels))\n \n pl.draw()","def config_ticks(self, axis_type, axis_name, ticker, formatter):\n\n if axis_name is None:\n axis_name = self._default_y_name\n\n if axis_type not in ('x', 'y'):\n raise ArgumentError(\"Unknown axis type that is not x or y\", axis_type=axis_type)\n\n if axis_type == 'x':\n axis = self.figure.xaxis\n else:\n axis = self._find_axis(axis_name)\n\n axis.ticker = ticker\n axis.formatter = formatter","def figure_style():\r\n sns.set(style=\"ticks\", context=\"paper\",\r\n font=\"Arial\",\r\n rc={\"font.size\": 7,\r\n \"axes.titlesize\": 8,\r\n \"axes.labelsize\": 7,\r\n \"axes.linewidth\": 0.5,\r\n \"lines.linewidth\": 1,\r\n \"lines.markersize\": 3,\r\n \"xtick.labelsize\": 7,\r\n \"ytick.labelsize\": 7,\r\n \"savefig.transparent\": True,\r\n \"xtick.major.size\": 2.5,\r\n \"ytick.major.size\": 2.5,\r\n \"xtick.major.width\": 0.5,\r\n \"ytick.major.width\": 0.5,\r\n \"xtick.minor.size\": 2,\r\n \"ytick.minor.size\": 2,\r\n \"xtick.minor.width\": 0.5,\r\n \"ytick.minor.width\": 0.5\r\n })\r\n matplotlib.rcParams['pdf.fonttype'] = 42\r\n matplotlib.rcParams['ps.fonttype'] = 42\r\n colors = {'sert': sns.color_palette('colorblind')[2],\r\n 'wt': sns.color_palette('colorblind')[7],\r\n 'left': sns.color_palette('colorblind')[1],\r\n 'right': sns.color_palette('colorblind')[0],\r\n 'enhanced': sns.color_palette('colorblind')[3],\r\n 'suppressed': sns.color_palette('colorblind')[0],\r\n 'no-modulation': sns.color_palette('colorblind')[7],\r\n 'both-significant': sns.color_palette('colorblind')[2],\r\n 'light-significant': sns.color_palette('colorblind')[0],\r\n 'stim-significant': sns.color_palette('colorblind')[4]}\r\n screen_width = tk.Tk().winfo_screenwidth()\r\n dpi = screen_width / 10\r\n return colors, dpi","def ticks(self, start, end, desired_ticks=None):\n raise NotImplementedError","def setCurve(self, *args):\n return _libsbml.GeneralGlyph_setCurve(self, *args)","def setMath(self, *args):\n return _libsbml.FunctionTerm_setMath(self, *args)","def _patch_intercept_mark():\n\n original_intercept_mark = CodeViewText.intercept_mark\n\n def _patched_intercept_mark(self, *args):\n if args[:2] == (\"set\", \"insert\") and args[2].endswith(\".0\"):\n self.set_insertwidth(3)\n else:\n self.set_insertwidth(2)\n\n original_intercept_mark(self, *args)\n\n CodeViewText.intercept_mark = _patched_intercept_mark","def tick_axis_number(ax=None,num_x_major=5,num_x_minor=None,num_y_major=5,\n num_y_minor=None,change_x=True,change_y=True):\n ax = gca(ax)\n if (num_x_minor is None):\n num_x_minor = 2 * num_x_major\n if (num_y_minor is None):\n num_y_minor = 2 * num_y_major\n if (change_x):\n axis_locator(ax.xaxis,num_x_major,num_x_minor)\n if (change_y):\n axis_locator(ax.yaxis,num_y_major,num_y_minor)","def setMath(self, *args):\n return _libsbml.FunctionDefinition_setMath(self, *args)","def setMath(self, *args):\n return _libsbml.StoichiometryMath_setMath(self, *args)","def DrawCheckMark(*args, **kwargs):\n return _gdi_.PseudoDC_DrawCheckMark(*args, **kwargs)","def __init__(self, *args, **kwargs):\n # Set tick length to zero so azimuthal labels are not too offset\n # Change default radial axis formatter but keep default theta one\n super().__init__(*args, **kwargs)\n formatter = axistools.Formatter('auto')\n self.yaxis.set_major_formatter(formatter)\n self.yaxis.isDefault_majfmt = True\n for axis in (self.xaxis, self.yaxis):\n axis.set_tick_params(which='both', size=0)","def tick(self, tick):\n pass","def tick(self, tick):\n pass","def set_ticks(self, ticks, column=None, row=None, minor=False, \n round_two=False, oned=True):\n \n assert (column is not None) or (row is not None), \\\n \"Must supply column or row number!\"\n assert not ((column is not None) and (row is not None)), \\\n \"Must supply column *or* row number!\"\n \n # Could do this more compactly but who cares.\n if column is not None:\n elements = self.elements_by_column\n for j, panel_set in enumerate(elements):\n for k, panel in enumerate(panel_set):\n if j != column:\n continue\n \n self.grid[panel].set_xticks(ticks, minor=minor)\n if (not minor):\n self.grid[panel].set_xticklabels(list(map(str, ticks)))\n \n # Just apply to relevant rows, too.\n if not round_two:\n if (column > 0) or oned:\n self.set_ticks(ticks, row=self.nrows-column-1*oned, minor=minor, \n round_two=True, oned=oned)\n else:\n elements = self.elements_by_row\n for j, panel_set in enumerate(elements):\n for k, panel in enumerate(panel_set):\n if j != row:\n continue\n \n if (panel in self.diag) and oned:\n continue\n \n self.grid[panel].set_yticks(ticks, minor=minor)\n if (not minor):\n self.grid[panel].set_yticklabels(list(map(str, ticks)))\n \n if not round_two:\n if (row > 0) or oned:\n self.set_ticks(ticks, column=self.nrows-row-1*oned, minor=minor, \n round_two=True, oned=oned)\n \n pl.draw()","def _lambert_ticks(ax, ticks, tick_location, line_constructor, tick_extractor):\r\n outline_patch = sgeom.LineString(ax.outline_patch.get_path().vertices.tolist())\r\n axis = find_side(outline_patch, tick_location)\r\n n_steps = 30\r\n extent = ax.get_extent(ccrs.PlateCarree())\r\n _ticks = []\r\n for t in ticks:\r\n xy = line_constructor(t, n_steps, extent)\r\n proj_xyz = ax.projection.transform_points(ccrs.Geodetic(), xy[:, 0], xy[:, 1])\r\n xyt = proj_xyz[..., :2]\r\n ls = sgeom.LineString(xyt.tolist())\r\n locs = axis.intersection(ls)\r\n if not locs:\r\n tick = [None]\r\n else:\r\n tick = tick_extractor(locs.xy)\r\n _ticks.append(tick[0])\r\n # Remove ticks that aren't visible: \r\n ticklabels = copy(ticks)\r\n while True:\r\n try:\r\n index = _ticks.index(None)\r\n except ValueError:\r\n break\r\n _ticks.pop(index)\r\n ticklabels.pop(index)\r\n return _ticks, ticklabels","def y_fmt(tick_val,pos): \n \n if tick_val > 1000000:\n val = int(tick_val/1000000)\n return '{:d}M'.format(val)\n \n elif tick_val > 1000:\n val = int(tick_val/1000)\n return '{:d}k'.format(val) \n \n else: \n return int(tick_val)","def tick(self):","def set_sig_figs(n):\n u.default_format = '.' + str(n) + 'g'\n pd.options.display.float_format = ('{:,.' + str(n) + '}').format","def setModel(self):\n return cell.ticker.Tickable()","def countticks(callable):\n def wrap(self):\n deltaT = pygame.time.get_ticks() - self.last_ticks\n res = callable(self,deltaT)\n self.last_ticks = pygame.time.get_ticks()\n return res\n return wrap","def MarkerDefineDefault(self):\n #self.MarkerDefine(TextView.MARKER_NUM, wx.stc.STC_MARK_ROUNDRECT, wx.BLACK, wx.BLUE)\n pass","def set_all_labels(ax, xax, ra_label, yax, dec_label, roundnum=1):\n ax.set_xticks(xax)\n ax.set_xticklabels(np.round(ra_label, roundnum))\n ax.set_yticks(yax)\n ax.set_yticklabels(np.round(dec_label, roundnum))\n ax.set_ylim(yax[0], yax[-1])\n \n return ax","def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \n #fig = plt.gcf()\n def myfunc(x):\n return hasattr(x, 'set_linewidth')\n for o in fig.findobj(myfunc):\n o.set_linewidth(Line_size)\n \n def myfunc(x):\n return hasattr(x, 'set_markersize')\n for o in fig.findobj(myfunc):\n o.set_markersize(Line_size+4)\n def myfunc(x):\n return hasattr(x, 'set_markeredgewidth')\n for o in fig.findobj(myfunc):\n o.set_markeredgewidth(Line_size)\n for ax in fig.axes:\n \n # trouve tous les trucs avec linewidth et les modifie\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\n item.set_fontsize(Axe_tick_size)\n \n #for item in ([ax.xaxis.label, ax.yaxis.label]):\n # item.set_fontsize(Axe_tick_size+5)\n for line in ax.get_xticklines() + ax.get_yticklines():\n line.set_markersize(Line_size+2)\n line.set_markeredgewidth(Line_size) \n \n \n \n #fig.show()","def theme(ax=None, minorticks=False):\n from matplotlib.ticker import AutoMinorLocator\n from pylab import rcParams, gca, tick_params\n if minorticks:\n if ax is None:\n ax = gca()\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n tick_params(which='both', width=rcParams['lines.linewidth'])","def tickNum(a, xAxis=3, yAxis=3):\r\n xlims = [x for x in a.axis()[0:2]]\r\n xRange = xlims[1] - xlims[0]\r\n ti = xRange/(xAxis-1)\r\n a.set_xticks([round(x, 1) for x in numpy.arange(xlims[0], xlims[1]+1, ti)])\r\n a.set_xlim([round(x, 1) for x in xlims])\r\n \r\n ylims = [i for i in a.axis()[2:]]\r\n yRange = ylims[1] - ylims[0]\r\n ti = yRange/(yAxis-1)\r\n a.set_yticks([round(i, 1) for i in numpy.arange(ylims[0], ylims[1]+1, ti)])\r\n a.set_ylim([round(i, 1) for i in ylims])","def DrawCheckMark(*args, **kwargs):\n return _gdi_.DC_DrawCheckMark(*args, **kwargs)","def test_bool_xticks(self):\n plot_index = pd.date_range(start=\"2000-1-1\", freq=\"D\", periods=10000)\n freq = 'M'\n ds = pd.Series(1, index=plot_index)\n # True when freq market is hit\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\n xticks = tl._process(0, 90)\n tl = formatter.TimestampLocator(plot_index, freq=freq)\n correct = tl._process(0, 90)\n tm.assert_almost_equal(xticks, correct)\n\n freq = 'MS'\n ds = pd.Series(1, index=plot_index)\n # True when freq market is hit\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\n xticks = tl._process(3, 94)\n tl = formatter.TimestampLocator(plot_index, freq=freq)\n correct = tl._process(3, 94)\n tm.assert_almost_equal(xticks, correct)\n\n freq = 'W'\n ds = pd.Series(1, index=plot_index)\n # True when freq market is hit\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\n xticks = tl._process(3, 94)\n tl = formatter.TimestampLocator(plot_index, freq=freq)\n correct = tl._process(3, 94)\n tm.assert_almost_equal(xticks, correct)","def format(self, ticks, numlabels=None, char_width=None, fill_ratio=0.3):\n return map(str, map(int, ticks))","def tick(self):\n for method in self.on_ticker:\n getattr(self, method)()","def ferret_custom_axes(id):\n axis_defs = [ None ] * pyferret.MAX_FERRET_NDIM\n axis_defs[0] = ( 1, 2, 1, \"KS,P\", False )\n return axis_defs","def do_talbotTicks(\n ax,\n axes=\"xy\",\n density=(1.0, 1.0),\n insideMargin=0.05,\n pointSize=None,\n tickPlacesAdd={\"x\": 0, \"y\": 0},\n floatAdd={\"x\": 0, \"y\": 0},\n axrange={\"x\": None, \"y\": None},\n colorbar=None, \n):\n\n # get axis limits\n # aleft = ax.getAxis('left')\n # abottom = ax.getAxis('bottom')\n\n if \"y\" in axes:\n yRange = list(ax.get_ylim())\n if axrange[\"y\"] is not None: # any overrides\n for ra in range(0, 2):\n if axrange[\"y\"][ra] is not None:\n yRange[ra] = axrange[\"y\"][ra]\n\n yr = np.diff(yRange)[0]\n ymin, ymax = (\n np.min(yRange) - yr * insideMargin,\n np.max(yRange) + yr * insideMargin,\n )\n ytick = ticks.Extended(\n density=density[1], figure=None, range=(ymin, ymax), axis=\"y\"\n )\n yt = ytick()\n yts = tickStrings(\n yt,\n scale=1,\n spacing=None,\n tickPlacesAdd=tickPlacesAdd[\"y\"],\n floatAdd=floatAdd[\"y\"],\n )\n # ytickl = [[(y, yts[i]) for i, y in enumerate(yt)] , []] # no minor ticks here\n if colorbar is not None:\n colorbar.set_ticks(yt)\n colorbar.set_ticklabels(yts)\n else:\n ax.set_yticks(yt)\n ax.set_yticklabels(yts) # , rotation='horizontal', fontsize=pointSize)\n # print ('yt, yts: ', yt, yts)\n\n # ytxt = ax.get_yticklabels()\n ytxt = ax.get_yticks().tolist()\n ax.yaxis.set_major_locator(matplotlib.ticker.FixedLocator(ytxt))\n # ax.set_yticklabels([label_format.format(x) for x in ytxt], fontsize=pointSIze,\n # rotation='horizontal')\n xRange = list(ax.get_xlim())\n if axrange[\"x\"] is not None: # any overrides\n for ra in range(0, 2):\n if axrange[\"x\"][ra] is not None:\n xRange[ra] = axrange[\"x\"][ra]\n # now create substitue tick marks and labels, using Talbot et al algorithm\n xr = np.diff(xRange)[0]\n xmin, xmax = (\n np.min(xRange) - xr * insideMargin,\n np.max(xRange) + xr * insideMargin,\n )\n xtick = ticks.Extended(\n density=density[0], figure=None, range=(xmin, xmax), axis=\"x\"\n )\n if pointSize is not None:\n ytxt = ax.get_yticklabels()\n ax.set_yticklabels(ytxt, fontsize = pointSize, rotation =\"horizontal\")\n\n if \"x\" in axes:\n xRange = list(ax.get_xlim())\n if axrange[\"x\"] is not None: # any overrides\n for ra in range(0, 2):\n if axrange[\"x\"][ra] is not None:\n xRange[ra] = axrange[\"x\"][ra]\n # now create substitue tick marks and labels, using Talbot et al algorithm\n xr = np.diff(xRange)[0]\n xmin, xmax = (\n np.min(xRange) - xr * insideMargin,\n np.max(xRange) + xr * insideMargin,\n )\n xtick = ticks.Extended(\n density=density[0], figure=None, range=(xmin, xmax), axis=\"x\"\n )\n xt = xtick()\n xts = tickStrings(\n xt,\n scale=1,\n spacing=None,\n tickPlacesAdd=tickPlacesAdd[\"x\"],\n floatAdd=floatAdd[\"x\"],\n )\n # xtickl = [[(x, xts[i]) for i, x in enumerate(xt)] , []] # no minor ticks here\n # x_ticks_labels = ax.set_xticks(xt)\n # ax.set_xticklabels(xts) # , rotation='horizontal', fontsize=pointSize)\n if pointSize is not None:\n xtxt = ax.get_xticklabels()\n # ax.set_xticklabels(xtxt, fontsize = pointSize, rotation =\"horizontal\")","def __executeActions(self):\n if 'labelFormat' not in self.options:\n if self.dim == 2:\n self.ax.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\n self.ax.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\n self.ax.ticklabel_format(**{'style': 'sci', 'scilimits': (0,1), 'useOffset': False, 'axis': 'both'})\n if 'title' not in self.options:\n self.ax.set_title(self.name, fontdict={'verticalalignment': 'baseline', 'horizontalalignment': 'center'})\n for key in self.options:\n if key in ['how', 'plotSettings', 'figureProperties', 'colorbar']:\n pass\n elif key == 'range':\n if 'ymin' in self.options[key]:\n self.ax.set_ylim(bottom=ast.literal_eval(self.options[key]['ymin']))\n if 'ymax' in self.options[key]:\n self.ax.set_ylim(top=ast.literal_eval(self.options[key]['ymax']))\n if 'xmin' in self.options[key]:\n self.ax.set_xlim(left=ast.literal_eval(self.options[key]['xmin']))\n if 'xmax' in self.options[key]:\n self.ax.set_xlim(right=ast.literal_eval(self.options[key]['xmax']))\n if self.dim == 3:\n if 'zmin' in self.options[key]:\n self.ax.set_zlim(bottom=ast.literal_eval(self.options[key]['zmin']))\n if 'zmax' in self.options[key]:\n self.ax.set_zlim(top=ast.literal_eval(self.options[key]['zmax']))\n elif key == 'labelFormat':\n if 'style' not in self.options[key]:\n self.options[key]['style'] = 'sci'\n if 'limits' not in self.options[key]:\n self.options[key]['limits'] = '(0,0)'\n if 'useOffset' not in self.options[key]:\n self.options[key]['useOffset'] = 'False'\n if 'axis' not in self.options[key]:\n self.options[key]['axis'] = 'both'\n self.ax.ticklabel_format(**{'style': self.options[key]['style'],\n 'scilimits': ast.literal_eval(self.options[key]['limits']),\n 'useOffset': ast.literal_eval(self.options[key]['useOffset']),\n 'axis': self.options[key]['axis']})\n elif key == 'camera':\n if self.dim == 2:\n self.raiseAWarning('2D plots have not a camera attribute... They are 2D!!!!')\n else:\n if 'elevation' in self.options[key] and 'azimuth' in self.options[key]:\n self.ax.view_init(elev=float(self.options[key]['elevation']), azim=float(self.options[key]['azimuth']))\n elif 'elevation' in self.options[key] and 'azimuth' not in self.options[key]:\n self.ax.view_init(elev=float(self.options[key]['elevation']), azim=None)\n elif 'elevation' not in self.options[key] and 'azimuth' in self.options[key]:\n self.ax.view_init(elev=None, azim=float(self.options[key]['azimuth']))\n elif key == 'title':\n self.ax.set_title(self.options[key]['text'], **self.options[key].get('attributes', {}))\n elif key == 'scale':\n major, minor = [int(x) for x in matplotlib.__version__.split('.')[:2]]\n #matplotlib before 3.5 used nonpos instead of nonpositive\n useNonpos = (major == 3 and minor < 5)\n if 'xscale' in self.options[key]:\n if useNonpos:\n self.ax.set_xscale(self.options[key]['xscale'], nonposx='clip')\n elif self.options[key]['xscale'].lower() == 'log':\n self.ax.set_xscale(self.options[key]['xscale'], nonpositive='clip')\n else:\n self.ax.set_xscale(self.options[key]['xscale'])\n if 'yscale' in self.options[key]:\n if useNonpos:\n self.ax.set_yscale(self.options[key]['yscale'], nonposy='clip')\n elif self.options[key]['yscale'].lower() == 'log':\n self.ax.set_yscale(self.options[key]['yscale'], nonpositive='clip')\n else:\n self.ax.set_yscale(self.options[key]['yscale'])\n if self.dim == 3:\n if 'zscale' in self.options[key]:\n self.ax.set_zscale(self.options[key]['zscale'])\n elif key == 'addText':\n if 'position' not in self.options[key]:\n if self.dim == 2:\n self.options[key]['position'] = '0.0,0.0'\n else:\n self.options[key]['position'] = '0.0,0.0,0.0'\n if 'withdash' not in self.options[key]:\n self.options[key]['withdash'] = 'False'\n if 'fontdict' not in self.options[key]:\n self.options[key]['fontdict'] = 'None'\n else:\n try:\n tempVar = ast.literal_eval(self.options[key]['fontdict'])\n self.options[key]['fontdict'] = str(tempVar)\n except AttributeError:\n self.raiseAnError(TypeError, f'In {key} tag: can not convert the string \"{self.options[key][\"fontdict\"]}\" to a dictionary! Check syntax for python function ast.literal_eval')\n if self.dim == 2 :\n self.ax.text(float(self.options[key]['position'].split(',')[0]),\n float(self.options[key]['position'].split(',')[1]),\n self.options[key]['text'],\n fontdict=ast.literal_eval(self.options[key]['fontdict']),\n **self.options[key].get('attributes', {}))\n else:\n self.ax.text(float(self.options[key]['position'].split(',')[0]),\n float(self.options[key]['position'].split(',')[1]),\n float(self.options[key]['position'].split(',')[2]),\n self.options[key]['text'],\n fontdict=ast.literal_eval(self.options[key]['fontdict']),\n **self.options[key].get('attributes', {}))\n elif key == 'autoscale':\n if 'enable' not in self.options[key]:\n self.options[key]['enable'] = 'True'\n elif utils.stringIsTrue(self.options[key]['enable']):\n self.options[key]['enable'] = 'True'\n elif utils.stringIsFalse(self.options[key]['enable']):\n self.options[key]['enable'] = 'False'\n if 'axis' not in self.options[key]:\n self.options[key]['axis'] = 'both'\n if 'tight' not in self.options[key]:\n self.options[key]['tight'] = 'None'\n self.ax.autoscale(enable=ast.literal_eval(self.options[key]['enable']),\n axis=self.options[key]['axis'],\n tight=ast.literal_eval(self.options[key]['tight']))\n elif key == 'horizontalLine':\n if self.dim == 3:\n self.raiseAWarning('horizontalLine not available in 3-D plots!!')\n else:\n if 'y' not in self.options[key]:\n self.options[key]['y'] = '0'\n if 'xmin' not in self.options[key]:\n self.options[key]['xmin'] = '0'\n if 'xmax' not in self.options[key]:\n self.options[key]['xmax'] = '1'\n if 'hold' not in self.options[key]:\n self.options[key]['hold'] = 'None'\n self.ax.axhline(y=ast.literal_eval(self.options[key]['y']),\n xmin=ast.literal_eval(self.options[key]['xmin']),\n xmax=ast.literal_eval(self.options[key]['xmax']),\n hold=ast.literal_eval(self.options[key]['hold']),\n **self.options[key].get('attributes', {}))\n elif key == 'verticalLine':\n if self.dim == 3:\n self.raiseAWarning('verticalLine not available in 3-D plots!!')\n else:\n if 'x' not in self.options[key]:\n self.options[key]['x'] = '0'\n if 'ymin' not in self.options[key]:\n self.options[key]['ymin'] = '0'\n if 'ymax' not in self.options[key]:\n self.options[key]['ymax'] = '1'\n if 'hold' not in self.options[key]:\n self.options[key]['hold'] = 'None'\n self.ax.axvline(x=ast.literal_eval(self.options[key]['x']),\n ymin=ast.literal_eval(self.options[key]['ymin']),\n ymax=ast.literal_eval(self.options[key]['ymax']),\n hold=ast.literal_eval(self.options[key]['hold']),\n **self.options[key].get('attributes', {}))\n elif key == 'horizontalRectangle':\n if self.dim == 3:\n self.raiseAWarning('horizontalRectangle not available in 3-D plots!!')\n else:\n if 'ymin' not in self.options[key]:\n self.raiseAnError(IOError, 'ymin parameter is needed for function horizontalRectangle!!')\n if 'ymax' not in self.options[key]:\n self.raiseAnError(IOError, 'ymax parameter is needed for function horizontalRectangle!!')\n if 'xmin' not in self.options[key]:\n self.options[key]['xmin'] = '0'\n if 'xmax' not in self.options[key]:\n self.options[key]['xmax'] = '1'\n self.ax.axhspan(ast.literal_eval(self.options[key]['ymin']),\n ast.literal_eval(self.options[key]['ymax']),\n xmin=ast.literal_eval(self.options[key]['xmin']),\n xmax=ast.literal_eval(self.options[key]['xmax']),\n **self.options[key].get('attributes', {}))\n elif key == 'verticalRectangle':\n if self.dim == 3:\n self.raiseAWarning('vertical_rectangle not available in 3-D plots!!')\n else:\n if 'xmin' not in self.options[key]:\n self.raiseAnError(IOError, 'xmin parameter is needed for function verticalRectangle!!')\n if 'xmax' not in self.options[key]:\n self.raiseAnError(IOError, 'xmax parameter is needed for function verticalRectangle!!')\n if 'ymin' not in self.options[key]:\n self.options[key]['ymin'] = '0'\n if 'ymax' not in self.options[key]:\n self.options[key]['ymax'] = '1'\n self.ax.axvspan(ast.literal_eval(self.options[key]['xmin']),\n ast.literal_eval(self.options[key]['xmax']),\n ymin=ast.literal_eval(self.options[key]['ymin']),\n ymax=ast.literal_eval(self.options[key]['ymax']),\n **self.options[key].get('attributes', {}))\n elif key == 'axesBox':\n if self.dim == 3:\n self.raiseAWarning('axesBox not available in 3-D plots!!')\n else:\n self.ax.set_frame_on(self.options[key][key])\n elif key == 'axis':\n self.ax.axis(self.options[key][key])\n elif key == 'grid':\n if 'b' not in self.options[key]:\n self.options[key]['b'] = 'off'\n if utils.stringIsTrue(self.options[key]['b']):\n self.options[key]['b'] = 'on'\n elif utils.stringIsFalse(self.options[key]['b']):\n self.options[key]['b'] = 'off'\n if 'which' not in self.options[key]:\n self.options[key]['which'] = 'major'\n if 'axis' not in self.options[key]:\n self.options[key]['axis'] = 'both'\n if self.dim == 2:\n self.ax.grid(b=self.options[key]['b'],\n which=self.options[key]['which'],\n axis=self.options[key]['axis'],\n **self.options[key].get('attributes', {}))\n else:\n self.ax.grid(b=self.options[key]['b'], **self.options[key].get('attributes', {}))\n else:\n self.raiseAWarning(f'Attempting to perform action {key}. If this does not work, check manual and relevant matplotlib method specification.')\n kwargs = {}\n for taco in self.options[key]:\n if taco != 'attributes' and taco != key:\n try:\n kwargs[taco] = ast.literal_eval(self.options[key][taco])\n except ValueError:\n kwargs[taco] = self.options[key][taco]\n try:\n customFunctionCall = getattr(self.ax, key)\n self.actPlot = customFunctionCall(**kwargs)\n except AttributeError as ae:\n self.raiseAnError(RuntimeError, f'<{str(ae)}> -> in executing custom action \"{key}\" in Plot {self.name}.\\n {self.printTag} command has been called in the following way: ax.{key}(**{str(kwargs)})')","def tick_values(self, vmin, vmax):\n raise NotImplementedError('Derived must override')","def setMath(self, *args):\n return _libsbml.EventAssignment_setMath(self, *args)","def setMath(self, *args):\n return _libsbml.Trigger_setMath(self, *args)","def setTickNumber(n=2, axes='XYZ'):\n dislin.ticks(n, axes)","def get_ticks(self, sig=2, n_tick=10):\n fmt = '%.' + str(sig) + 'g'\n xlabels = np.zeros(self.x_axis.shape, dtype=object)\n xlabels[:] = \"\"\n each_n_pixels = math.floor(len(xlabels) / n_tick)\n for i in range(len(xlabels)):\n if i % each_n_pixels == 0:\n xlabels[i] = '%s' % float(fmt % self.x_axis[i])\n ylabels = np.zeros(self.y_axis.shape, dtype=object)\n ylabels[:] = \"\"\n each_n_pixels = math.floor(len(ylabels) / n_tick)\n for i in range(len(ylabels)):\n if i % each_n_pixels == 0:\n ylabels[i] = '%s' % float(fmt % self.y_axis[i])\n return xlabels, ylabels","def get_special_kpoint_ticks(kpoints: list[tuple[str, float]], math_mode: str = '$') -> tuple[list[float], list[str]]:\n if kpoints is None:\n kpoints = []\n\n ticks = []\n ticklabels = []\n for label, position in kpoints:\n if label.lower() in ('gamma', 'g'):\n label = rf'{math_mode}\\Gamma{math_mode}'\n ticklabels.append(label)\n ticks.append(position)\n\n return ticks, ticklabels","def diff_gdef_mark(font_before, font_after):\n return _gdef(font_before, font_after, \"gdef_mark\")","def __init__(self, *args, **kwargs):\n # Impose default formatter\n super().__init__(*args, **kwargs)\n formatter = axistools.Formatter('auto')\n self.xaxis.set_major_formatter(formatter)\n self.yaxis.set_major_formatter(formatter)\n self.xaxis.isDefault_majfmt = True\n self.yaxis.isDefault_majfmt = True\n # Custom attributes\n self._datex_rotated = False # whether manual rotation has been applied\n self._dualy_arg = None # for scaling units on opposite side of ax\n self._dualx_arg = None\n self._dualy_cache = None # prevent excess _dualy_overrides calls\n self._dualx_cache = None","def get_tick():\n return _tick","def major_ticks(self, startint=None, majorint=None):\n\n\t# Set major interval if not supplied #\n\n\tif majorint:\n assert type(majorint) == int\n else: \n majorint = myroundup(len(self.data_dt[1]) / 7.) \n\n\tprint 'major tick interval:', majorint \n\n\t# Determine the ticks #\n\n\tif startint:\n assert type(startint) == int\n else:\n startint = 0\n\ttick_points = range(startint, len(self.data_orig[:]), majorint) \n\n\tformats = {'YEARLY': '%y',\n 'MONTHLY': '%b %y',\n 'WEEKLY': '%d/%m/%y',\n 'DAILY': '%d/%m/%y',\n 'HOURLY': '%m/%d %H:%M',\n 'MINUTELY': '%m/%d %H:%M',\n 'SECONDLY': '%m/%d %H:%M'}\n\n\tmajor_xticks = {}\n\tmajor_xlabels = {}\n\tcount = 0\n\tfor row in range(1, self.nrows+1):\n\t xticks = []\n\t labels = []\n\t for index, dt in enumerate(self.data_dt[row]):\n \tplace = index + count\n \tif place in tick_points:\n \t xticks.append(dates.date2num(dt))\n \t labels.append(dt.strftime(formats[self.freq])) \n\n major_xticks[row] = xticks\n major_xlabels[row] = labels\n count = count + len(self.data_dt[row])\n\n\treturn major_xticks, major_xlabels","def setMath(self, *args):\n return _libsbml.Priority_setMath(self, *args)","def test_opposite_ticks(self):\n fix_text_kerning_factor()\n\n fig = plt.figure()\n ax = fig.add_subplot(projection='ternary')\n\n ax.taxis.set_ticks_position('tick2')\n ax.laxis.set_ticks_position('tick2')\n ax.raxis.set_ticks_position('tick2')\n\n ax.set_tlabel('Top')\n ax.set_llabel('Left')\n ax.set_rlabel('Right')","def value_line(self):\n marks = self._get_marks(False)\n marks['Val'] = self.data['Value']\n fig = plt.figure(figsize=(4,2), dpi=200)\n fig.patch.set_facecolor('#ececec')\n ax = fig.add_subplot(111)\n ax.plot(self.data['Value'], alpha=0.8, lw=1.2, color=\"green\", label='Value')\n ax.scatter([x for x in marks[marks['Marks']>0].index], marks[marks['Marks']>0]['Val'], marker='^', s=20, c=\"b\", label=\"Buy\")\n ax.scatter([x for x in marks[marks['Marks']<0].index], marks[marks['Marks']<0]['Val'], marker='v', s=20, c=\"r\", label=\"Sell\")\n ax.set_xlabel('Time')\n ax.set_ylabel('Portfolio\\'s Value (€)')\n ax.set_title('Portfolio\\'s Value (€) - Daily')\n ax.xaxis.set_major_locator(dates.MonthLocator())\n ax.xaxis.set_major_formatter(dates.DateFormatter('%b-%Y'))\n for x, y, mark in zip(marks.index, marks['Val'], marks['Marks']):\n a = ax.get_ylim()\n if x == marks.index[0]:\n ax.annotate(str(mark) + \" €\", xy=(x + timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 80), y + (a[1]-a[0])/35), fontsize=5)\n else:\n if mark > 0:\n ax.annotate(str(mark) + \" €\", xy=(x + timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 60), y - (a[1]-a[0])/35), fontsize=5)\n else:\n ax.annotate(str(mark) + \" €\", xy=(x - timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 15), y + (a[1]-a[0])/35), fontsize=5)\n ax.grid(True)\n fig.autofmt_xdate()\n ax.legend()\n return fig, ax","def _nice_axes(self, ax):\n ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3))\n pstyle.set_xaxis_label(ax)\n try:\n pstyle.set_xLimits(self.twiss_df.SEQUENCE, ax)\n except pstyle.ArgumentError:\n pass\n if self._ip_pos is not None and len(self._ip_pos) > 0:\n pstyle.show_ir(self._ip_pos, ax)","def setTickPosition(position='sameaslabels', axes='XYZ'):\n tickdict = {'sameaslabels':'LABELS', 'inside':'REVERS','center':'CENTER'}\n dislin.ticpos(tickdict[position],axes)","def getCurveExplicitlySet(self):\n return _libsbml.GeneralGlyph_getCurveExplicitlySet(self)","def func_plot_fmt_map():\n # line_styles = ['o-', 'x-', '*-', '-_', 'D-', 'h-', '+-', 's-', 'v-', \n # ',-', '1-']\n func_tuples = get_func_tuples()\n M = {k:v for (k, _, v) in func_tuples}\n return M","def draw_ticklabels(self):\n for item in self._ax.get_xticklabels() + self._ax.get_yticklabels():\n self._ax.draw_artist(item)\n # self._fig.canvas.update() ## Qt4Agg\n self._fig.canvas.draw() ## TKAgg\n self._fig.canvas.flush_events() # Fixes bug with Qt4Agg backend","def set_style(usetex=False):\n plt.rc('text', usetex=usetex)\n plt.rc('font', family='Serif')\n\n\n mpl.rcParams['figure.figsize'] = [10, 7]\n mpl.rcParams['font.size'] = 17\n\n mpl.rcParams['savefig.dpi'] = 150\n mpl.rcParams['xtick.minor.visible'] = True\n mpl.rcParams['ytick.minor.visible'] = True\n mpl.rcParams['xtick.direction'] = 'in'\n mpl.rcParams['ytick.direction'] = 'in'\n\n mpl.rcParams['xtick.top'] = True\n mpl.rcParams['ytick.right'] = True\n\n mpl.rcParams['xtick.major.size'] = 6\n mpl.rcParams['xtick.minor.size'] = 3\n\n mpl.rcParams['ytick.major.size'] = 6\n mpl.rcParams['ytick.minor.size'] = 3\n\n mpl.rcParams['xtick.labelsize'] = 13\n mpl.rcParams['ytick.labelsize'] = 13","def _nice(x, round=False):\n if x <= 0:\n import warnings\n warnings.warn(\"Invalid (negative) range passed to tick interval calculation\")\n x = abs(x)\n expv = floor(log10(x))\n f = x / pow(10, expv)\n if round:\n if f < 1.75:\n nf = 1.0\n elif f < 3.75:\n nf = 2.5\n elif f < 7.0:\n nf = 5.0\n else:\n nf = 10.0\n else:\n if f <= 1.0:\n nf = 1.0\n elif f <= 2.5:\n nf = 2.5\n elif f <= 5.0:\n nf = 5.0\n else:\n nf = 10.0\n return nf * pow(10, expv)","def disable_ticks(\n ax: Any,\n) -> None:\n\n ax.tick_params(\n axis=\"both\",\n which=\"both\",\n top=False,\n bottom=False,\n left=False,\n right=False,\n labelbottom=False,\n labelleft=False,\n )","def _index_tick(x, pos):\n if x.is_integer() or isinstance(x, int):\n # Use the integer value (fixed weird 'close to integer value bug')\n iloc = int(x)\n if iloc < 0 or iloc >= len(index):\n return \"\"\n tick_val = index[iloc]\n else:\n # Interpolate\n iloc_low = int(floor(x))\n iloc_high = int(ceil(x))\n if iloc_low < 0 or iloc_high >= len(index):\n return \"\"\n low = index[iloc_low]\n high = index[iloc_high]\n\n tick_val = low * (x - iloc_low) + high * (1 - x + iloc_low)\n\n # Format tick value\n return f\"{tick_val:.{tick_label_precision}f}\"","def newplot(*args, **kwargs):\n\n if 'linewidth' and 'lw' not in kwargs.keys():\n kwargs['linewidth'] = 2\n\n plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI)\n plt.plot(*args, **kwargs)\n\n plt.setp(plt.gca().spines.values(), linewidth=2)\n plt.xticks(fontsize=25, fontname='Times New Roman')\n plt.yticks(fontsize=25, fontname='Times New Roman')\n plt.ticklabel_format(useOffset=False)\n plt.ticklabel_format(style='sci', scilimits=(-3, 3))","def ticker(self, symbol, **kwargs):\n pass","def get_tickrate(self):\n raise NotImplementedError","def testAdjustSingleLabelDoesNothing(self):\n self.AddToChart(self.chart, (5, 6, 7))\n self.chart.left.labels = ['Cutoff']\n self.chart.left.label_positions = [3]\n def CheckExpectations():\n self.assertEqual(self.Param('chxl'), '0:|Cutoff')\n self.assertEqual(self.Param('chxp'), '0,3')\n CheckExpectations() # Check without adjustment\n self.chart.AddFormatter(formatters.LabelSeparator(right=15))\n CheckExpectations() # Make sure adjustment hasn't changed anything","def _format_default_functions(self):\n self._out_formatter = null_out_formatter\n self._f_default_names = lambda x: [0]","def setAxisTickColor(idx=-1, axes='XYZ'):\n dislin.axclrs(idx, 'TICKS', axes)","def get_xticks_labels(self):\n xticks = np.arange(-1, self.space_between_glyphs * len(self.positions))\n xticklabels = [' ']\n for p in self.positions:\n xticklabels.append(str(p))\n xticklabels += [' '] * self.space_between_glyphs\n return xticks, xticklabels","def update_tick(self, tick: InstigatorTick):","def dmark(value):\n return mark_safe(DMark().convert(value))","def set_xticks(self, array, extent, units, symmetric_around_centre=False):\n\n plt.tick_params(labelsize=self.xsize)\n\n if symmetric_around_centre:\n return\n\n xticks = np.linspace(extent[0], extent[1], 5)\n\n if self.x_manual is not None:\n xtick_labels = np.asarray([self.x_manual[0], self.x_manual[3]])\n elif not units.use_scaled:\n xtick_labels = np.linspace(0, array.shape_2d[0], 5).astype(\"int\")\n elif units.use_scaled and units.conversion_factor is None:\n xtick_labels = np.round(np.linspace(extent[0], extent[1], 5), 2)\n elif units.use_scaled and units.conversion_factor is not None:\n xtick_labels = np.round(\n np.linspace(\n extent[0] * units.conversion_factor,\n extent[1] * units.conversion_factor,\n 5,\n ),\n 2,\n )\n\n else:\n raise exc.PlottingException(\n \"The y and y ticks cannot be set using the input options.\"\n )\n\n plt.xticks(ticks=xticks, labels=xtick_labels)","def generateLabelsTicks(posns):\n if len(posns) <= 10:\n return labelsTicks(posns, 1)\n elif len(posns) <= 50:\n return labelsTicks(posns, 5)\n else:\n return labelsTicks(posns, 10)","def y_formatter_cb(self, ax):\n # y_vals should be the y-location of the labels.\n labels = getattr( self, 'labels', [] )\n labels = list(labels); #labels.reverse()\n y_vals = numpy.arange(.5,len(labels)+.5,1)\n\n # Locations should be fixed.\n fl = FixedLocator( y_vals )\n # Make the formatter for the y-axis\n ff = FixedFormatter( labels )\n ax.yaxis.set_major_formatter( ff )\n ax.yaxis.set_major_locator( fl )","def getOnsetTick(s):\n ticksPerQuarter = getResolution(s)\n onsets = [int(n.offset * ticksPerQuarter) for n in s.flat.notes]\n return onsets","def render_ticks(axis, labelsize):\n axis.get_xaxis().set_tick_params(\n which='both', direction='in', width=1.5, labelrotation=0, labelsize=labelsize)\n axis.get_yaxis().set_tick_params(\n which='both', direction='in', width=1.5, labelcolor='k', labelsize=labelsize)\n # axis.grid(color='r', linestyle='-.', linewidth=0.5, alpha=0.3, which='both', axis='both')","def onAxisMajorTicksChanged(self, axis_name, value):\n if axis_name in self.axes:\n self.axes[axis_name].setTickCount(value)","def xFormat(self, formatFnc, label=None, options=None, isPyData=False):\r\n return self","def to_ticks(self, *args, **kwargs):\n return _uhd_swig.time_spec_t_to_ticks(self, *args, **kwargs)","def setMath(self, *args):\n return _libsbml.Delay_setMath(self, *args)","def set(self):\n\n if self.tick_values is None and self.tick_labels is None:\n cb = plt.colorbar(fraction=self.fraction, pad=self.pad)\n elif self.tick_values is not None and self.tick_labels is not None:\n cb = plt.colorbar(\n fraction=self.fraction, pad=self.pad, ticks=self.tick_values\n )\n cb.ax.set_yticklabels(labels=self.tick_labels)\n else:\n raise exc.PlottingException(\n \"Only 1 entry of tick_values or tick_labels was input. You must either supply\"\n \"both the values and labels, or neither.\"\n )\n\n cb.ax.tick_params(labelsize=self.ticksize)","def setCurve(self, *args):\n return _libsbml.ReactionGlyph_setCurve(self, *args)"],"string":"[\n \"def default_style(func):\\n def wrapper(*args, **kwargs):\\n fig = plt.figure(figsize=(18,18))\\n sns.set_context(\\\"talk\\\", font_scale=0.9)\\n plt.xlim(-3, 3)\\n plt.tick_params(grid_alpha=0.2)\\n func(*args, **kwargs)\\n plt.clf()\\n return wrapper\",\n \"def create_tick_mark(\\n fmin: float,\\n fmax: float,\\n *,\\n amplitude: float | None = None,\\n) -> float:\\n return amplitude if amplitude is not None else max(abs(fmin), abs(fmax))\",\n \"def py_apply_ticks(self, plot):\\n if self.x_ticks is not None:\\n plot.set_xticks(self.x_ticks)\\n if self.x_labels is not None:\\n plot.set_xticklabels(self.x_labels)\\n if self.y_ticks is not None:\\n plot.set_yticks(self.y_ticks)\\n if self.y_labels is not None:\\n plot.set_yticklabels(self.y_labels)\",\n \"def update_ticks_format( axis, scale ):\\n axis.set_major_formatter( ticker.FuncFormatter( lambda x,pos: \\\"%d\\\" % (x*scale+0.5)) )\\n if linlog != 'linear':\\n grid = np.arange(np.log10(sf/2))[2:]\\n locs = 10**grid/scale_freq\\n axis.set_major_locator(ticker.FixedLocator(locs))\\n else:\\n if scale == 1.0: # freq_cut \\n multbin_major = 10\\n multbin_minor = 1\\n elif sf > 19000: # time_cut 5kHz ticks\\n multbin_major = 5000/scale\\n multbin_minor = multbin_major / 5\\n else: # time_cut 1KHz ticks\\n multbin_major = 1000/scale\\n multbin_minor = multbin_major / 10\\n axis.set_major_locator(ticker.MultipleLocator(multbin_major))\\n axis.set_minor_locator(ticker.MultipleLocator(multbin_minor))\",\n \"def _log_decade_ticks(ax,min_log,max_log,ax_set_func,num=None,**kw_ticks):\\n if (num is None):\\n num = max_log - min_log + 1\\n ax_set_func(np.logspace(min_log, max_log, base=10, num=num))\\n return tickAxisFont(ax=ax,**kw_ticks)\",\n \"def set_axes_ticks(\\n ax: object,\\n xticks:Union[List, None]=None,\\n xticks_str:Union[List, None]=None,\\n xticks_pad:Union[List, None]=None,\\n x_minor:Union[List, None] = None,\\n x_rotation:float=0., \\n major_length: float=3.0,\\n minor_length: float=1.5,\\n yticks:Union[List, None]=None,\\n yticks_str:Union[List, None]=None, \\n yticks_pad:Union[List, None]=None,\\n y_minor:Union[List, None] = None,\\n y_rotation:float=0., \\n fontsize:int=8,\\n): \\n\\n \\n if yticks is not None:\\n ax.set_yticks(yticks, yticks_str, fontsize=fontsize)\\n if yticks_pad is not None:\\n ylabels = ax.get_yticklabels()\\n for i, tick in enumerate(ax.get_yaxis().get_major_ticks()):\\n tick.set_pad(yticks_pad[i])\\n if tick.get_pad() < 0:\\n ax.get_yaxis().set_tick_params(direction=\\\"out\\\")\\n tick.label1 = ylabels[i]\\n ax.tick_params(axis='y', which='major', direction='out', length=major_length, labelrotation=y_rotation)\\n if y_minor is not None:\\n ax.set_yticks(y_minor, minor=True)\\n ax.tick_params(axis='y', which='minor', direction='out', length=minor_length)\\n if xticks is not None:\\n ax.set_xticks(xticks, xticks_str, fontsize=8)\\n if xticks_pad is not None:\\n xlabels = ax.get_xticklabels()\\n for i, tick in enumerate(ax.get_xaxis().get_major_ticks()):\\n tick.set_pad(xticks_pad[i])\\n tick.label1 = xlabels[i]\\n ax.tick_params(axis='x', which='major', direction='out', length=major_length, labelrotation=x_rotation)\\n if x_minor is not None:\\n ax.set_xticks(x_minor, minor=True)\\n ax.tick_params(axis='x', which='minor', direction='out', length=minor_length)\",\n \"def set_axes_ticks(\\n ax: object,\\n xticks:Union[List, None]=None,\\n xticks_str:Union[List, None]=None,\\n xticks_pad:Union[List, None]=None,\\n x_minor:Union[List, None] = None,\\n x_rotation:float=0., \\n major_length: float=3.0,\\n minor_length: float=1.5,\\n yticks:Union[List, None]=None,\\n yticks_str:Union[List, None]=None, \\n yticks_pad:Union[List, None]=None,\\n y_minor:Union[List, None] = None,\\n y_rotation:float=0., \\n fontsize:int=8,\\n): \\n\\n \\n if yticks is not None:\\n ax.set_yticks(yticks, yticks_str, fontsize=fontsize)\\n if yticks_pad is not None:\\n ylabels = ax.get_yticklabels()\\n for i, tick in enumerate(ax.get_yaxis().get_major_ticks()):\\n tick.set_pad(yticks_pad[i])\\n if tick.get_pad() < 0:\\n ax.tick_params(direction=\\\"out\\\") # reset direction\\n tick.label1 = ylabels[i]\\n ax.tick_params(axis='y', which='major', direction='out', length=major_length, labelrotation=y_rotation)\\n if y_minor is not None:\\n ax.set_yticks(y_minor, minor=True)\\n ax.tick_params(axis='y', which='minor', direction='out', length=minor_length)\\n if xticks is not None:\\n ax.set_xticks(xticks, xticks_str, fontsize=8)\\n if xticks_pad is not None:\\n xlabels = ax.get_xticklabels()\\n for i, tick in enumerate(ax.get_xaxis().get_major_ticks()):\\n tick.set_pad(xticks_pad[i])\\n tick.label1 = xlabels[i]\\n ax.tick_params(axis='x', which='major', direction='out', length=major_length, labelrotation=x_rotation)\\n if x_minor is not None:\\n ax.set_xticks(x_minor, minor=True)\\n ax.tick_params(axis='x', which='minor', direction='out', length=minor_length)\",\n \"def tom_ticks(ax=None,num_major=4,num_minor=0,fontsize=g_font_label,**kwargs):\\n ax = gca(ax)\\n tick_axis_number(ax=ax,\\n num_x_major=num_major,\\n num_x_minor=num_minor,\\n num_y_major=num_major,\\n num_y_minor=num_minor,**kwargs)\\n if (num_minor == 0):\\n ax.tick_params(which='minor', right=False, left=False,top=False,\\n bottom = False, axis = 'both')\\n tickAxisFont(ax=ax,fontsize=fontsize)\",\n \"def powerpoint_style(Axe_tick_size=15,Line_size=3) : \\n fig = plt.gcf()\\n ax = fig.gca()\\n # trouve tous les trucs avec linewidth et les modifie\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n # en particuliers les marqueurs des ticks\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size)\\n \\n # trouve tous les textes et les modifie\\n def myfunc(x):\\n return hasattr(x, 'set_fontsize')\\n for o in fig.findobj(myfunc):\\n o.set_fontsize(Axe_tick_size)\\n # les labels un peu plus larges\\n ax.set_xlabel(ax.get_xlabel(),fontsize = Axe_tick_size+5,labelpad=2)\\n ax.set_ylabel(ax.get_ylabel(),fontsize = Axe_tick_size+5,labelpad=2)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n \\n \\n fig.show()\",\n \"def format_xaxis (self, axes, \\n n_ticks = 10, # Number of ticks we would like\\n timestamp_formatting = '(%Y-%m-%d)%H:%M', # Specified formatting \\n xaxis_mode = None): # Several automatic modes\\n if (self.X_type == \\\"categorical\\\"):\\n axes.set_xticks(self.X[self.start_indx:self.end_indx], minor=False)\\n axes.set_xticklabels(self.Xcategories[self.start_indx:self.end_indx][:,0], minor=False)\\n \\n elif(self.X_type == \\\"numerical\\\"):\\n # If regular numerical we just plot the values\\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\\n# ax.get_xaxis().get_major_formatter().set_useOffset(False)\\n \\n elif(self.X_type == \\\"timestamp\\\"):\\n axes.xaxis.set_major_formatter(mdates.DateFormatter(timestamp_formatting))\\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\\n axes.xaxis_date()\\n # ax.xaxis.set_major_formatter(FuncFormatter(self.ticklabels[val:val + wsize]))\\n self.figure.autofmt_xdate()\\n# print (type(self.X), type(self.X[0]))\\n \\n elif(self.formatXaxis == \\\"intraday\\\"):\\n # If the data is intraday and we want to apply the Gap Remover !!! \\n gap_remover_flag = 1;\\n if (gap_remover_flag):\\n formatter = FuncFormatter(ul.detransformer_Formatter)\\n axes.xaxis.set_major_formatter(formatter) \\n # mdates.DateFormatter(formatting)\\n \\n else:\\n axes.xaxis.set_major_formatter(mdates.DateFormatter(formatting))\\n \\n axes.xaxis.set_major_locator(mticker.MaxNLocator(nbins = n_ticks, prune='upper'))\",\n \"def tickLabelFormatter(ticks, style):\\n \\n from hep.draw.latex import scientificNotation\\n\\n # Compute the absolute size of the largest tick.\\n largest = max(map(abs, ticks))\\n if largest == 0:\\n # All zero.\\n return lambda v: \\\"none\\\"\\n\\n # Find the scale factor.\\n range = max(ticks) - min(ticks)\\n scale = min(largest, range)\\n if scale == 0:\\n scale = 1\\n else:\\n scale = log10(scale)\\n if scale > 5:\\n # Format using scientific notation.\\n return lambda v: \\\"$\\\" + scientificNotation(v, 2) + \\\"$\\\"\\n elif scale > 2:\\n # Format as an integer.\\n return lambda v: \\\"%d\\\" % v\\n elif scale > -3:\\n # Format as a floating-point number.\\n return lambda v: \\\"%.*f\\\" % (int(2.5 - scale), v)\\n else:\\n # Format using scientific notation.\\n return lambda v: \\\"$\\\" + scientificNotation(v, 2) + \\\"$\\\"\",\n \"def ticks(self, domain_min, domain_max):\\n raise NotImplementedError()\",\n \"def default_config(self):\\n return {\\n \\\"xtype\\\": \\\"scalar\\\",\\n \\\"ytype\\\": \\\"scalar\\\",\\n \\\"xtick-delta\\\": 50, \\n \\\"ytick-delta\\\": 20, \\n \\\"xtick-format\\\": '{:g}', \\n \\\"ytick-format\\\": '{:g}',\\n }\",\n \"def test_manual_ticklabels(self):\\n fix_text_kerning_factor()\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n\\n # Specify tick positions manually.\\n ticks = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]\\n labels = [\\\"0/5\\\", \\\"1/5\\\", \\\"2/5\\\", \\\"3/5\\\", \\\"4/5\\\", \\\"5/5\\\"]\\n ax.taxis.set_ticks(ticks, labels=labels)\\n ax.laxis.set_ticks(ticks, labels=labels)\\n ax.raxis.set_ticks(ticks, labels=labels)\",\n \"def _set_ticks(lims, num_ticks):\\n range_ = lims[1] - lims[0]\\n interval = range_ / num_ticks\\n ticks = np.arange(lims[0], lims[1] + interval / 2, interval)\\n return ticks\",\n \"def powerpoint_style2(Axe_tick_size=15,Line_size=3) : \\n fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size)\",\n \"def ticker_wrapper(ticker):\",\n \"def x_formatter_cb( self, ax ):\\n ax.set_xlim( xmin=self.begin_num,xmax=self.end_num )\\n dl = common.PrettyDateLocator()\\n df = common.PrettyDateFormatter( dl )\\n ax.xaxis.set_major_locator( dl )\\n ax.xaxis.set_major_formatter( df )\\n ax.xaxis.set_clip_on(False)\\n sf = common.PrettyScalarFormatter( )\\n ax.yaxis.set_major_formatter( sf )\\n labels = ax.get_xticklabels()\",\n \"def change_axis_ticks(plot, stylesheet=None):\\n from PyQt5 import QtGui\\n\\n font = QtGui.QFont()\\n font.setPointSize(stylesheet[\\\"pixelsize\\\"])\\n plot.getAxis(\\\"bottom\\\").tickFont = font\\n plot.getAxis(\\\"top\\\").tickFont = font\\n plot.getAxis(\\\"right\\\").tickFont = font\\n plot.getAxis(\\\"left\\\").tickFont = font\",\n \"def get_mark(hist, mark, yaxis):\\n from rplot.fixes import ROOT\\n limits = get_limits(hist, xaxis=yaxis)\\n if yaxis:\\n return ROOT.TGaxis(limits[0], mark, limits[1], mark, 0, 0, 0)\\n else:\\n return ROOT.TGaxis(mark, limits[0], mark, 1.05*limits[1], 0, 0, 0)\",\n \"def set_integer_xticks(self, set_ticks = False):\\n self._x_integer_ticks = True\",\n \"def format_ticks(ax, **kwargs):\\n add_minor_x = kwargs.get('add_minor_x', True)\\n add_minor_y = kwargs.get('add_minor_y', True)\\n tickdirection = kwargs.get('tickdirection', 'in') \\n # Default to minor tick every 1/2 of space between\\n # major ticks \\n\\n if add_minor_x:\\n xmajorspace = np.diff(ax.get_xticks())[0] \\n xminorspace = np.abs(xmajorspace/2)\\n xminorspace = kwargs.get('xminorspace', xminorspace)\\n ax.xaxis.set_minor_locator(MultipleLocator(xminorspace))\\n if add_minor_y:\\n ymajorspace = np.diff(ax.get_yticks())[0]\\n yminorspace = np.abs(ymajorspace/2)\\n yminorspace = kwargs.get('yminorspace', yminorspace)\\n ax.yaxis.set_minor_locator(MultipleLocator(yminorspace))\\n\\n for ticktype in ['minor', 'major']:\\n ax.tick_params(axis=\\\"y\\\", which=ticktype, direction=tickdirection)\\n ax.tick_params(axis=\\\"x\\\", which=ticktype, direction=tickdirection)\",\n \"def set_hgps_style(f):\\n #f.set_tick_labels_font(size='small')\\n #f.set_axis_labels_font(size='small')\\n f.ticks.set_xspacing(2)\\n f.ticks.set_yspacing(2)\\n f.ticks.set_linewidth(1.5)\\n f.tick_labels.set_xformat('dd')\\n f.tick_labels.set_yformat('dd')\\n f.tick_labels.set_style('colons')\\n #f.tick_labels.set_font(size='small')\\n f.axis_labels.set_xtext('Right Ascension (deg)')\\n f.axis_labels.set_ytext('Declination (deg)')\",\n \"def fix_ticks(self, noxticks=False, noyticks=False, style=None, N=None,\\n rotate_x=False, rotate_y=False, xticklabels=None, yticklabels=None, \\n oned=True):\\n \\n pl.draw()\\n \\n self.fix_axes_labels()\\n \\n self.fix_axes_ticks(axis='x', N=N, rotate_x=rotate_x) \\n self.fix_axes_ticks(axis='y', N=N, rotate_y=rotate_y)\\n \\n \\n if self.diagonal == 'lower' and oned:\\n self.grid[np.intersect1d(self.left, self.top)[0]].set_yticklabels([])\\n \\n self.remove_all_ticks(noxticks, noyticks)\\n \\n pl.draw()\",\n \"def test_manual_ticks(self):\\n fix_text_kerning_factor()\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n\\n ax.plot(*get_spiral())\\n\\n ax.grid()\\n\\n ax.set_tlabel('Top')\\n ax.set_llabel('Left')\\n ax.set_rlabel('Right')\\n\\n # Specify tick positions manually.\\n ax.taxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])\\n ax.laxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])\\n ax.raxis.set_ticks([0.2, 0.4, 0.6, 0.8, 1.0])\",\n \"def fix_axes_ticks(self, axis='x', style=None, dtype=float, N=None, \\n rotate_x=False, rotate_y=False):\\n \\n # Grab functions we need by name\\n get_lim = \\\"get_{!s}lim\\\".format(axis)\\n get_ticks = \\\"get_{!s}ticks\\\".format(axis)\\n get_ticklabels = \\\"get_{!s}ticklabels\\\".format(axis)\\n set_ticks = \\\"set_{!s}ticks\\\".format(axis)\\n set_ticklabels = \\\"set_{!s}ticklabels\\\".format(axis)\\n shared = eval(\\\"self.share_{!s}\\\".format(axis))\\n \\n # Get locations of ticks on bottom row\\n if axis is 'x':\\n ticks_by_col = []\\n for i in self.bottom:\\n ticks_by_col.append(self.grid[i].get_xticks())\\n \\n # Get locations of ticks on left column\\n if axis is 'y':\\n ticks_by_row = []\\n for i in self.left:\\n ticks_by_row.append(self.grid[i].get_xticks())\\n \\n # Figure out if axes are shared or not\\n if axis == 'x':\\n j = 0\\n if shared:\\n axes = self.xaxes\\n else:\\n axes = np.arange(self.N)\\n elif axis == 'y':\\n j = 1\\n if shared:\\n axes = self.yaxes\\n else:\\n axes = np.arange(self.N)\\n else:\\n raise ValueError('axis must be set to \\\\'x\\\\' or \\\\'y\\\\'')\\n \\n if not shared:\\n return\\n \\n # Loop over axes and make corrections\\n for i in axes:\\n \\n # Skip non-existent elements\\n if self.diagonal:\\n if self.above_diagonal(i):\\n continue\\n \\n if self.grid[i] is None:\\n continue\\n\\n # Retrieve current ticks, tick-spacings, and axis limits\\n ticks = eval(\\\"list(self.grid[{0}].{1!s}())\\\".format(i, get_ticks))\\n\\n if not ticks:\\n continue\\n \\n # Get all the info for current set of ticks\\n ticklabels = eval((\\\"[tick for tick in \\\" +\\\\\\n \\\"self.grid[{0}].{1!s}()]\\\").format(i, get_ticklabels))\\n \\n labels = [] \\n for tick in ticklabels: \\n l = tick.get_text()\\n \\n # Minus signs are weird in unicode...\\n try:\\n assert isinstance(l, unicode)\\n except:\\n new = l\\n else:\\n if u'\\\\u2212' in l:\\n new = '-' + l.encode('ascii', 'ignore')\\n else:\\n new = l.encode('ascii', 'ignore') \\n \\n labels.append(new)\\n \\n Nticks = len(labels) \\n dt = np.diff(ticks)[0] \\n \\n # Axes limits\\n limits = eval(\\\"self.grid[{0}].{1!s}()\\\".format(i, get_lim))\\n \\n # column or row number. Need this to know whether or not to...?\\n pos = self.axis_position(i)[j]\\n\\n # Determine if we're chopping off the first and/or last tick mark\\n # e.g., if the axes are adjoined\\n ul = None\\n if shared and pos < (self.dims[int(not j)] - 1):\\n ul = -1\\n \\n ll = 0 \\n \\n # If number of ticks was specified by hand \\n if N is not None:\\n mi, ma = round(limits[0], 1), round(limits[1], 1)\\n \\n prec = 2\\n while mi == ma:\\n mi, ma = round(limits[0], prec), round(limits[1], prec)\\n prec += 1\\n\\n dt = (ma - mi) / float(N)\\n\\n if dt < 1:\\n dt = np.round(dt, abs(int(np.log10(dt))) + 1)\\n ticks = np.arange(mi, mi + (N+1)*dt, dt)\\n else:\\n ticks = np.round(np.linspace(mi, ma, N), 1)\\n \\n labels = ['{0:g}'.format(val) for val in ticks]\\n \\n if (axis == 'x' and rotate_x):\\n rotate = rotate_x\\n elif (axis == 'y' and rotate_y):\\n rotate = rotate_y\\n else:\\n rotate = False\\n \\n if ul is None:\\n eval(\\\"self.grid[{0}].{1!s}(ticks)\\\".format(i, set_ticks))\\n \\n if rotate:\\n if type(rotate) == bool:\\n eval((\\\"self.grid[{0}].{1!s}(labels, \\\" +\\\\\\n \\\"rotation=90)\\\").format(i, set_ticklabels))\\n else:\\n eval((\\\"self.grid[{0}].{1!s}(labels, \\\" +\\\\\\n \\\"rotation={2:g})\\\").format(i, set_ticklabels,\\\\\\n rotate)) \\n else:\\n eval(\\\"self.grid[{0}].{1!s}(labels)\\\".format(i,\\\\\\n set_ticklabels))\\n else:\\n eval(\\\"self.grid[{0}].{1!s}(ticks[{2}:{3}])\\\".format(i,\\\\\\n set_ticks, ll, ul))\\n\\n if rotate:\\n if type(rotate) == bool:\\n eval((\\\"self.grid[{0}].{1!s}(labels[{2}:{3}], \\\" +\\\\\\n \\\"rotation=90)\\\").format(i, set_ticklabels, ll, ul))\\n else:\\n eval((\\\"self.grid[{0}].{1!s}(labels[{2}:{3}], \\\" +\\\\\\n \\\"rotation={4:g})\\\").format(i, set_ticklabels, ll,\\\\\\n ul, rotate)) \\n else:\\n eval(\\\"self.grid[{0}].{1!s}(labels[{2}:{3}])\\\".format(i,\\\\\\n set_ticklabels, ll, ul))\\n \\n if style is not None: \\n self.grid[i].ticklabel_format(style=style)\\n \\n # Loop over columns, force those not in row 0 to share ticks with \\n # whatever tick marks there are in row #0\\n if axis == 'x':\\n for k in range(len(self.elements_by_column)):\\n loc = self.axis_number(0, k)\\n xticks = self.grid[loc].get_xticks()\\n xticks = [round(tick, 3) for tick in xticks]\\n xlim = [round(lim, 3) for lim in self.grid[loc].get_xlim()]\\n \\n xticks = [0 if abs(tick) < 1e-8 * max(np.abs(xticks)) else tick \\\\\\n for tick in xticks]\\n \\n for h, element in enumerate(self.elements_by_column[k]):\\n if element in self.bottom:\\n continue \\n \\n self.grid[element].set_xticks(xticks)\\n self.grid[element].set_xlim(xlim)\\n \\n # Same deal for y ticks\\n if axis == 'y':\\n for k in range(len(self.elements_by_row)):\\n loc = self.axis_number(k, 0)\\n yticks = self.grid[loc].get_yticks()\\n yticks = [round(tick, 3) for tick in yticks]\\n ylim = [round(lim, 3) for lim in self.grid[loc].get_ylim()]\\n \\n yticks = [0 if abs(tick) < 1e-8 * max(np.abs(yticks)) else tick \\\\\\n for tick in yticks]\\n \\n for h, element in enumerate(self.elements_by_row[k]):\\n if element in self.left:\\n continue \\n if self.diag is not None:\\n if element in self.diag:\\n continue \\n \\n self.grid[element].set_yticks(yticks)\\n self.grid[element].set_ylim(ylim)\\n \\n # Remove ticklabels of interior panels completely\\n if shared:\\n for k in range(self.N):\\n if self.grid[k] is None:\\n continue\\n \\n if (self.diagonal is not None):\\n if self.above_diagonal(k):\\n continue\\n \\n if k not in axes:\\n eval(\\\"self.grid[{0}].{1!s}([])\\\".format(k, set_ticklabels))\\n \\n pl.draw()\",\n \"def config_ticks(self, axis_type, axis_name, ticker, formatter):\\n\\n if axis_name is None:\\n axis_name = self._default_y_name\\n\\n if axis_type not in ('x', 'y'):\\n raise ArgumentError(\\\"Unknown axis type that is not x or y\\\", axis_type=axis_type)\\n\\n if axis_type == 'x':\\n axis = self.figure.xaxis\\n else:\\n axis = self._find_axis(axis_name)\\n\\n axis.ticker = ticker\\n axis.formatter = formatter\",\n \"def figure_style():\\r\\n sns.set(style=\\\"ticks\\\", context=\\\"paper\\\",\\r\\n font=\\\"Arial\\\",\\r\\n rc={\\\"font.size\\\": 7,\\r\\n \\\"axes.titlesize\\\": 8,\\r\\n \\\"axes.labelsize\\\": 7,\\r\\n \\\"axes.linewidth\\\": 0.5,\\r\\n \\\"lines.linewidth\\\": 1,\\r\\n \\\"lines.markersize\\\": 3,\\r\\n \\\"xtick.labelsize\\\": 7,\\r\\n \\\"ytick.labelsize\\\": 7,\\r\\n \\\"savefig.transparent\\\": True,\\r\\n \\\"xtick.major.size\\\": 2.5,\\r\\n \\\"ytick.major.size\\\": 2.5,\\r\\n \\\"xtick.major.width\\\": 0.5,\\r\\n \\\"ytick.major.width\\\": 0.5,\\r\\n \\\"xtick.minor.size\\\": 2,\\r\\n \\\"ytick.minor.size\\\": 2,\\r\\n \\\"xtick.minor.width\\\": 0.5,\\r\\n \\\"ytick.minor.width\\\": 0.5\\r\\n })\\r\\n matplotlib.rcParams['pdf.fonttype'] = 42\\r\\n matplotlib.rcParams['ps.fonttype'] = 42\\r\\n colors = {'sert': sns.color_palette('colorblind')[2],\\r\\n 'wt': sns.color_palette('colorblind')[7],\\r\\n 'left': sns.color_palette('colorblind')[1],\\r\\n 'right': sns.color_palette('colorblind')[0],\\r\\n 'enhanced': sns.color_palette('colorblind')[3],\\r\\n 'suppressed': sns.color_palette('colorblind')[0],\\r\\n 'no-modulation': sns.color_palette('colorblind')[7],\\r\\n 'both-significant': sns.color_palette('colorblind')[2],\\r\\n 'light-significant': sns.color_palette('colorblind')[0],\\r\\n 'stim-significant': sns.color_palette('colorblind')[4]}\\r\\n screen_width = tk.Tk().winfo_screenwidth()\\r\\n dpi = screen_width / 10\\r\\n return colors, dpi\",\n \"def ticks(self, start, end, desired_ticks=None):\\n raise NotImplementedError\",\n \"def setCurve(self, *args):\\n return _libsbml.GeneralGlyph_setCurve(self, *args)\",\n \"def setMath(self, *args):\\n return _libsbml.FunctionTerm_setMath(self, *args)\",\n \"def _patch_intercept_mark():\\n\\n original_intercept_mark = CodeViewText.intercept_mark\\n\\n def _patched_intercept_mark(self, *args):\\n if args[:2] == (\\\"set\\\", \\\"insert\\\") and args[2].endswith(\\\".0\\\"):\\n self.set_insertwidth(3)\\n else:\\n self.set_insertwidth(2)\\n\\n original_intercept_mark(self, *args)\\n\\n CodeViewText.intercept_mark = _patched_intercept_mark\",\n \"def tick_axis_number(ax=None,num_x_major=5,num_x_minor=None,num_y_major=5,\\n num_y_minor=None,change_x=True,change_y=True):\\n ax = gca(ax)\\n if (num_x_minor is None):\\n num_x_minor = 2 * num_x_major\\n if (num_y_minor is None):\\n num_y_minor = 2 * num_y_major\\n if (change_x):\\n axis_locator(ax.xaxis,num_x_major,num_x_minor)\\n if (change_y):\\n axis_locator(ax.yaxis,num_y_major,num_y_minor)\",\n \"def setMath(self, *args):\\n return _libsbml.FunctionDefinition_setMath(self, *args)\",\n \"def setMath(self, *args):\\n return _libsbml.StoichiometryMath_setMath(self, *args)\",\n \"def DrawCheckMark(*args, **kwargs):\\n return _gdi_.PseudoDC_DrawCheckMark(*args, **kwargs)\",\n \"def __init__(self, *args, **kwargs):\\n # Set tick length to zero so azimuthal labels are not too offset\\n # Change default radial axis formatter but keep default theta one\\n super().__init__(*args, **kwargs)\\n formatter = axistools.Formatter('auto')\\n self.yaxis.set_major_formatter(formatter)\\n self.yaxis.isDefault_majfmt = True\\n for axis in (self.xaxis, self.yaxis):\\n axis.set_tick_params(which='both', size=0)\",\n \"def tick(self, tick):\\n pass\",\n \"def tick(self, tick):\\n pass\",\n \"def set_ticks(self, ticks, column=None, row=None, minor=False, \\n round_two=False, oned=True):\\n \\n assert (column is not None) or (row is not None), \\\\\\n \\\"Must supply column or row number!\\\"\\n assert not ((column is not None) and (row is not None)), \\\\\\n \\\"Must supply column *or* row number!\\\"\\n \\n # Could do this more compactly but who cares.\\n if column is not None:\\n elements = self.elements_by_column\\n for j, panel_set in enumerate(elements):\\n for k, panel in enumerate(panel_set):\\n if j != column:\\n continue\\n \\n self.grid[panel].set_xticks(ticks, minor=minor)\\n if (not minor):\\n self.grid[panel].set_xticklabels(list(map(str, ticks)))\\n \\n # Just apply to relevant rows, too.\\n if not round_two:\\n if (column > 0) or oned:\\n self.set_ticks(ticks, row=self.nrows-column-1*oned, minor=minor, \\n round_two=True, oned=oned)\\n else:\\n elements = self.elements_by_row\\n for j, panel_set in enumerate(elements):\\n for k, panel in enumerate(panel_set):\\n if j != row:\\n continue\\n \\n if (panel in self.diag) and oned:\\n continue\\n \\n self.grid[panel].set_yticks(ticks, minor=minor)\\n if (not minor):\\n self.grid[panel].set_yticklabels(list(map(str, ticks)))\\n \\n if not round_two:\\n if (row > 0) or oned:\\n self.set_ticks(ticks, column=self.nrows-row-1*oned, minor=minor, \\n round_two=True, oned=oned)\\n \\n pl.draw()\",\n \"def _lambert_ticks(ax, ticks, tick_location, line_constructor, tick_extractor):\\r\\n outline_patch = sgeom.LineString(ax.outline_patch.get_path().vertices.tolist())\\r\\n axis = find_side(outline_patch, tick_location)\\r\\n n_steps = 30\\r\\n extent = ax.get_extent(ccrs.PlateCarree())\\r\\n _ticks = []\\r\\n for t in ticks:\\r\\n xy = line_constructor(t, n_steps, extent)\\r\\n proj_xyz = ax.projection.transform_points(ccrs.Geodetic(), xy[:, 0], xy[:, 1])\\r\\n xyt = proj_xyz[..., :2]\\r\\n ls = sgeom.LineString(xyt.tolist())\\r\\n locs = axis.intersection(ls)\\r\\n if not locs:\\r\\n tick = [None]\\r\\n else:\\r\\n tick = tick_extractor(locs.xy)\\r\\n _ticks.append(tick[0])\\r\\n # Remove ticks that aren't visible: \\r\\n ticklabels = copy(ticks)\\r\\n while True:\\r\\n try:\\r\\n index = _ticks.index(None)\\r\\n except ValueError:\\r\\n break\\r\\n _ticks.pop(index)\\r\\n ticklabels.pop(index)\\r\\n return _ticks, ticklabels\",\n \"def y_fmt(tick_val,pos): \\n \\n if tick_val > 1000000:\\n val = int(tick_val/1000000)\\n return '{:d}M'.format(val)\\n \\n elif tick_val > 1000:\\n val = int(tick_val/1000)\\n return '{:d}k'.format(val) \\n \\n else: \\n return int(tick_val)\",\n \"def tick(self):\",\n \"def set_sig_figs(n):\\n u.default_format = '.' + str(n) + 'g'\\n pd.options.display.float_format = ('{:,.' + str(n) + '}').format\",\n \"def setModel(self):\\n return cell.ticker.Tickable()\",\n \"def countticks(callable):\\n def wrap(self):\\n deltaT = pygame.time.get_ticks() - self.last_ticks\\n res = callable(self,deltaT)\\n self.last_ticks = pygame.time.get_ticks()\\n return res\\n return wrap\",\n \"def MarkerDefineDefault(self):\\n #self.MarkerDefine(TextView.MARKER_NUM, wx.stc.STC_MARK_ROUNDRECT, wx.BLACK, wx.BLUE)\\n pass\",\n \"def set_all_labels(ax, xax, ra_label, yax, dec_label, roundnum=1):\\n ax.set_xticks(xax)\\n ax.set_xticklabels(np.round(ra_label, roundnum))\\n ax.set_yticks(yax)\\n ax.set_yticklabels(np.round(dec_label, roundnum))\\n ax.set_ylim(yax[0], yax[-1])\\n \\n return ax\",\n \"def powerpoint_style3(fig,Axe_tick_size=15,Line_size=3) : \\n #fig = plt.gcf()\\n def myfunc(x):\\n return hasattr(x, 'set_linewidth')\\n for o in fig.findobj(myfunc):\\n o.set_linewidth(Line_size)\\n \\n def myfunc(x):\\n return hasattr(x, 'set_markersize')\\n for o in fig.findobj(myfunc):\\n o.set_markersize(Line_size+4)\\n def myfunc(x):\\n return hasattr(x, 'set_markeredgewidth')\\n for o in fig.findobj(myfunc):\\n o.set_markeredgewidth(Line_size)\\n for ax in fig.axes:\\n \\n # trouve tous les trucs avec linewidth et les modifie\\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +ax.get_xticklabels() + ax.get_yticklabels()):\\n item.set_fontsize(Axe_tick_size)\\n \\n #for item in ([ax.xaxis.label, ax.yaxis.label]):\\n # item.set_fontsize(Axe_tick_size+5)\\n for line in ax.get_xticklines() + ax.get_yticklines():\\n line.set_markersize(Line_size+2)\\n line.set_markeredgewidth(Line_size) \\n \\n \\n \\n #fig.show()\",\n \"def theme(ax=None, minorticks=False):\\n from matplotlib.ticker import AutoMinorLocator\\n from pylab import rcParams, gca, tick_params\\n if minorticks:\\n if ax is None:\\n ax = gca()\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n tick_params(which='both', width=rcParams['lines.linewidth'])\",\n \"def tickNum(a, xAxis=3, yAxis=3):\\r\\n xlims = [x for x in a.axis()[0:2]]\\r\\n xRange = xlims[1] - xlims[0]\\r\\n ti = xRange/(xAxis-1)\\r\\n a.set_xticks([round(x, 1) for x in numpy.arange(xlims[0], xlims[1]+1, ti)])\\r\\n a.set_xlim([round(x, 1) for x in xlims])\\r\\n \\r\\n ylims = [i for i in a.axis()[2:]]\\r\\n yRange = ylims[1] - ylims[0]\\r\\n ti = yRange/(yAxis-1)\\r\\n a.set_yticks([round(i, 1) for i in numpy.arange(ylims[0], ylims[1]+1, ti)])\\r\\n a.set_ylim([round(i, 1) for i in ylims])\",\n \"def DrawCheckMark(*args, **kwargs):\\n return _gdi_.DC_DrawCheckMark(*args, **kwargs)\",\n \"def test_bool_xticks(self):\\n plot_index = pd.date_range(start=\\\"2000-1-1\\\", freq=\\\"D\\\", periods=10000)\\n freq = 'M'\\n ds = pd.Series(1, index=plot_index)\\n # True when freq market is hit\\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\\n xticks = tl._process(0, 90)\\n tl = formatter.TimestampLocator(plot_index, freq=freq)\\n correct = tl._process(0, 90)\\n tm.assert_almost_equal(xticks, correct)\\n\\n freq = 'MS'\\n ds = pd.Series(1, index=plot_index)\\n # True when freq market is hit\\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\\n xticks = tl._process(3, 94)\\n tl = formatter.TimestampLocator(plot_index, freq=freq)\\n correct = tl._process(3, 94)\\n tm.assert_almost_equal(xticks, correct)\\n\\n freq = 'W'\\n ds = pd.Series(1, index=plot_index)\\n # True when freq market is hit\\n bool_ticks = ds.resample(freq).reindex(plot_index).fillna(0).astype(bool)\\n tl = formatter.TimestampLocator(plot_index, xticks=bool_ticks)\\n xticks = tl._process(3, 94)\\n tl = formatter.TimestampLocator(plot_index, freq=freq)\\n correct = tl._process(3, 94)\\n tm.assert_almost_equal(xticks, correct)\",\n \"def format(self, ticks, numlabels=None, char_width=None, fill_ratio=0.3):\\n return map(str, map(int, ticks))\",\n \"def tick(self):\\n for method in self.on_ticker:\\n getattr(self, method)()\",\n \"def ferret_custom_axes(id):\\n axis_defs = [ None ] * pyferret.MAX_FERRET_NDIM\\n axis_defs[0] = ( 1, 2, 1, \\\"KS,P\\\", False )\\n return axis_defs\",\n \"def do_talbotTicks(\\n ax,\\n axes=\\\"xy\\\",\\n density=(1.0, 1.0),\\n insideMargin=0.05,\\n pointSize=None,\\n tickPlacesAdd={\\\"x\\\": 0, \\\"y\\\": 0},\\n floatAdd={\\\"x\\\": 0, \\\"y\\\": 0},\\n axrange={\\\"x\\\": None, \\\"y\\\": None},\\n colorbar=None, \\n):\\n\\n # get axis limits\\n # aleft = ax.getAxis('left')\\n # abottom = ax.getAxis('bottom')\\n\\n if \\\"y\\\" in axes:\\n yRange = list(ax.get_ylim())\\n if axrange[\\\"y\\\"] is not None: # any overrides\\n for ra in range(0, 2):\\n if axrange[\\\"y\\\"][ra] is not None:\\n yRange[ra] = axrange[\\\"y\\\"][ra]\\n\\n yr = np.diff(yRange)[0]\\n ymin, ymax = (\\n np.min(yRange) - yr * insideMargin,\\n np.max(yRange) + yr * insideMargin,\\n )\\n ytick = ticks.Extended(\\n density=density[1], figure=None, range=(ymin, ymax), axis=\\\"y\\\"\\n )\\n yt = ytick()\\n yts = tickStrings(\\n yt,\\n scale=1,\\n spacing=None,\\n tickPlacesAdd=tickPlacesAdd[\\\"y\\\"],\\n floatAdd=floatAdd[\\\"y\\\"],\\n )\\n # ytickl = [[(y, yts[i]) for i, y in enumerate(yt)] , []] # no minor ticks here\\n if colorbar is not None:\\n colorbar.set_ticks(yt)\\n colorbar.set_ticklabels(yts)\\n else:\\n ax.set_yticks(yt)\\n ax.set_yticklabels(yts) # , rotation='horizontal', fontsize=pointSize)\\n # print ('yt, yts: ', yt, yts)\\n\\n # ytxt = ax.get_yticklabels()\\n ytxt = ax.get_yticks().tolist()\\n ax.yaxis.set_major_locator(matplotlib.ticker.FixedLocator(ytxt))\\n # ax.set_yticklabels([label_format.format(x) for x in ytxt], fontsize=pointSIze,\\n # rotation='horizontal')\\n xRange = list(ax.get_xlim())\\n if axrange[\\\"x\\\"] is not None: # any overrides\\n for ra in range(0, 2):\\n if axrange[\\\"x\\\"][ra] is not None:\\n xRange[ra] = axrange[\\\"x\\\"][ra]\\n # now create substitue tick marks and labels, using Talbot et al algorithm\\n xr = np.diff(xRange)[0]\\n xmin, xmax = (\\n np.min(xRange) - xr * insideMargin,\\n np.max(xRange) + xr * insideMargin,\\n )\\n xtick = ticks.Extended(\\n density=density[0], figure=None, range=(xmin, xmax), axis=\\\"x\\\"\\n )\\n if pointSize is not None:\\n ytxt = ax.get_yticklabels()\\n ax.set_yticklabels(ytxt, fontsize = pointSize, rotation =\\\"horizontal\\\")\\n\\n if \\\"x\\\" in axes:\\n xRange = list(ax.get_xlim())\\n if axrange[\\\"x\\\"] is not None: # any overrides\\n for ra in range(0, 2):\\n if axrange[\\\"x\\\"][ra] is not None:\\n xRange[ra] = axrange[\\\"x\\\"][ra]\\n # now create substitue tick marks and labels, using Talbot et al algorithm\\n xr = np.diff(xRange)[0]\\n xmin, xmax = (\\n np.min(xRange) - xr * insideMargin,\\n np.max(xRange) + xr * insideMargin,\\n )\\n xtick = ticks.Extended(\\n density=density[0], figure=None, range=(xmin, xmax), axis=\\\"x\\\"\\n )\\n xt = xtick()\\n xts = tickStrings(\\n xt,\\n scale=1,\\n spacing=None,\\n tickPlacesAdd=tickPlacesAdd[\\\"x\\\"],\\n floatAdd=floatAdd[\\\"x\\\"],\\n )\\n # xtickl = [[(x, xts[i]) for i, x in enumerate(xt)] , []] # no minor ticks here\\n # x_ticks_labels = ax.set_xticks(xt)\\n # ax.set_xticklabels(xts) # , rotation='horizontal', fontsize=pointSize)\\n if pointSize is not None:\\n xtxt = ax.get_xticklabels()\\n # ax.set_xticklabels(xtxt, fontsize = pointSize, rotation =\\\"horizontal\\\")\",\n \"def __executeActions(self):\\n if 'labelFormat' not in self.options:\\n if self.dim == 2:\\n self.ax.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\\n self.ax.xaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())\\n self.ax.ticklabel_format(**{'style': 'sci', 'scilimits': (0,1), 'useOffset': False, 'axis': 'both'})\\n if 'title' not in self.options:\\n self.ax.set_title(self.name, fontdict={'verticalalignment': 'baseline', 'horizontalalignment': 'center'})\\n for key in self.options:\\n if key in ['how', 'plotSettings', 'figureProperties', 'colorbar']:\\n pass\\n elif key == 'range':\\n if 'ymin' in self.options[key]:\\n self.ax.set_ylim(bottom=ast.literal_eval(self.options[key]['ymin']))\\n if 'ymax' in self.options[key]:\\n self.ax.set_ylim(top=ast.literal_eval(self.options[key]['ymax']))\\n if 'xmin' in self.options[key]:\\n self.ax.set_xlim(left=ast.literal_eval(self.options[key]['xmin']))\\n if 'xmax' in self.options[key]:\\n self.ax.set_xlim(right=ast.literal_eval(self.options[key]['xmax']))\\n if self.dim == 3:\\n if 'zmin' in self.options[key]:\\n self.ax.set_zlim(bottom=ast.literal_eval(self.options[key]['zmin']))\\n if 'zmax' in self.options[key]:\\n self.ax.set_zlim(top=ast.literal_eval(self.options[key]['zmax']))\\n elif key == 'labelFormat':\\n if 'style' not in self.options[key]:\\n self.options[key]['style'] = 'sci'\\n if 'limits' not in self.options[key]:\\n self.options[key]['limits'] = '(0,0)'\\n if 'useOffset' not in self.options[key]:\\n self.options[key]['useOffset'] = 'False'\\n if 'axis' not in self.options[key]:\\n self.options[key]['axis'] = 'both'\\n self.ax.ticklabel_format(**{'style': self.options[key]['style'],\\n 'scilimits': ast.literal_eval(self.options[key]['limits']),\\n 'useOffset': ast.literal_eval(self.options[key]['useOffset']),\\n 'axis': self.options[key]['axis']})\\n elif key == 'camera':\\n if self.dim == 2:\\n self.raiseAWarning('2D plots have not a camera attribute... They are 2D!!!!')\\n else:\\n if 'elevation' in self.options[key] and 'azimuth' in self.options[key]:\\n self.ax.view_init(elev=float(self.options[key]['elevation']), azim=float(self.options[key]['azimuth']))\\n elif 'elevation' in self.options[key] and 'azimuth' not in self.options[key]:\\n self.ax.view_init(elev=float(self.options[key]['elevation']), azim=None)\\n elif 'elevation' not in self.options[key] and 'azimuth' in self.options[key]:\\n self.ax.view_init(elev=None, azim=float(self.options[key]['azimuth']))\\n elif key == 'title':\\n self.ax.set_title(self.options[key]['text'], **self.options[key].get('attributes', {}))\\n elif key == 'scale':\\n major, minor = [int(x) for x in matplotlib.__version__.split('.')[:2]]\\n #matplotlib before 3.5 used nonpos instead of nonpositive\\n useNonpos = (major == 3 and minor < 5)\\n if 'xscale' in self.options[key]:\\n if useNonpos:\\n self.ax.set_xscale(self.options[key]['xscale'], nonposx='clip')\\n elif self.options[key]['xscale'].lower() == 'log':\\n self.ax.set_xscale(self.options[key]['xscale'], nonpositive='clip')\\n else:\\n self.ax.set_xscale(self.options[key]['xscale'])\\n if 'yscale' in self.options[key]:\\n if useNonpos:\\n self.ax.set_yscale(self.options[key]['yscale'], nonposy='clip')\\n elif self.options[key]['yscale'].lower() == 'log':\\n self.ax.set_yscale(self.options[key]['yscale'], nonpositive='clip')\\n else:\\n self.ax.set_yscale(self.options[key]['yscale'])\\n if self.dim == 3:\\n if 'zscale' in self.options[key]:\\n self.ax.set_zscale(self.options[key]['zscale'])\\n elif key == 'addText':\\n if 'position' not in self.options[key]:\\n if self.dim == 2:\\n self.options[key]['position'] = '0.0,0.0'\\n else:\\n self.options[key]['position'] = '0.0,0.0,0.0'\\n if 'withdash' not in self.options[key]:\\n self.options[key]['withdash'] = 'False'\\n if 'fontdict' not in self.options[key]:\\n self.options[key]['fontdict'] = 'None'\\n else:\\n try:\\n tempVar = ast.literal_eval(self.options[key]['fontdict'])\\n self.options[key]['fontdict'] = str(tempVar)\\n except AttributeError:\\n self.raiseAnError(TypeError, f'In {key} tag: can not convert the string \\\"{self.options[key][\\\"fontdict\\\"]}\\\" to a dictionary! Check syntax for python function ast.literal_eval')\\n if self.dim == 2 :\\n self.ax.text(float(self.options[key]['position'].split(',')[0]),\\n float(self.options[key]['position'].split(',')[1]),\\n self.options[key]['text'],\\n fontdict=ast.literal_eval(self.options[key]['fontdict']),\\n **self.options[key].get('attributes', {}))\\n else:\\n self.ax.text(float(self.options[key]['position'].split(',')[0]),\\n float(self.options[key]['position'].split(',')[1]),\\n float(self.options[key]['position'].split(',')[2]),\\n self.options[key]['text'],\\n fontdict=ast.literal_eval(self.options[key]['fontdict']),\\n **self.options[key].get('attributes', {}))\\n elif key == 'autoscale':\\n if 'enable' not in self.options[key]:\\n self.options[key]['enable'] = 'True'\\n elif utils.stringIsTrue(self.options[key]['enable']):\\n self.options[key]['enable'] = 'True'\\n elif utils.stringIsFalse(self.options[key]['enable']):\\n self.options[key]['enable'] = 'False'\\n if 'axis' not in self.options[key]:\\n self.options[key]['axis'] = 'both'\\n if 'tight' not in self.options[key]:\\n self.options[key]['tight'] = 'None'\\n self.ax.autoscale(enable=ast.literal_eval(self.options[key]['enable']),\\n axis=self.options[key]['axis'],\\n tight=ast.literal_eval(self.options[key]['tight']))\\n elif key == 'horizontalLine':\\n if self.dim == 3:\\n self.raiseAWarning('horizontalLine not available in 3-D plots!!')\\n else:\\n if 'y' not in self.options[key]:\\n self.options[key]['y'] = '0'\\n if 'xmin' not in self.options[key]:\\n self.options[key]['xmin'] = '0'\\n if 'xmax' not in self.options[key]:\\n self.options[key]['xmax'] = '1'\\n if 'hold' not in self.options[key]:\\n self.options[key]['hold'] = 'None'\\n self.ax.axhline(y=ast.literal_eval(self.options[key]['y']),\\n xmin=ast.literal_eval(self.options[key]['xmin']),\\n xmax=ast.literal_eval(self.options[key]['xmax']),\\n hold=ast.literal_eval(self.options[key]['hold']),\\n **self.options[key].get('attributes', {}))\\n elif key == 'verticalLine':\\n if self.dim == 3:\\n self.raiseAWarning('verticalLine not available in 3-D plots!!')\\n else:\\n if 'x' not in self.options[key]:\\n self.options[key]['x'] = '0'\\n if 'ymin' not in self.options[key]:\\n self.options[key]['ymin'] = '0'\\n if 'ymax' not in self.options[key]:\\n self.options[key]['ymax'] = '1'\\n if 'hold' not in self.options[key]:\\n self.options[key]['hold'] = 'None'\\n self.ax.axvline(x=ast.literal_eval(self.options[key]['x']),\\n ymin=ast.literal_eval(self.options[key]['ymin']),\\n ymax=ast.literal_eval(self.options[key]['ymax']),\\n hold=ast.literal_eval(self.options[key]['hold']),\\n **self.options[key].get('attributes', {}))\\n elif key == 'horizontalRectangle':\\n if self.dim == 3:\\n self.raiseAWarning('horizontalRectangle not available in 3-D plots!!')\\n else:\\n if 'ymin' not in self.options[key]:\\n self.raiseAnError(IOError, 'ymin parameter is needed for function horizontalRectangle!!')\\n if 'ymax' not in self.options[key]:\\n self.raiseAnError(IOError, 'ymax parameter is needed for function horizontalRectangle!!')\\n if 'xmin' not in self.options[key]:\\n self.options[key]['xmin'] = '0'\\n if 'xmax' not in self.options[key]:\\n self.options[key]['xmax'] = '1'\\n self.ax.axhspan(ast.literal_eval(self.options[key]['ymin']),\\n ast.literal_eval(self.options[key]['ymax']),\\n xmin=ast.literal_eval(self.options[key]['xmin']),\\n xmax=ast.literal_eval(self.options[key]['xmax']),\\n **self.options[key].get('attributes', {}))\\n elif key == 'verticalRectangle':\\n if self.dim == 3:\\n self.raiseAWarning('vertical_rectangle not available in 3-D plots!!')\\n else:\\n if 'xmin' not in self.options[key]:\\n self.raiseAnError(IOError, 'xmin parameter is needed for function verticalRectangle!!')\\n if 'xmax' not in self.options[key]:\\n self.raiseAnError(IOError, 'xmax parameter is needed for function verticalRectangle!!')\\n if 'ymin' not in self.options[key]:\\n self.options[key]['ymin'] = '0'\\n if 'ymax' not in self.options[key]:\\n self.options[key]['ymax'] = '1'\\n self.ax.axvspan(ast.literal_eval(self.options[key]['xmin']),\\n ast.literal_eval(self.options[key]['xmax']),\\n ymin=ast.literal_eval(self.options[key]['ymin']),\\n ymax=ast.literal_eval(self.options[key]['ymax']),\\n **self.options[key].get('attributes', {}))\\n elif key == 'axesBox':\\n if self.dim == 3:\\n self.raiseAWarning('axesBox not available in 3-D plots!!')\\n else:\\n self.ax.set_frame_on(self.options[key][key])\\n elif key == 'axis':\\n self.ax.axis(self.options[key][key])\\n elif key == 'grid':\\n if 'b' not in self.options[key]:\\n self.options[key]['b'] = 'off'\\n if utils.stringIsTrue(self.options[key]['b']):\\n self.options[key]['b'] = 'on'\\n elif utils.stringIsFalse(self.options[key]['b']):\\n self.options[key]['b'] = 'off'\\n if 'which' not in self.options[key]:\\n self.options[key]['which'] = 'major'\\n if 'axis' not in self.options[key]:\\n self.options[key]['axis'] = 'both'\\n if self.dim == 2:\\n self.ax.grid(b=self.options[key]['b'],\\n which=self.options[key]['which'],\\n axis=self.options[key]['axis'],\\n **self.options[key].get('attributes', {}))\\n else:\\n self.ax.grid(b=self.options[key]['b'], **self.options[key].get('attributes', {}))\\n else:\\n self.raiseAWarning(f'Attempting to perform action {key}. If this does not work, check manual and relevant matplotlib method specification.')\\n kwargs = {}\\n for taco in self.options[key]:\\n if taco != 'attributes' and taco != key:\\n try:\\n kwargs[taco] = ast.literal_eval(self.options[key][taco])\\n except ValueError:\\n kwargs[taco] = self.options[key][taco]\\n try:\\n customFunctionCall = getattr(self.ax, key)\\n self.actPlot = customFunctionCall(**kwargs)\\n except AttributeError as ae:\\n self.raiseAnError(RuntimeError, f'<{str(ae)}> -> in executing custom action \\\"{key}\\\" in Plot {self.name}.\\\\n {self.printTag} command has been called in the following way: ax.{key}(**{str(kwargs)})')\",\n \"def tick_values(self, vmin, vmax):\\n raise NotImplementedError('Derived must override')\",\n \"def setMath(self, *args):\\n return _libsbml.EventAssignment_setMath(self, *args)\",\n \"def setMath(self, *args):\\n return _libsbml.Trigger_setMath(self, *args)\",\n \"def setTickNumber(n=2, axes='XYZ'):\\n dislin.ticks(n, axes)\",\n \"def get_ticks(self, sig=2, n_tick=10):\\n fmt = '%.' + str(sig) + 'g'\\n xlabels = np.zeros(self.x_axis.shape, dtype=object)\\n xlabels[:] = \\\"\\\"\\n each_n_pixels = math.floor(len(xlabels) / n_tick)\\n for i in range(len(xlabels)):\\n if i % each_n_pixels == 0:\\n xlabels[i] = '%s' % float(fmt % self.x_axis[i])\\n ylabels = np.zeros(self.y_axis.shape, dtype=object)\\n ylabels[:] = \\\"\\\"\\n each_n_pixels = math.floor(len(ylabels) / n_tick)\\n for i in range(len(ylabels)):\\n if i % each_n_pixels == 0:\\n ylabels[i] = '%s' % float(fmt % self.y_axis[i])\\n return xlabels, ylabels\",\n \"def get_special_kpoint_ticks(kpoints: list[tuple[str, float]], math_mode: str = '$') -> tuple[list[float], list[str]]:\\n if kpoints is None:\\n kpoints = []\\n\\n ticks = []\\n ticklabels = []\\n for label, position in kpoints:\\n if label.lower() in ('gamma', 'g'):\\n label = rf'{math_mode}\\\\Gamma{math_mode}'\\n ticklabels.append(label)\\n ticks.append(position)\\n\\n return ticks, ticklabels\",\n \"def diff_gdef_mark(font_before, font_after):\\n return _gdef(font_before, font_after, \\\"gdef_mark\\\")\",\n \"def __init__(self, *args, **kwargs):\\n # Impose default formatter\\n super().__init__(*args, **kwargs)\\n formatter = axistools.Formatter('auto')\\n self.xaxis.set_major_formatter(formatter)\\n self.yaxis.set_major_formatter(formatter)\\n self.xaxis.isDefault_majfmt = True\\n self.yaxis.isDefault_majfmt = True\\n # Custom attributes\\n self._datex_rotated = False # whether manual rotation has been applied\\n self._dualy_arg = None # for scaling units on opposite side of ax\\n self._dualx_arg = None\\n self._dualy_cache = None # prevent excess _dualy_overrides calls\\n self._dualx_cache = None\",\n \"def get_tick():\\n return _tick\",\n \"def major_ticks(self, startint=None, majorint=None):\\n\\n\\t# Set major interval if not supplied #\\n\\n\\tif majorint:\\n assert type(majorint) == int\\n else: \\n majorint = myroundup(len(self.data_dt[1]) / 7.) \\n\\n\\tprint 'major tick interval:', majorint \\n\\n\\t# Determine the ticks #\\n\\n\\tif startint:\\n assert type(startint) == int\\n else:\\n startint = 0\\n\\ttick_points = range(startint, len(self.data_orig[:]), majorint) \\n\\n\\tformats = {'YEARLY': '%y',\\n 'MONTHLY': '%b %y',\\n 'WEEKLY': '%d/%m/%y',\\n 'DAILY': '%d/%m/%y',\\n 'HOURLY': '%m/%d %H:%M',\\n 'MINUTELY': '%m/%d %H:%M',\\n 'SECONDLY': '%m/%d %H:%M'}\\n\\n\\tmajor_xticks = {}\\n\\tmajor_xlabels = {}\\n\\tcount = 0\\n\\tfor row in range(1, self.nrows+1):\\n\\t xticks = []\\n\\t labels = []\\n\\t for index, dt in enumerate(self.data_dt[row]):\\n \\tplace = index + count\\n \\tif place in tick_points:\\n \\t xticks.append(dates.date2num(dt))\\n \\t labels.append(dt.strftime(formats[self.freq])) \\n\\n major_xticks[row] = xticks\\n major_xlabels[row] = labels\\n count = count + len(self.data_dt[row])\\n\\n\\treturn major_xticks, major_xlabels\",\n \"def setMath(self, *args):\\n return _libsbml.Priority_setMath(self, *args)\",\n \"def test_opposite_ticks(self):\\n fix_text_kerning_factor()\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(projection='ternary')\\n\\n ax.taxis.set_ticks_position('tick2')\\n ax.laxis.set_ticks_position('tick2')\\n ax.raxis.set_ticks_position('tick2')\\n\\n ax.set_tlabel('Top')\\n ax.set_llabel('Left')\\n ax.set_rlabel('Right')\",\n \"def value_line(self):\\n marks = self._get_marks(False)\\n marks['Val'] = self.data['Value']\\n fig = plt.figure(figsize=(4,2), dpi=200)\\n fig.patch.set_facecolor('#ececec')\\n ax = fig.add_subplot(111)\\n ax.plot(self.data['Value'], alpha=0.8, lw=1.2, color=\\\"green\\\", label='Value')\\n ax.scatter([x for x in marks[marks['Marks']>0].index], marks[marks['Marks']>0]['Val'], marker='^', s=20, c=\\\"b\\\", label=\\\"Buy\\\")\\n ax.scatter([x for x in marks[marks['Marks']<0].index], marks[marks['Marks']<0]['Val'], marker='v', s=20, c=\\\"r\\\", label=\\\"Sell\\\")\\n ax.set_xlabel('Time')\\n ax.set_ylabel('Portfolio\\\\'s Value (€)')\\n ax.set_title('Portfolio\\\\'s Value (€) - Daily')\\n ax.xaxis.set_major_locator(dates.MonthLocator())\\n ax.xaxis.set_major_formatter(dates.DateFormatter('%b-%Y'))\\n for x, y, mark in zip(marks.index, marks['Val'], marks['Marks']):\\n a = ax.get_ylim()\\n if x == marks.index[0]:\\n ax.annotate(str(mark) + \\\" €\\\", xy=(x + timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 80), y + (a[1]-a[0])/35), fontsize=5)\\n else:\\n if mark > 0:\\n ax.annotate(str(mark) + \\\" €\\\", xy=(x + timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 60), y - (a[1]-a[0])/35), fontsize=5)\\n else:\\n ax.annotate(str(mark) + \\\" €\\\", xy=(x - timedelta(abs((self.data.index[0] - self.data.index[-1]).days) / 15), y + (a[1]-a[0])/35), fontsize=5)\\n ax.grid(True)\\n fig.autofmt_xdate()\\n ax.legend()\\n return fig, ax\",\n \"def _nice_axes(self, ax):\\n ax.ticklabel_format(axis='y', style='sci', scilimits=(-2, 3))\\n pstyle.set_xaxis_label(ax)\\n try:\\n pstyle.set_xLimits(self.twiss_df.SEQUENCE, ax)\\n except pstyle.ArgumentError:\\n pass\\n if self._ip_pos is not None and len(self._ip_pos) > 0:\\n pstyle.show_ir(self._ip_pos, ax)\",\n \"def setTickPosition(position='sameaslabels', axes='XYZ'):\\n tickdict = {'sameaslabels':'LABELS', 'inside':'REVERS','center':'CENTER'}\\n dislin.ticpos(tickdict[position],axes)\",\n \"def getCurveExplicitlySet(self):\\n return _libsbml.GeneralGlyph_getCurveExplicitlySet(self)\",\n \"def func_plot_fmt_map():\\n # line_styles = ['o-', 'x-', '*-', '-_', 'D-', 'h-', '+-', 's-', 'v-', \\n # ',-', '1-']\\n func_tuples = get_func_tuples()\\n M = {k:v for (k, _, v) in func_tuples}\\n return M\",\n \"def draw_ticklabels(self):\\n for item in self._ax.get_xticklabels() + self._ax.get_yticklabels():\\n self._ax.draw_artist(item)\\n # self._fig.canvas.update() ## Qt4Agg\\n self._fig.canvas.draw() ## TKAgg\\n self._fig.canvas.flush_events() # Fixes bug with Qt4Agg backend\",\n \"def set_style(usetex=False):\\n plt.rc('text', usetex=usetex)\\n plt.rc('font', family='Serif')\\n\\n\\n mpl.rcParams['figure.figsize'] = [10, 7]\\n mpl.rcParams['font.size'] = 17\\n\\n mpl.rcParams['savefig.dpi'] = 150\\n mpl.rcParams['xtick.minor.visible'] = True\\n mpl.rcParams['ytick.minor.visible'] = True\\n mpl.rcParams['xtick.direction'] = 'in'\\n mpl.rcParams['ytick.direction'] = 'in'\\n\\n mpl.rcParams['xtick.top'] = True\\n mpl.rcParams['ytick.right'] = True\\n\\n mpl.rcParams['xtick.major.size'] = 6\\n mpl.rcParams['xtick.minor.size'] = 3\\n\\n mpl.rcParams['ytick.major.size'] = 6\\n mpl.rcParams['ytick.minor.size'] = 3\\n\\n mpl.rcParams['xtick.labelsize'] = 13\\n mpl.rcParams['ytick.labelsize'] = 13\",\n \"def _nice(x, round=False):\\n if x <= 0:\\n import warnings\\n warnings.warn(\\\"Invalid (negative) range passed to tick interval calculation\\\")\\n x = abs(x)\\n expv = floor(log10(x))\\n f = x / pow(10, expv)\\n if round:\\n if f < 1.75:\\n nf = 1.0\\n elif f < 3.75:\\n nf = 2.5\\n elif f < 7.0:\\n nf = 5.0\\n else:\\n nf = 10.0\\n else:\\n if f <= 1.0:\\n nf = 1.0\\n elif f <= 2.5:\\n nf = 2.5\\n elif f <= 5.0:\\n nf = 5.0\\n else:\\n nf = 10.0\\n return nf * pow(10, expv)\",\n \"def disable_ticks(\\n ax: Any,\\n) -> None:\\n\\n ax.tick_params(\\n axis=\\\"both\\\",\\n which=\\\"both\\\",\\n top=False,\\n bottom=False,\\n left=False,\\n right=False,\\n labelbottom=False,\\n labelleft=False,\\n )\",\n \"def _index_tick(x, pos):\\n if x.is_integer() or isinstance(x, int):\\n # Use the integer value (fixed weird 'close to integer value bug')\\n iloc = int(x)\\n if iloc < 0 or iloc >= len(index):\\n return \\\"\\\"\\n tick_val = index[iloc]\\n else:\\n # Interpolate\\n iloc_low = int(floor(x))\\n iloc_high = int(ceil(x))\\n if iloc_low < 0 or iloc_high >= len(index):\\n return \\\"\\\"\\n low = index[iloc_low]\\n high = index[iloc_high]\\n\\n tick_val = low * (x - iloc_low) + high * (1 - x + iloc_low)\\n\\n # Format tick value\\n return f\\\"{tick_val:.{tick_label_precision}f}\\\"\",\n \"def newplot(*args, **kwargs):\\n\\n if 'linewidth' and 'lw' not in kwargs.keys():\\n kwargs['linewidth'] = 2\\n\\n plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI)\\n plt.plot(*args, **kwargs)\\n\\n plt.setp(plt.gca().spines.values(), linewidth=2)\\n plt.xticks(fontsize=25, fontname='Times New Roman')\\n plt.yticks(fontsize=25, fontname='Times New Roman')\\n plt.ticklabel_format(useOffset=False)\\n plt.ticklabel_format(style='sci', scilimits=(-3, 3))\",\n \"def ticker(self, symbol, **kwargs):\\n pass\",\n \"def get_tickrate(self):\\n raise NotImplementedError\",\n \"def testAdjustSingleLabelDoesNothing(self):\\n self.AddToChart(self.chart, (5, 6, 7))\\n self.chart.left.labels = ['Cutoff']\\n self.chart.left.label_positions = [3]\\n def CheckExpectations():\\n self.assertEqual(self.Param('chxl'), '0:|Cutoff')\\n self.assertEqual(self.Param('chxp'), '0,3')\\n CheckExpectations() # Check without adjustment\\n self.chart.AddFormatter(formatters.LabelSeparator(right=15))\\n CheckExpectations() # Make sure adjustment hasn't changed anything\",\n \"def _format_default_functions(self):\\n self._out_formatter = null_out_formatter\\n self._f_default_names = lambda x: [0]\",\n \"def setAxisTickColor(idx=-1, axes='XYZ'):\\n dislin.axclrs(idx, 'TICKS', axes)\",\n \"def get_xticks_labels(self):\\n xticks = np.arange(-1, self.space_between_glyphs * len(self.positions))\\n xticklabels = [' ']\\n for p in self.positions:\\n xticklabels.append(str(p))\\n xticklabels += [' '] * self.space_between_glyphs\\n return xticks, xticklabels\",\n \"def update_tick(self, tick: InstigatorTick):\",\n \"def dmark(value):\\n return mark_safe(DMark().convert(value))\",\n \"def set_xticks(self, array, extent, units, symmetric_around_centre=False):\\n\\n plt.tick_params(labelsize=self.xsize)\\n\\n if symmetric_around_centre:\\n return\\n\\n xticks = np.linspace(extent[0], extent[1], 5)\\n\\n if self.x_manual is not None:\\n xtick_labels = np.asarray([self.x_manual[0], self.x_manual[3]])\\n elif not units.use_scaled:\\n xtick_labels = np.linspace(0, array.shape_2d[0], 5).astype(\\\"int\\\")\\n elif units.use_scaled and units.conversion_factor is None:\\n xtick_labels = np.round(np.linspace(extent[0], extent[1], 5), 2)\\n elif units.use_scaled and units.conversion_factor is not None:\\n xtick_labels = np.round(\\n np.linspace(\\n extent[0] * units.conversion_factor,\\n extent[1] * units.conversion_factor,\\n 5,\\n ),\\n 2,\\n )\\n\\n else:\\n raise exc.PlottingException(\\n \\\"The y and y ticks cannot be set using the input options.\\\"\\n )\\n\\n plt.xticks(ticks=xticks, labels=xtick_labels)\",\n \"def generateLabelsTicks(posns):\\n if len(posns) <= 10:\\n return labelsTicks(posns, 1)\\n elif len(posns) <= 50:\\n return labelsTicks(posns, 5)\\n else:\\n return labelsTicks(posns, 10)\",\n \"def y_formatter_cb(self, ax):\\n # y_vals should be the y-location of the labels.\\n labels = getattr( self, 'labels', [] )\\n labels = list(labels); #labels.reverse()\\n y_vals = numpy.arange(.5,len(labels)+.5,1)\\n\\n # Locations should be fixed.\\n fl = FixedLocator( y_vals )\\n # Make the formatter for the y-axis\\n ff = FixedFormatter( labels )\\n ax.yaxis.set_major_formatter( ff )\\n ax.yaxis.set_major_locator( fl )\",\n \"def getOnsetTick(s):\\n ticksPerQuarter = getResolution(s)\\n onsets = [int(n.offset * ticksPerQuarter) for n in s.flat.notes]\\n return onsets\",\n \"def render_ticks(axis, labelsize):\\n axis.get_xaxis().set_tick_params(\\n which='both', direction='in', width=1.5, labelrotation=0, labelsize=labelsize)\\n axis.get_yaxis().set_tick_params(\\n which='both', direction='in', width=1.5, labelcolor='k', labelsize=labelsize)\\n # axis.grid(color='r', linestyle='-.', linewidth=0.5, alpha=0.3, which='both', axis='both')\",\n \"def onAxisMajorTicksChanged(self, axis_name, value):\\n if axis_name in self.axes:\\n self.axes[axis_name].setTickCount(value)\",\n \"def xFormat(self, formatFnc, label=None, options=None, isPyData=False):\\r\\n return self\",\n \"def to_ticks(self, *args, **kwargs):\\n return _uhd_swig.time_spec_t_to_ticks(self, *args, **kwargs)\",\n \"def setMath(self, *args):\\n return _libsbml.Delay_setMath(self, *args)\",\n \"def set(self):\\n\\n if self.tick_values is None and self.tick_labels is None:\\n cb = plt.colorbar(fraction=self.fraction, pad=self.pad)\\n elif self.tick_values is not None and self.tick_labels is not None:\\n cb = plt.colorbar(\\n fraction=self.fraction, pad=self.pad, ticks=self.tick_values\\n )\\n cb.ax.set_yticklabels(labels=self.tick_labels)\\n else:\\n raise exc.PlottingException(\\n \\\"Only 1 entry of tick_values or tick_labels was input. You must either supply\\\"\\n \\\"both the values and labels, or neither.\\\"\\n )\\n\\n cb.ax.tick_params(labelsize=self.ticksize)\",\n \"def setCurve(self, *args):\\n return _libsbml.ReactionGlyph_setCurve(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6055695","0.5834575","0.5709799","0.5684322","0.56447107","0.5592472","0.5586648","0.55707574","0.55437565","0.55194885","0.54999316","0.5466122","0.5416735","0.539491","0.53574145","0.5304559","0.5293611","0.5277207","0.52736354","0.5267641","0.524143","0.5229542","0.5227914","0.5211003","0.5203765","0.51941717","0.51349497","0.51221764","0.5108008","0.510781","0.50973606","0.50958353","0.5074098","0.5057962","0.50511867","0.5033653","0.50118077","0.5004562","0.5004562","0.49800986","0.4973674","0.49578953","0.49573648","0.49537247","0.49448135","0.49434265","0.49403888","0.492129","0.49207217","0.49205884","0.4916859","0.49127805","0.49110666","0.4909443","0.49067274","0.4880418","0.48787045","0.48774347","0.48723304","0.48694247","0.48647895","0.4864636","0.48536116","0.48528385","0.48480314","0.4846824","0.48392582","0.4835359","0.48132682","0.4790585","0.47901922","0.4786894","0.4782931","0.4777603","0.47669035","0.475488","0.4752098","0.47501317","0.47491705","0.4746726","0.47370565","0.47366408","0.47287083","0.47243744","0.4711499","0.47087356","0.470611","0.46984237","0.4690421","0.46825466","0.4675851","0.46694067","0.46678546","0.46651357","0.4664471","0.4654055","0.4652742","0.4649782","0.46438488","0.46428418"],"string":"[\n \"0.6055695\",\n \"0.5834575\",\n \"0.5709799\",\n \"0.5684322\",\n \"0.56447107\",\n \"0.5592472\",\n \"0.5586648\",\n \"0.55707574\",\n \"0.55437565\",\n \"0.55194885\",\n \"0.54999316\",\n \"0.5466122\",\n \"0.5416735\",\n \"0.539491\",\n \"0.53574145\",\n \"0.5304559\",\n \"0.5293611\",\n \"0.5277207\",\n \"0.52736354\",\n \"0.5267641\",\n \"0.524143\",\n \"0.5229542\",\n \"0.5227914\",\n \"0.5211003\",\n \"0.5203765\",\n \"0.51941717\",\n \"0.51349497\",\n \"0.51221764\",\n \"0.5108008\",\n \"0.510781\",\n \"0.50973606\",\n \"0.50958353\",\n \"0.5074098\",\n \"0.5057962\",\n \"0.50511867\",\n \"0.5033653\",\n \"0.50118077\",\n \"0.5004562\",\n \"0.5004562\",\n \"0.49800986\",\n \"0.4973674\",\n \"0.49578953\",\n \"0.49573648\",\n \"0.49537247\",\n \"0.49448135\",\n \"0.49434265\",\n \"0.49403888\",\n \"0.492129\",\n \"0.49207217\",\n \"0.49205884\",\n \"0.4916859\",\n \"0.49127805\",\n \"0.49110666\",\n \"0.4909443\",\n \"0.49067274\",\n \"0.4880418\",\n \"0.48787045\",\n \"0.48774347\",\n \"0.48723304\",\n \"0.48694247\",\n \"0.48647895\",\n \"0.4864636\",\n \"0.48536116\",\n \"0.48528385\",\n \"0.48480314\",\n \"0.4846824\",\n \"0.48392582\",\n \"0.4835359\",\n \"0.48132682\",\n \"0.4790585\",\n \"0.47901922\",\n \"0.4786894\",\n \"0.4782931\",\n \"0.4777603\",\n \"0.47669035\",\n \"0.475488\",\n \"0.4752098\",\n \"0.47501317\",\n \"0.47491705\",\n \"0.4746726\",\n \"0.47370565\",\n \"0.47366408\",\n \"0.47287083\",\n \"0.47243744\",\n \"0.4711499\",\n \"0.47087356\",\n \"0.470611\",\n \"0.46984237\",\n \"0.4690421\",\n \"0.46825466\",\n \"0.4675851\",\n \"0.46694067\",\n \"0.46678546\",\n \"0.46651357\",\n \"0.4664471\",\n \"0.4654055\",\n \"0.4652742\",\n \"0.4649782\",\n \"0.46438488\",\n \"0.46428418\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60170686"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":78498,"cells":{"query":{"kind":"string","value":"Return the range (min, max) of a dataset, excluding any NANs."},"document":{"kind":"string","value":"def calcrange(data, log=False):\n xmin, xmax = None, None\n for x in data:\n if not log or x > 0.:\n if xmin is None or x < xmin: xmin = x\n if xmax is None or x > xmax: xmax = x\n\n if xmin is None and xmax is None:\n if log:\n return 0.1, 1.\n else:\n return 0., 1.\n else:\n return xmin, xmax"},"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 data_range(x):\n return max(x)-min(x)","def _full_value_range(self):\n min_value, max_value = self._raw_data.data_range\n return max_value - min_value","def _computeRangeFromData(data):\n if data is None:\n return None\n\n dataRange = min_max(data, min_positive=True, finite=True)\n if dataRange.minimum is None: # Only non-finite data\n return None\n\n if dataRange is not None:\n min_positive = dataRange.min_positive\n if min_positive is None:\n min_positive = float('nan')\n return dataRange.minimum, min_positive, dataRange.maximum","def data_range(xs: List[float]) -> float:\n return max(xs) - min(xs)","def get_range(cls, data: tuple or list) -> float:\n cls._data_validation(data)\n max_ = cls.get_max(data)\n min_ = cls.get_min(data)\n return float(max_ - min_)","def range(series):\n return min(series), max(series)","def range(self):\n lows, highs = [], []\n for graph in self._graphs.values():\n low, high = graph.range()\n lows.append(low)\n highs.append(high)\n return (min(lows), max(highs))","def find_min_max(data):\n v = [i[1] for i in data]\n extremes = [min(v), max(v)]\n logging.info('Calculated extremes: %s', extremes)\n return extremes","def get_range(df, col):\n return df[col].min(), df[col].max()","def getColorRange(self):\n vmax=self.data_matrix.max()\n vmin=self.data_matrix.min()\n\n if vmax * vmin < 0: # ie number range spans +ve and -ve\n vmax = max([vmax, abs(vmin)])\n vmin = -1*vmax\n\n return vmax,vmin","def findRanges(data_grouped):\n ranges = []\n for i in data_grouped.columns:\n theRange = (data_grouped[i].min(), data_grouped[i].max())\n ranges.append(theRange)\n return ranges","def in_range(data, minval=-np.inf, maxval=np.inf):\n return (minval <= data) & (data <= maxval)","def limits(self):\n\n\t\treturn [\n\t\t\tmin(self.xvalues),\n\t\t\tmax(self.xvalues),\n\t\t\tmin(self.yvalues),\n\t\t\tmax(self.yvalues)]","def range(x):\n try:\n return (min(min(y) for y in x), max(max(y) for y in x))\n except ValueError:\n return (None, None)","def m_to_range(self, data):\n return (data - self._min_range_m) / self._total_range","def get_range(lst):\n return float(max(lst)) - float(min(lst))","def ex_range(data):\n a, b, step = _cleanse_range_args(data)\n return list(range(a, b+sign(step), step))","def clip_range(x, xlim):\n return min([max([x, xlim[0]]), xlim[1]])","def min_max(xs):\n return min(xs), max(xs)","def range(df):\r\n\r\n\tdf_range_dict = dict()\r\n\r\n\tfor i, col in enumerate(df.columns):\r\n\t\tdf_range_dict[col] = [df[col].max(), df[col].min(), df[col].max() - df[col].min()]\r\n\r\n\tdf_range = pd.DataFrame(df_range_dict, index=['Max Value', 'Min Value', 'Range (Max - Min)'])\r\n\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\r\n\r\n\treturn df_range","def calcrange(a4lim,data):\r\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\r\n return a4range","def _bound(x, min_value, max_value):\n return np.maximum(min_value, np.minimum(x, max_value))","def minmax(self):\n return self._data_lim[self._n_overlay - 1]","def minmax(data):\n smallest = data[0]\n largest = data[0]\n\n for i in range(0,len(data)):\n if data[i] < smallest:\n smallest = data[i]\n elif data[i] > largest:\n largest = data[i]\n\n return(smallest,largest)","def min_max_outliers(res, min=None, max=None):\n min_max_list = []\n if isinstance(min, (int, float)):\n data1 = res[res < min].reset_index()\n data1['limit type'] = 'minimum'\n data1['limit'] = min\n min_max_list.append(data1)\n if isinstance(max, (int, float)):\n data1 = res[res > max].reset_index()\n data1['limit type'] = 'maximum'\n data1['limit'] = max\n min_max_list.append(data1)\n\n min_max1 = pd.concat(min_max_list)\n\n return min_max1","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def remove_out_of_bounds(self, data, low_bound, high_bound):\n data = data.dropna()\n data = data[(data > low_bound).all(axis=1) & (data < high_bound).all(axis=1)] \n return data","def get_range(self, field, deep=False, axis=None):\n variables = list(self.vars(deep, with_name=field))\n\n if not variables:\n raise KeyError(\"No variable named '%s' was found!\" % field)\n\n start = [np.nanmin(self[var], axis).item(0) for var in variables]\n end = [np.nanmax(self[var], axis).item(0) for var in variables]\n return min(start), max(end)","def _get_extremes(self, attr='values'):\n # calculate the maximum and minimum for all series\n series_max = [0]\n series_min = [0]\n for s in self:\n if s is not None:\n series_max.append(s.max(attr))\n series_min.append(s.min(attr))\n return min(series_min), max(series_max)","def bounds(self):\n return self.xmin, self.xmax, self.ymin, self.ymax","def domain_range(domain, _range=[0, 1], return_transform=False):\n\n if not return_transform:\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\n else:\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element","def normalizeToRange(data,max=255,min=0):\n if min: return (max-min)*normalize(data)+min\n else: return max*normalize2(data) # speeds up operation","def variable_range(examples, var):\n if var[1] == 'd':\n range = set()\n for datum in examples:\n range.add(datum[var[0]])\n return range\n else:\n range_min, range_max = 0, 0\n for datum in examples:\n data_val = float(datum[var[0]])\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\n return (range_min, range_max)","def _parse_vrange(self, data):\n vmin = self.config.get('vmin', np.nanmin(data))\n vmax = self.config.get('vmax', np.nanmax(data))\n vrange = self.config.get('vrange', None)\n\n # Parse vmin, vmax\n if isinstance(vmin, str):\n vmin = np.nanquantile(data, q=float(vmin))\n if isinstance(vmax, str):\n vmax = np.nanquantile(data, q=float(vmax))\n\n # Parse vrange\n if vrange is True:\n vrange = max(abs(np.nanmin(data)), abs(np.nanmax(data)))\n elif isinstance(vrange, str):\n vrange = abs(np.nanquantile(data, q=(float(vrange), 1-float(vrange)))).max()\n\n if vrange is not None:\n if isinstance(vrange, (list, tuple, np.ndarray)):\n vmin, vmax = vrange\n else:\n vmin, vmax = -vrange, vrange\n return vmin, vmax","def view_limits(self, dmin, dmax):\n base = self._select_base(dmin, dmax)\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\n vmin = base.le(dmin)\n vmax = base.ge(dmax)\n if vmin == vmax:\n vmin -= 1\n vmax += 1\n else:\n vmin = dmin\n vmax = dmax\n\n return mtransforms.nonsingular(vmin, vmax)","def range(self) -> Tuple[Union[int, float], Union[int, float]]:\n return self._range","def x_y_coor_min_max(x_y_coor):\n\tx_range = [np.min(x_y_coor[\"X\"]),np.max(x_y_coor[\"X\"])]\n\ty_range = [np.min(x_y_coor[\"Y\"]),np.max(x_y_coor[\"Y\"])]\n\treturn x_range, y_range","def range_(headers, data):\n\tcolumn_matrix=data.get_data(headers).getT() # get columns as rows, as this makes analysis much easier by just perfoming operations on column list directly\n\tif column_matrix==[]:\n\t\tprint \"wrong headers, not present in data Object\"\n\t\treturn []\n\tcolumn_max=column_matrix.max(1)\n\tcolumn_min=column_matrix.min(1)\n\tfinal=np.concatenate((column_min, column_max), axis=1)\n\t\n\trng=final.tolist()\n\treturn rng","def get_range(self) -> tuple[int, int]:\n return self.range_from, self.range_to","def minMax(df):\n max_, min_ = df.max(axis=0), df.min(axis=0)\n midrange = (max_ + min_) / 2\n half_range = (max_ - min_) / 2\n return (df - midrange) / half_range","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 normalize_minmax(data):\n _min = np.float(np.min(data))\n _max = np.float(np.max(data))\n if (_max-_min)!=0:\n img = (data - _min) / (_max-_min)\n else:\n img = np.zeros_like(data) \n return img","def max_in_range(self, x, y, low, high):\r\n data = np.vstack((x,y)) \r\n y_values = data[1][np.logical_and(low < data[0], data[0] < high)]\r\n x_values = data[0][np.logical_and(low < data[0], data[0] < high)]\r\n index_max_y = y_values.argmax()\r\n max_y = y_values[index_max_y]\r\n max_x = x_values[index_max_y]\r\n return max_x, max_y","def column_range_validation_factory(minim=None, maxim=None, ignore_missing_vals=False):\n if minim is None:\n if isinstance(maxim, datetime):\n minim = datetime.min\n else:\n minim = -1 * (sys.maxsize - 1)\n if maxim is None:\n if isinstance(minim, datetime):\n maxim = datetime.max\n else:\n maxim = sys.maxsize\n\n def in_range_validation_fn(x):\n if ignore_missing_vals and pd.isnull(x):\n return True, {}\n return (isinstance(x, (type(minim), type(maxim)))) and (x <= maxim) and (x >= minim), {}\n\n in_range_validation_fn.__doc__ = \"checks whether values are between {} and {}\".format(\n minim, maxim\n )\n if ignore_missing_vals:\n in_range_validation_fn.__doc__ += \", ignoring nulls\"\n\n return in_range_validation_fn","def GetTotalRange(vDataSet):\r\n dtype = GetType(vDataSet)\r\n if dtype == np.uint8 or dtype == np.uint16:\r\n info = np.iinfo(dtype)\r\n else:\r\n info = np.finfo(dtype)\r\n return info.min,info.max","def getDataRange(self):\n return None if self._dataRange is None else tuple(self._dataRange)","def get_range(self, start=None, end=None):\n\n # handle the case of no data\n if self.data.shape[0] == 0 or self.source.data[\"index\"].shape[0] == 0:\n return None, None\n\n first_source_idx = self.source.data[\"index\"][0]\n last_source_idx = self.source.data[\"index\"][-1]\n\n # convert to timestamp if necessary\n if isinstance(self.data.index, pd.DatetimeIndex):\n start = pd.to_datetime(start, unit=\"ms\")\n end = pd.to_datetime(end, unit=\"ms\")\n first_source_idx = pd.to_datetime(first_source_idx, unit=\"ms\")\n last_source_idx = pd.to_datetime(last_source_idx, unit=\"ms\")\n\n # get new start and end\n if start is not None:\n if start < first_source_idx:\n start = max(self.data.index[0], start)\n elif start > last_source_idx:\n start = min(self.data.index[-1], start)\n elif start < self.data.index[0]:\n start = self.data.index[0]\n elif start > self.data.index[-1]:\n start = self.data.index[-1]\n elif len(self.source.data[\"index\"]) > 0:\n start = first_source_idx\n else:\n start = self.data.index[0]\n\n if end is not None:\n if end < first_source_idx:\n end = max(self.data.index[0], end)\n elif end > last_source_idx:\n end = min(self.data.index[-1], end)\n elif end < self.data.index[0]:\n end = self.data.index[0]\n elif end > self.data.index[-1]:\n end = self.data.index[-1]\n elif len(self.source.data[\"index\"]) > 0:\n end = last_source_idx\n else:\n end = self.data.index[-1]\n\n return start, end","def bounds(self):\n\n if self.size == 0:\n lo, hi = np.nan, np.nan\n elif self.is_monotonic:\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\n elif self.dtype is np.datetime64:\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\n else:\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\n\n return lo, hi","def range(self):\n return self.range_array","def range_inclusive(start, stop):\n return range(start, stop + 1)","def xminmax ( self ) :\n return self.xvar.minmax()","def vallimits(arr,limval = NAN):\n # Find where arr is non-NAN\n if isnan(limval) == True:\n vallocs = where(isnan(arr) == False)\n else:\n vallocs = where(arr != limval)\n # Extract the indices corresponding to the maximum and\n # minimum non-NANs. If none exist, set them to NAN\n try:\n uplim = max(vallocs[0])\n except ValueError:\n uplim = NAN\n try:\n downlim = min(vallocs[0])\n except ValueError:\n downlim = NAN\n return downlim,uplim","def view_limits(self, vmin, vmax):\n return vmin, vmax\n # return nonsingular(vmin, vmax)","def min_max(self, data, era):\n return 0, np.max(data)","def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\n ...","def GetScalarRange(self):\n ...","def _default_sampling_xrange(self):\n from scipy.stats import rv_continuous\n dataset = self.rvdist.rvs(1000) if rv_continuous in self.rvdist.__class__.__mro__ \\\n else self.rvdist.dataset\n scale = np.nanmax(dataset) - np.nanmin(dataset)\n return [np.nanmin(dataset) - scale*0.05, np.nanmax(dataset) + scale*0.05]","def min_max_range(s):\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\n sign = np.sign(np.argmax(s) - np.argmin(s))\n if sign == 0:\n return 0.0\n else:\n return sign*(np.max(s) - np.min(s))","def fetchbounds(self):\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\n self.in_end, self.end, self.out_end] \\\n if x is not None]\n return min(pnts), max(pnts)","def min_range(self):\n return self._min_range","def _set_min_max_values(self):\n\n p_1, p_2 = self.points[0], self.points[1]\n nb_dim = len(p_1.values)\n self._min_values = []\n self._max_values = []\n for d in range(nb_dim):\n d_min = min(p_1[d], p_2[d])\n d_max = max(p_2[d], p_2[d])\n self._min_values.append(d_min)\n self._max_values.append(d_max)","def minima_in_range(r, g_r, r_min, r_max):\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\n g_r_slice = g_r[idx]\n g_r_min = g_r_slice[g_r_slice.argmin()]\n idx_min, _ = find_nearest(g_r, g_r_min)\n return r[idx_min], g_r[idx_min]","def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\n assert \\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\n if dtype is None:\n dtype = images.dtype\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)","def domain_bounds(self):\n return self._xmin, self._xmax, self._ymin, self._ymax, self._zmin, self._zmax","def get_minx_maxx(self, normalized=True):\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\n\n for idx, feature_name in enumerate(self.continuous_feature_names):\n max_value = self.train_df[feature_name].max()\n min_value = self.train_df[feature_name].min()\n\n if normalized:\n minx[0][idx] = (self.permitted_range[feature_name]\n [0] - min_value) / (max_value - min_value)\n maxx[0][idx] = (self.permitted_range[feature_name]\n [1] - min_value) / (max_value - min_value)\n else:\n minx[0][idx] = self.permitted_range[feature_name][0]\n maxx[0][idx] = self.permitted_range[feature_name][1]\n return minx, maxx","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def getDataRange(self):\n return self._dataRange","def GetRange(vDataSet,channel=None):\r\n nc = vDataSet.GetSizeC()\r\n maset = 0\r\n if channel is None:\r\n channels = range(nc)\r\n else:\r\n channels = [channel]\r\n\r\n for i in channels:\r\n ma = vDataSet.GetChannelRangeMax(i)\r\n if ma > maset:\r\n maset = ma\r\n\r\n maset = np.power(2,np.ceil(np.log2(maset)))-1\r\n return 0,maset","def get_range(self):\n return time_to_range(self.get_time())","def minmax(xs):\n min_val = None\n max_val = None\n for x in xs:\n if min_val is None or x < min_val:\n min_val = x\n if max_val is None or x > max_val:\n max_val = x\n return (min_val, max_val)","def value_ranges(self, attributes):\n ranges = []\n for attribute in attributes:\n if not attribute.is_continuous():\n raise inv.InvalidDataError('Cannot discretise non continuous attribute ' + attribute.name)\n values = self.values_grouped_by_attribute(attributes)\n for value in values: #each entry in values is the range of values for a particular attribute\n value.sort()\n ranges.append(r.Range(value[0], value[-1], True))\n return ranges","def summarize_ranges(self, ranges):\n if len(ranges) == 0: return []\n min_ = 'min'\n max_ = 'max'\n for r in ranges:\n if r[0][0] == \"min\":\n r[0][0] = min_\n else:\n min_ = r[0][0]\n if r[-1][1] == \"max\":\n r[-1][1] = max_\n else:\n max_ = r[-1][1]\n return ranges[-1]","def _value_in_bounds(self, vals):\n return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1]))","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 get_minmax_stats(dataframe, variable):\n\n print(\"Maximum value of \", variable, \"is: \", dataframe[variable].max())\n print(\"Minimum value of \", variable, \"is: \", dataframe[variable].min())","def regression_range(self):\n regression_range = detect_regression_range.DetectRegressionRange(\n self.historical_metadata)\n if regression_range is None: # pragma: no cover\n logging.warning('Got ``None`` for the regression range.')\n else:\n regression_range = tuple(regression_range)\n\n return regression_range","def get_xrange(self) -> np.array:\n # todo: ensure this functions work as well for y_values\n lower, upper = self.get_xrange_indices()\n return self.x[lower, upper + 1]","def clip(val, val_min, val_max):\n return min(val_max, max(val_min, val))","def normalise_min_max(df):\n return (df - df.min()) / (df.max() - df.min())","def normalise_min_max(df):\n return (df - df.min()) / (df.max() - df.min())","def yield_spectral_range(self) -> Tuple[float, float, float]:\n return [min(self.x), max(self.x), len(self.x)]","def MaxToMin(min_lev, max_lev, datetime_maxes):\r\n y_res_mins = []\r\n deltaT_ranges = []\r\n for row in range(len(max_lev)-1):\r\n range_length = (datetime_maxes.iloc[row+1]-datetime_maxes.iloc[row]).seconds/3600 # hours\r\n if ~np.isnan(max_lev.iloc[row]) & (range_length>=3.5) & (range_length<=7.5): # peak to trough should take 6.2 hours in ocean\r\n y_res_mins.append(min_lev.iloc[row+1])\r\n deltaT_ranges.append(datetime_maxes.iloc[row+1]-datetime_maxes.iloc[row])\r\n elif ~np.isnan(max_lev.iloc[row]): # if peak lag is more than 4 hours, erroneous data\r\n y_res_mins.append(np.nan)\r\n deltaT_ranges.append(np.nan)\r\n # if last value in oceanside array is not nan, append another nan on the return arrays\r\n if (datetime_maxes.iloc[row+1]==datetime_maxes.iloc[-1]) & ~np.isnan(max_lev.iloc[row+1]): \r\n y_res_mins.append(np.nan)\r\n deltaT_ranges.append(np.nan)\r\n y_res_mins = np.array(y_res_mins)\r\n deltaT_ranges = np.array(deltaT_ranges)\r\n return deltaT_ranges, y_res_mins","def getInputDeviceRange(*args, maxValue: bool=True, minValue: bool=True,\n **kwargs)->List[float]:\n pass","def detect_range(self) -> Union[int, float]:\n return self.proto.detect_range","def bounds(x, xMin, xMax):\n if (x < xMin):\n x = xMin\n elif (x > xMax):\n x = xMax\n return(x)","def min_max(arr: StaticArray) -> ():\n minimum = arr.get(0) # sets min to first element\n maximum = arr.get(0) # sets max to first element\n # iterate over the elements in the array to check for < or >\n for index in range(arr.size()):\n if arr[index] < minimum: # if element is less than the current min, min = new element\n minimum = arr[index]\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\n maximum = arr[index]\n return minimum, maximum","def get_bounds(self, value = None, index = None):\n\n if self._data is None or 0 in self._data.shape:\n return (0.0, 0.0)\n\n if type(value) == types.IntType:\n if self.value_dimension == 0:\n maxi = nanmax(self._data[value, ::])\n mini = nanmin(self._data[value, ::])\n else:\n # value_dimension == 1\n maxi = nanmax(self._data[::, value])\n mini = nanmin(self._data[::, value])\n elif type(index) == types.IntType:\n if self.index_dimension == 0:\n maxi = nanmax(self._data[index, ::])\n mini = nanmin(self._data[index, ::])\n else:\n # index_dimension == 1\n maxi = nanmax(self._data[::, index])\n mini = nanmin(self._data[::, index])\n else:\n # value is None and index is None:\n maxi = nanmax(self._data)\n mini = nanmin(self._data)\n\n return (mini, maxi)","def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\n return pulumi.get(self, \"ranges\")","def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\n return pulumi.get(self, \"ranges\")","def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\n return pulumi.get(self, \"ranges\")","def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\n return pulumi.get(self, \"ranges\")","def range(self):\r\n\t\treturn max(self.sample) - min(self.sample)","def extreme_values(self, extreme):\n\n\t\tif extreme.lower() == 'min':\n\t\t\treturn data.min()\n\t\telif extreme.lower() == 'max':\n\t\t\treturn data.max()\n\t\telse:\n\t\t\tassert 'Invalid Parameter !'","def get_features_min_max(self):\n min_max_list = []\n\n # Get each feature's min and max values.\n for feature_name in self.feature_names:\n min = self.data[feature_name].min()\n max = self.data[feature_name].max()\n min_max_list.append([min, max])\n\n # Create dataframe from list of lists in correct format\n min_max_df = pd.DataFrame(min_max_list)\n min_max = min_max_df.T\n min_max.columns = self.feature_names\n min_max.index = ['min', 'max']\n\n return min_max","def range(self):\n lower, upper = sorted((self.y1, self.y2))\n return FloatRange(lower=lower, upper=upper)","def get_ranges(self) -> typing.List[typing.Tuple[float, float]]:\n return self.ranges[:]","def minmin_maxmax( *args ):\n rmin = min( [ mv.min() for mv in args ] )\n rmax = max( [ mv.max() for mv in args ] )\n rmv = cdms2.createVariable( [rmin,rmax] )\n return rmv","def getRange(self) -> Tuple[int, int]:\n return self.validator().bottom(), self.validator().top()","def bounds(self) -> Tensor:\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)","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)"],"string":"[\n \"def data_range(x):\\n return max(x)-min(x)\",\n \"def _full_value_range(self):\\n min_value, max_value = self._raw_data.data_range\\n return max_value - min_value\",\n \"def _computeRangeFromData(data):\\n if data is None:\\n return None\\n\\n dataRange = min_max(data, min_positive=True, finite=True)\\n if dataRange.minimum is None: # Only non-finite data\\n return None\\n\\n if dataRange is not None:\\n min_positive = dataRange.min_positive\\n if min_positive is None:\\n min_positive = float('nan')\\n return dataRange.minimum, min_positive, dataRange.maximum\",\n \"def data_range(xs: List[float]) -> float:\\n return max(xs) - min(xs)\",\n \"def get_range(cls, data: tuple or list) -> float:\\n cls._data_validation(data)\\n max_ = cls.get_max(data)\\n min_ = cls.get_min(data)\\n return float(max_ - min_)\",\n \"def range(series):\\n return min(series), max(series)\",\n \"def range(self):\\n lows, highs = [], []\\n for graph in self._graphs.values():\\n low, high = graph.range()\\n lows.append(low)\\n highs.append(high)\\n return (min(lows), max(highs))\",\n \"def find_min_max(data):\\n v = [i[1] for i in data]\\n extremes = [min(v), max(v)]\\n logging.info('Calculated extremes: %s', extremes)\\n return extremes\",\n \"def get_range(df, col):\\n return df[col].min(), df[col].max()\",\n \"def getColorRange(self):\\n vmax=self.data_matrix.max()\\n vmin=self.data_matrix.min()\\n\\n if vmax * vmin < 0: # ie number range spans +ve and -ve\\n vmax = max([vmax, abs(vmin)])\\n vmin = -1*vmax\\n\\n return vmax,vmin\",\n \"def findRanges(data_grouped):\\n ranges = []\\n for i in data_grouped.columns:\\n theRange = (data_grouped[i].min(), data_grouped[i].max())\\n ranges.append(theRange)\\n return ranges\",\n \"def in_range(data, minval=-np.inf, maxval=np.inf):\\n return (minval <= data) & (data <= maxval)\",\n \"def limits(self):\\n\\n\\t\\treturn [\\n\\t\\t\\tmin(self.xvalues),\\n\\t\\t\\tmax(self.xvalues),\\n\\t\\t\\tmin(self.yvalues),\\n\\t\\t\\tmax(self.yvalues)]\",\n \"def range(x):\\n try:\\n return (min(min(y) for y in x), max(max(y) for y in x))\\n except ValueError:\\n return (None, None)\",\n \"def m_to_range(self, data):\\n return (data - self._min_range_m) / self._total_range\",\n \"def get_range(lst):\\n return float(max(lst)) - float(min(lst))\",\n \"def ex_range(data):\\n a, b, step = _cleanse_range_args(data)\\n return list(range(a, b+sign(step), step))\",\n \"def clip_range(x, xlim):\\n return min([max([x, xlim[0]]), xlim[1]])\",\n \"def min_max(xs):\\n return min(xs), max(xs)\",\n \"def range(df):\\r\\n\\r\\n\\tdf_range_dict = dict()\\r\\n\\r\\n\\tfor i, col in enumerate(df.columns):\\r\\n\\t\\tdf_range_dict[col] = [df[col].max(), df[col].min(), df[col].max() - df[col].min()]\\r\\n\\r\\n\\tdf_range = pd.DataFrame(df_range_dict, index=['Max Value', 'Min Value', 'Range (Max - Min)'])\\r\\n\\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\\r\\n\\r\\n\\treturn df_range\",\n \"def calcrange(a4lim,data):\\r\\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\\r\\n return a4range\",\n \"def _bound(x, min_value, max_value):\\n return np.maximum(min_value, np.minimum(x, max_value))\",\n \"def minmax(self):\\n return self._data_lim[self._n_overlay - 1]\",\n \"def minmax(data):\\n smallest = data[0]\\n largest = data[0]\\n\\n for i in range(0,len(data)):\\n if data[i] < smallest:\\n smallest = data[i]\\n elif data[i] > largest:\\n largest = data[i]\\n\\n return(smallest,largest)\",\n \"def min_max_outliers(res, min=None, max=None):\\n min_max_list = []\\n if isinstance(min, (int, float)):\\n data1 = res[res < min].reset_index()\\n data1['limit type'] = 'minimum'\\n data1['limit'] = min\\n min_max_list.append(data1)\\n if isinstance(max, (int, float)):\\n data1 = res[res > max].reset_index()\\n data1['limit type'] = 'maximum'\\n data1['limit'] = max\\n min_max_list.append(data1)\\n\\n min_max1 = pd.concat(min_max_list)\\n\\n return min_max1\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def remove_out_of_bounds(self, data, low_bound, high_bound):\\n data = data.dropna()\\n data = data[(data > low_bound).all(axis=1) & (data < high_bound).all(axis=1)] \\n return data\",\n \"def get_range(self, field, deep=False, axis=None):\\n variables = list(self.vars(deep, with_name=field))\\n\\n if not variables:\\n raise KeyError(\\\"No variable named '%s' was found!\\\" % field)\\n\\n start = [np.nanmin(self[var], axis).item(0) for var in variables]\\n end = [np.nanmax(self[var], axis).item(0) for var in variables]\\n return min(start), max(end)\",\n \"def _get_extremes(self, attr='values'):\\n # calculate the maximum and minimum for all series\\n series_max = [0]\\n series_min = [0]\\n for s in self:\\n if s is not None:\\n series_max.append(s.max(attr))\\n series_min.append(s.min(attr))\\n return min(series_min), max(series_max)\",\n \"def bounds(self):\\n return self.xmin, self.xmax, self.ymin, self.ymax\",\n \"def domain_range(domain, _range=[0, 1], return_transform=False):\\n\\n if not return_transform:\\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\\n else:\\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element\",\n \"def normalizeToRange(data,max=255,min=0):\\n if min: return (max-min)*normalize(data)+min\\n else: return max*normalize2(data) # speeds up operation\",\n \"def variable_range(examples, var):\\n if var[1] == 'd':\\n range = set()\\n for datum in examples:\\n range.add(datum[var[0]])\\n return range\\n else:\\n range_min, range_max = 0, 0\\n for datum in examples:\\n data_val = float(datum[var[0]])\\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\\n return (range_min, range_max)\",\n \"def _parse_vrange(self, data):\\n vmin = self.config.get('vmin', np.nanmin(data))\\n vmax = self.config.get('vmax', np.nanmax(data))\\n vrange = self.config.get('vrange', None)\\n\\n # Parse vmin, vmax\\n if isinstance(vmin, str):\\n vmin = np.nanquantile(data, q=float(vmin))\\n if isinstance(vmax, str):\\n vmax = np.nanquantile(data, q=float(vmax))\\n\\n # Parse vrange\\n if vrange is True:\\n vrange = max(abs(np.nanmin(data)), abs(np.nanmax(data)))\\n elif isinstance(vrange, str):\\n vrange = abs(np.nanquantile(data, q=(float(vrange), 1-float(vrange)))).max()\\n\\n if vrange is not None:\\n if isinstance(vrange, (list, tuple, np.ndarray)):\\n vmin, vmax = vrange\\n else:\\n vmin, vmax = -vrange, vrange\\n return vmin, vmax\",\n \"def view_limits(self, dmin, dmax):\\n base = self._select_base(dmin, dmax)\\n if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':\\n vmin = base.le(dmin)\\n vmax = base.ge(dmax)\\n if vmin == vmax:\\n vmin -= 1\\n vmax += 1\\n else:\\n vmin = dmin\\n vmax = dmax\\n\\n return mtransforms.nonsingular(vmin, vmax)\",\n \"def range(self) -> Tuple[Union[int, float], Union[int, float]]:\\n return self._range\",\n \"def x_y_coor_min_max(x_y_coor):\\n\\tx_range = [np.min(x_y_coor[\\\"X\\\"]),np.max(x_y_coor[\\\"X\\\"])]\\n\\ty_range = [np.min(x_y_coor[\\\"Y\\\"]),np.max(x_y_coor[\\\"Y\\\"])]\\n\\treturn x_range, y_range\",\n \"def range_(headers, data):\\n\\tcolumn_matrix=data.get_data(headers).getT() # get columns as rows, as this makes analysis much easier by just perfoming operations on column list directly\\n\\tif column_matrix==[]:\\n\\t\\tprint \\\"wrong headers, not present in data Object\\\"\\n\\t\\treturn []\\n\\tcolumn_max=column_matrix.max(1)\\n\\tcolumn_min=column_matrix.min(1)\\n\\tfinal=np.concatenate((column_min, column_max), axis=1)\\n\\t\\n\\trng=final.tolist()\\n\\treturn rng\",\n \"def get_range(self) -> tuple[int, int]:\\n return self.range_from, self.range_to\",\n \"def minMax(df):\\n max_, min_ = df.max(axis=0), df.min(axis=0)\\n midrange = (max_ + min_) / 2\\n half_range = (max_ - min_) / 2\\n return (df - midrange) / half_range\",\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 normalize_minmax(data):\\n _min = np.float(np.min(data))\\n _max = np.float(np.max(data))\\n if (_max-_min)!=0:\\n img = (data - _min) / (_max-_min)\\n else:\\n img = np.zeros_like(data) \\n return img\",\n \"def max_in_range(self, x, y, low, high):\\r\\n data = np.vstack((x,y)) \\r\\n y_values = data[1][np.logical_and(low < data[0], data[0] < high)]\\r\\n x_values = data[0][np.logical_and(low < data[0], data[0] < high)]\\r\\n index_max_y = y_values.argmax()\\r\\n max_y = y_values[index_max_y]\\r\\n max_x = x_values[index_max_y]\\r\\n return max_x, max_y\",\n \"def column_range_validation_factory(minim=None, maxim=None, ignore_missing_vals=False):\\n if minim is None:\\n if isinstance(maxim, datetime):\\n minim = datetime.min\\n else:\\n minim = -1 * (sys.maxsize - 1)\\n if maxim is None:\\n if isinstance(minim, datetime):\\n maxim = datetime.max\\n else:\\n maxim = sys.maxsize\\n\\n def in_range_validation_fn(x):\\n if ignore_missing_vals and pd.isnull(x):\\n return True, {}\\n return (isinstance(x, (type(minim), type(maxim)))) and (x <= maxim) and (x >= minim), {}\\n\\n in_range_validation_fn.__doc__ = \\\"checks whether values are between {} and {}\\\".format(\\n minim, maxim\\n )\\n if ignore_missing_vals:\\n in_range_validation_fn.__doc__ += \\\", ignoring nulls\\\"\\n\\n return in_range_validation_fn\",\n \"def GetTotalRange(vDataSet):\\r\\n dtype = GetType(vDataSet)\\r\\n if dtype == np.uint8 or dtype == np.uint16:\\r\\n info = np.iinfo(dtype)\\r\\n else:\\r\\n info = np.finfo(dtype)\\r\\n return info.min,info.max\",\n \"def getDataRange(self):\\n return None if self._dataRange is None else tuple(self._dataRange)\",\n \"def get_range(self, start=None, end=None):\\n\\n # handle the case of no data\\n if self.data.shape[0] == 0 or self.source.data[\\\"index\\\"].shape[0] == 0:\\n return None, None\\n\\n first_source_idx = self.source.data[\\\"index\\\"][0]\\n last_source_idx = self.source.data[\\\"index\\\"][-1]\\n\\n # convert to timestamp if necessary\\n if isinstance(self.data.index, pd.DatetimeIndex):\\n start = pd.to_datetime(start, unit=\\\"ms\\\")\\n end = pd.to_datetime(end, unit=\\\"ms\\\")\\n first_source_idx = pd.to_datetime(first_source_idx, unit=\\\"ms\\\")\\n last_source_idx = pd.to_datetime(last_source_idx, unit=\\\"ms\\\")\\n\\n # get new start and end\\n if start is not None:\\n if start < first_source_idx:\\n start = max(self.data.index[0], start)\\n elif start > last_source_idx:\\n start = min(self.data.index[-1], start)\\n elif start < self.data.index[0]:\\n start = self.data.index[0]\\n elif start > self.data.index[-1]:\\n start = self.data.index[-1]\\n elif len(self.source.data[\\\"index\\\"]) > 0:\\n start = first_source_idx\\n else:\\n start = self.data.index[0]\\n\\n if end is not None:\\n if end < first_source_idx:\\n end = max(self.data.index[0], end)\\n elif end > last_source_idx:\\n end = min(self.data.index[-1], end)\\n elif end < self.data.index[0]:\\n end = self.data.index[0]\\n elif end > self.data.index[-1]:\\n end = self.data.index[-1]\\n elif len(self.source.data[\\\"index\\\"]) > 0:\\n end = last_source_idx\\n else:\\n end = self.data.index[-1]\\n\\n return start, end\",\n \"def bounds(self):\\n\\n if self.size == 0:\\n lo, hi = np.nan, np.nan\\n elif self.is_monotonic:\\n lo, hi = sorted([self.coordinates[0], self.coordinates[-1]])\\n elif self.dtype is np.datetime64:\\n lo, hi = np.min(self.coordinates), np.max(self.coordinates)\\n else:\\n lo, hi = np.nanmin(self.coordinates), np.nanmax(self.coordinates)\\n\\n return lo, hi\",\n \"def range(self):\\n return self.range_array\",\n \"def range_inclusive(start, stop):\\n return range(start, stop + 1)\",\n \"def xminmax ( self ) :\\n return self.xvar.minmax()\",\n \"def vallimits(arr,limval = NAN):\\n # Find where arr is non-NAN\\n if isnan(limval) == True:\\n vallocs = where(isnan(arr) == False)\\n else:\\n vallocs = where(arr != limval)\\n # Extract the indices corresponding to the maximum and\\n # minimum non-NANs. If none exist, set them to NAN\\n try:\\n uplim = max(vallocs[0])\\n except ValueError:\\n uplim = NAN\\n try:\\n downlim = min(vallocs[0])\\n except ValueError:\\n downlim = NAN\\n return downlim,uplim\",\n \"def view_limits(self, vmin, vmax):\\n return vmin, vmax\\n # return nonsingular(vmin, vmax)\",\n \"def min_max(self, data, era):\\n return 0, np.max(data)\",\n \"def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\\n ...\",\n \"def GetScalarRange(self):\\n ...\",\n \"def _default_sampling_xrange(self):\\n from scipy.stats import rv_continuous\\n dataset = self.rvdist.rvs(1000) if rv_continuous in self.rvdist.__class__.__mro__ \\\\\\n else self.rvdist.dataset\\n scale = np.nanmax(dataset) - np.nanmin(dataset)\\n return [np.nanmin(dataset) - scale*0.05, np.nanmax(dataset) + scale*0.05]\",\n \"def min_max_range(s):\\n # note np.argmax, np.argmin returns the position of first occurence of global max, min\\n sign = np.sign(np.argmax(s) - np.argmin(s))\\n if sign == 0:\\n return 0.0\\n else:\\n return sign*(np.max(s) - np.min(s))\",\n \"def fetchbounds(self):\\n pnts = [x for x in [self.out_start, self.start, self.in_start, \\\\\\n self.in_end, self.end, self.out_end] \\\\\\n if x is not None]\\n return min(pnts), max(pnts)\",\n \"def min_range(self):\\n return self._min_range\",\n \"def _set_min_max_values(self):\\n\\n p_1, p_2 = self.points[0], self.points[1]\\n nb_dim = len(p_1.values)\\n self._min_values = []\\n self._max_values = []\\n for d in range(nb_dim):\\n d_min = min(p_1[d], p_2[d])\\n d_max = max(p_2[d], p_2[d])\\n self._min_values.append(d_min)\\n self._max_values.append(d_max)\",\n \"def minima_in_range(r, g_r, r_min, r_max):\\n idx = np.where(np.logical_and(np.greater_equal(r, r_min), np.greater_equal(r_max, r)))\\n g_r_slice = g_r[idx]\\n g_r_min = g_r_slice[g_r_slice.argmin()]\\n idx_min, _ = find_nearest(g_r, g_r_min)\\n return r[idx_min], g_r[idx_min]\",\n \"def to_range(images, min_value=0.0, max_value=1.0, dtype=None):\\n assert \\\\\\n np.min(images) >= -1.0 - 1e-5 and np.max(images) <= 1.0 + 1e-5 \\\\\\n and (images.dtype == np.float32 or images.dtype == np.float64), \\\\\\n 'The input images should be float64(32) and in the range of [-1.0, 1.0]!'\\n if dtype is None:\\n dtype = images.dtype\\n return ((images + 1.) / 2. * (max_value - min_value) + min_value).astype(dtype)\",\n \"def domain_bounds(self):\\n return self._xmin, self._xmax, self._ymin, self._ymax, self._zmin, self._zmax\",\n \"def get_minx_maxx(self, normalized=True):\\n minx = np.array([[0.0] * len(self.encoded_feature_names)])\\n maxx = np.array([[1.0] * len(self.encoded_feature_names)])\\n\\n for idx, feature_name in enumerate(self.continuous_feature_names):\\n max_value = self.train_df[feature_name].max()\\n min_value = self.train_df[feature_name].min()\\n\\n if normalized:\\n minx[0][idx] = (self.permitted_range[feature_name]\\n [0] - min_value) / (max_value - min_value)\\n maxx[0][idx] = (self.permitted_range[feature_name]\\n [1] - min_value) / (max_value - min_value)\\n else:\\n minx[0][idx] = self.permitted_range[feature_name][0]\\n maxx[0][idx] = self.permitted_range[feature_name][1]\\n return minx, maxx\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def getDataRange(self):\\n return self._dataRange\",\n \"def GetRange(vDataSet,channel=None):\\r\\n nc = vDataSet.GetSizeC()\\r\\n maset = 0\\r\\n if channel is None:\\r\\n channels = range(nc)\\r\\n else:\\r\\n channels = [channel]\\r\\n\\r\\n for i in channels:\\r\\n ma = vDataSet.GetChannelRangeMax(i)\\r\\n if ma > maset:\\r\\n maset = ma\\r\\n\\r\\n maset = np.power(2,np.ceil(np.log2(maset)))-1\\r\\n return 0,maset\",\n \"def get_range(self):\\n return time_to_range(self.get_time())\",\n \"def minmax(xs):\\n min_val = None\\n max_val = None\\n for x in xs:\\n if min_val is None or x < min_val:\\n min_val = x\\n if max_val is None or x > max_val:\\n max_val = x\\n return (min_val, max_val)\",\n \"def value_ranges(self, attributes):\\n ranges = []\\n for attribute in attributes:\\n if not attribute.is_continuous():\\n raise inv.InvalidDataError('Cannot discretise non continuous attribute ' + attribute.name)\\n values = self.values_grouped_by_attribute(attributes)\\n for value in values: #each entry in values is the range of values for a particular attribute\\n value.sort()\\n ranges.append(r.Range(value[0], value[-1], True))\\n return ranges\",\n \"def summarize_ranges(self, ranges):\\n if len(ranges) == 0: return []\\n min_ = 'min'\\n max_ = 'max'\\n for r in ranges:\\n if r[0][0] == \\\"min\\\":\\n r[0][0] = min_\\n else:\\n min_ = r[0][0]\\n if r[-1][1] == \\\"max\\\":\\n r[-1][1] = max_\\n else:\\n max_ = r[-1][1]\\n return ranges[-1]\",\n \"def _value_in_bounds(self, vals):\\n return (self._min_in_bounds(vals[0]), self._max_in_bounds(vals[1]))\",\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 get_minmax_stats(dataframe, variable):\\n\\n print(\\\"Maximum value of \\\", variable, \\\"is: \\\", dataframe[variable].max())\\n print(\\\"Minimum value of \\\", variable, \\\"is: \\\", dataframe[variable].min())\",\n \"def regression_range(self):\\n regression_range = detect_regression_range.DetectRegressionRange(\\n self.historical_metadata)\\n if regression_range is None: # pragma: no cover\\n logging.warning('Got ``None`` for the regression range.')\\n else:\\n regression_range = tuple(regression_range)\\n\\n return regression_range\",\n \"def get_xrange(self) -> np.array:\\n # todo: ensure this functions work as well for y_values\\n lower, upper = self.get_xrange_indices()\\n return self.x[lower, upper + 1]\",\n \"def clip(val, val_min, val_max):\\n return min(val_max, max(val_min, val))\",\n \"def normalise_min_max(df):\\n return (df - df.min()) / (df.max() - df.min())\",\n \"def normalise_min_max(df):\\n return (df - df.min()) / (df.max() - df.min())\",\n \"def yield_spectral_range(self) -> Tuple[float, float, float]:\\n return [min(self.x), max(self.x), len(self.x)]\",\n \"def MaxToMin(min_lev, max_lev, datetime_maxes):\\r\\n y_res_mins = []\\r\\n deltaT_ranges = []\\r\\n for row in range(len(max_lev)-1):\\r\\n range_length = (datetime_maxes.iloc[row+1]-datetime_maxes.iloc[row]).seconds/3600 # hours\\r\\n if ~np.isnan(max_lev.iloc[row]) & (range_length>=3.5) & (range_length<=7.5): # peak to trough should take 6.2 hours in ocean\\r\\n y_res_mins.append(min_lev.iloc[row+1])\\r\\n deltaT_ranges.append(datetime_maxes.iloc[row+1]-datetime_maxes.iloc[row])\\r\\n elif ~np.isnan(max_lev.iloc[row]): # if peak lag is more than 4 hours, erroneous data\\r\\n y_res_mins.append(np.nan)\\r\\n deltaT_ranges.append(np.nan)\\r\\n # if last value in oceanside array is not nan, append another nan on the return arrays\\r\\n if (datetime_maxes.iloc[row+1]==datetime_maxes.iloc[-1]) & ~np.isnan(max_lev.iloc[row+1]): \\r\\n y_res_mins.append(np.nan)\\r\\n deltaT_ranges.append(np.nan)\\r\\n y_res_mins = np.array(y_res_mins)\\r\\n deltaT_ranges = np.array(deltaT_ranges)\\r\\n return deltaT_ranges, y_res_mins\",\n \"def getInputDeviceRange(*args, maxValue: bool=True, minValue: bool=True,\\n **kwargs)->List[float]:\\n pass\",\n \"def detect_range(self) -> Union[int, float]:\\n return self.proto.detect_range\",\n \"def bounds(x, xMin, xMax):\\n if (x < xMin):\\n x = xMin\\n elif (x > xMax):\\n x = xMax\\n return(x)\",\n \"def min_max(arr: StaticArray) -> ():\\n minimum = arr.get(0) # sets min to first element\\n maximum = arr.get(0) # sets max to first element\\n # iterate over the elements in the array to check for < or >\\n for index in range(arr.size()):\\n if arr[index] < minimum: # if element is less than the current min, min = new element\\n minimum = arr[index]\\n elif arr[index] > maximum: # if element is greater than the current max, max = new element\\n maximum = arr[index]\\n return minimum, maximum\",\n \"def get_bounds(self, value = None, index = None):\\n\\n if self._data is None or 0 in self._data.shape:\\n return (0.0, 0.0)\\n\\n if type(value) == types.IntType:\\n if self.value_dimension == 0:\\n maxi = nanmax(self._data[value, ::])\\n mini = nanmin(self._data[value, ::])\\n else:\\n # value_dimension == 1\\n maxi = nanmax(self._data[::, value])\\n mini = nanmin(self._data[::, value])\\n elif type(index) == types.IntType:\\n if self.index_dimension == 0:\\n maxi = nanmax(self._data[index, ::])\\n mini = nanmin(self._data[index, ::])\\n else:\\n # index_dimension == 1\\n maxi = nanmax(self._data[::, index])\\n mini = nanmin(self._data[::, index])\\n else:\\n # value is None and index is None:\\n maxi = nanmax(self._data)\\n mini = nanmin(self._data)\\n\\n return (mini, maxi)\",\n \"def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\\n return pulumi.get(self, \\\"ranges\\\")\",\n \"def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\\n return pulumi.get(self, \\\"ranges\\\")\",\n \"def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\\n return pulumi.get(self, \\\"ranges\\\")\",\n \"def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IDRangeArgs']]]]:\\n return pulumi.get(self, \\\"ranges\\\")\",\n \"def range(self):\\r\\n\\t\\treturn max(self.sample) - min(self.sample)\",\n \"def extreme_values(self, extreme):\\n\\n\\t\\tif extreme.lower() == 'min':\\n\\t\\t\\treturn data.min()\\n\\t\\telif extreme.lower() == 'max':\\n\\t\\t\\treturn data.max()\\n\\t\\telse:\\n\\t\\t\\tassert 'Invalid Parameter !'\",\n \"def get_features_min_max(self):\\n min_max_list = []\\n\\n # Get each feature's min and max values.\\n for feature_name in self.feature_names:\\n min = self.data[feature_name].min()\\n max = self.data[feature_name].max()\\n min_max_list.append([min, max])\\n\\n # Create dataframe from list of lists in correct format\\n min_max_df = pd.DataFrame(min_max_list)\\n min_max = min_max_df.T\\n min_max.columns = self.feature_names\\n min_max.index = ['min', 'max']\\n\\n return min_max\",\n \"def range(self):\\n lower, upper = sorted((self.y1, self.y2))\\n return FloatRange(lower=lower, upper=upper)\",\n \"def get_ranges(self) -> typing.List[typing.Tuple[float, float]]:\\n return self.ranges[:]\",\n \"def minmin_maxmax( *args ):\\n rmin = min( [ mv.min() for mv in args ] )\\n rmax = max( [ mv.max() for mv in args ] )\\n rmv = cdms2.createVariable( [rmin,rmax] )\\n return rmv\",\n \"def getRange(self) -> Tuple[int, int]:\\n return self.validator().bottom(), self.validator().top()\",\n \"def bounds(self) -> Tensor:\\n return torch.cat([self.mins, self.mins + self.ranges], dim=-2)\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7928218","0.759846","0.7561937","0.7432182","0.72924185","0.716103","0.7079898","0.7077026","0.7050836","0.68989515","0.6853273","0.677322","0.67359143","0.669912","0.66874564","0.66771185","0.6630462","0.65873176","0.65851694","0.65726477","0.6569491","0.6533301","0.65296024","0.651561","0.6509885","0.6508283","0.6486555","0.64570326","0.6450348","0.64111143","0.64012253","0.6395937","0.6384028","0.63654107","0.63647634","0.6353018","0.6343086","0.6311244","0.62959474","0.629532","0.62928385","0.6282906","0.62825215","0.62788874","0.62666625","0.62640476","0.6248214","0.6243511","0.6241706","0.6241585","0.624062","0.62402415","0.6239254","0.62316054","0.62176234","0.6209976","0.6206328","0.6196405","0.6195632","0.61931574","0.6184703","0.61846787","0.61757797","0.6168485","0.61549276","0.61446744","0.6141731","0.61352223","0.61279666","0.6127536","0.6124817","0.6123299","0.6116898","0.61038244","0.60928816","0.6089148","0.6066381","0.6049922","0.60494226","0.60461515","0.60461515","0.6040513","0.6039426","0.6036609","0.60302347","0.6027602","0.6021348","0.6019396","0.6016482","0.6016482","0.6016482","0.6016482","0.60133857","0.60119253","0.60105574","0.6001942","0.60017675","0.60005724","0.60003066","0.5999204","0.5994918"],"string":"[\n \"0.7928218\",\n \"0.759846\",\n \"0.7561937\",\n \"0.7432182\",\n \"0.72924185\",\n \"0.716103\",\n \"0.7079898\",\n \"0.7077026\",\n \"0.7050836\",\n \"0.68989515\",\n \"0.6853273\",\n \"0.677322\",\n \"0.67359143\",\n \"0.669912\",\n \"0.66874564\",\n \"0.66771185\",\n \"0.6630462\",\n \"0.65873176\",\n \"0.65851694\",\n \"0.65726477\",\n \"0.6569491\",\n \"0.6533301\",\n \"0.65296024\",\n \"0.651561\",\n \"0.6509885\",\n \"0.6508283\",\n \"0.6486555\",\n \"0.64570326\",\n \"0.6450348\",\n \"0.64111143\",\n \"0.64012253\",\n \"0.6395937\",\n \"0.6384028\",\n \"0.63654107\",\n \"0.63647634\",\n \"0.6353018\",\n \"0.6343086\",\n \"0.6311244\",\n \"0.62959474\",\n \"0.629532\",\n \"0.62928385\",\n \"0.6282906\",\n \"0.62825215\",\n \"0.62788874\",\n \"0.62666625\",\n \"0.62640476\",\n \"0.6248214\",\n \"0.6243511\",\n \"0.6241706\",\n \"0.6241585\",\n \"0.624062\",\n \"0.62402415\",\n \"0.6239254\",\n \"0.62316054\",\n \"0.62176234\",\n \"0.6209976\",\n \"0.6206328\",\n \"0.6196405\",\n \"0.6195632\",\n \"0.61931574\",\n \"0.6184703\",\n \"0.61846787\",\n \"0.61757797\",\n \"0.6168485\",\n \"0.61549276\",\n \"0.61446744\",\n \"0.6141731\",\n \"0.61352223\",\n \"0.61279666\",\n \"0.6127536\",\n \"0.6124817\",\n \"0.6123299\",\n \"0.6116898\",\n \"0.61038244\",\n \"0.60928816\",\n \"0.6089148\",\n \"0.6066381\",\n \"0.6049922\",\n \"0.60494226\",\n \"0.60461515\",\n \"0.60461515\",\n \"0.6040513\",\n \"0.6039426\",\n \"0.6036609\",\n \"0.60302347\",\n \"0.6027602\",\n \"0.6021348\",\n \"0.6019396\",\n \"0.6016482\",\n \"0.6016482\",\n \"0.6016482\",\n \"0.6016482\",\n \"0.60133857\",\n \"0.60119253\",\n \"0.60105574\",\n \"0.6001942\",\n \"0.60017675\",\n \"0.60005724\",\n \"0.60003066\",\n \"0.5999204\",\n \"0.5994918\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78499,"cells":{"query":{"kind":"string","value":"Return the range (min, max) of a dataset, based on quartiles (stable against large numbers)."},"document":{"kind":"string","value":"def calcrange_quartile(data, log=False):\n if not isinstance(data, numpy.ndarray):\n data = numpy.array(data)\n if log:\n data = data[data > 0.]\n\n if len(data) == 0:\n if log: return 0.1, 1.\n else: return 0., 1.\n\n data = numpy.sort(data)\n q1 = data[int(math.floor(0.25*len(data)))]\n q3 = data[int(math.floor(0.75*len(data)))]\n if log:\n return q1 / (q3 - q1), q3 * (q3 - q1)\n else:\n return q1 - (q3 - q1), q3 + (q3 - q1)"},"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 Quartiles(data):\n q = np.percentile(data, [25, 50, 75])\n\n return q[0], q[1], q[2]","def interquartile_range(x):\n return (quantile(x,0.75) - quantile(x,0.25))","def interquartile_range(xs: List[float]) -> float:\n return quantile(xs, 0.75) - quantile(xs, 0.25)","def data_range(x):\n return max(x)-min(x)","def getquantile(df, low=0.1, high=0.9):\n q1 = df.quantile(low)\n q3 = df.quantile(high)\n print(q1)\n print(q3)\n return df[df<q1],df[df>q3]","def data_range(xs: List[float]) -> float:\n return max(xs) - min(xs)","def get_quantile_thresholds(ds, quantile, dim, lat_name='lat', lon_name='lon', lat_chunk=1, lon_chunk=1):\n ds = ds.chunk({**{lat_name: 1, lon_name: 1},\n **{d: -1 for d in dim}})\n return ds.quantile(quantile, dim)","def m_to_range(self, data):\n return (data - self._min_range_m) / self._total_range","def get_range(cls, data: tuple or list) -> float:\n cls._data_validation(data)\n max_ = cls.get_max(data)\n min_ = cls.get_min(data)\n return float(max_ - min_)","def outlier_thresholds(dataframe, col_name, low_quantile, up_quantile):\n quartile1 = dataframe[col_name].quantile(low_quantile)\n quartile3 = dataframe[col_name].quantile(up_quantile)\n interquantile_range = quartile3 - quartile1\n up_limit = quartile3 + 1.5 * interquantile_range\n low_limit = quartile1 - 1.5 * interquantile_range\n return low_limit, up_limit","def get_quartile_data(cls, data: tuple or list) -> tuple:\n cls._data_validation(data)\n # Sort the data\n sorted_data = sorted(list(data))\n # Get q2, which is the median\n q2 = cls.get_median(data)\n first_half_data = list()\n second_half_data = list()\n # add to first half until median, then add to second half\n for i in range(len(sorted_data)):\n # if less than q2, first half\n if sorted_data[i] < q2:\n first_half_data.append(sorted_data[i])\n # if greather than q2, second half, skips q2\n elif sorted_data[i] > q2:\n second_half_data.append(sorted_data[i])\n # use median method on halves to get quartiles\n q1 = cls.get_median(first_half_data)\n q3 = cls.get_median(second_half_data)\n iqr = q3-q1\n return q1, q2, q3, iqr","def quartile(db: pd.DataFrame, col: str) -> pd.DataFrame:\n _, bins = pd.qcut(x=db[col],\n q=[0.25, 0.75], # [0.0, 0.25, 0.5, 0.75, 1.0],\n retbins=True, duplicates='drop')\n q1 = bins[0] # lower (first) quartile\n q3 = bins[1] # upper (third) quartile\n iqr = q3 - q1 # InterQuartile Range\n lower_fence = (q1 - 1.5 * iqr)\n upper_fence = (q3 + 1.5 * iqr)\n db.loc[db[col] < lower_fence, col] = q1\n db.loc[db[col] > upper_fence, col] = q3\n return db","def performance_quantiles(data, performance_measure):\n quantiles = pd.qcut(x=data[performance_measure], q=4, labels=['q1', 'q2', 'q3', 'q4'])\n bins = quantiles.to_frame(name=performance_measure + '_quantiles')\n data_quantiles = pd.merge(data, bins, right_index=True, left_index=True)\n data_quantiles.dropna(inplace=True)\n data_quantiles.sort_values(performance_measure + '_quantiles', inplace=True)\n return data_quantiles","def get_quartile_data(cls, data: tuple or list) -> tuple:\n cls._data_validation(data)\n from math import floor\n # Sort the data\n n = cls.get_n(data)\n if n == 0:\n # Empty dataset, returns zeroes\n return 0, 0, 0, 0\n sorted_data = sorted(list(data))\n n_is_odd = True if n % 2 == 1 else False\n\n # Get middle index\n odd_middle_index = floor(n / 2)\n even_upper_index = floor(n / 2)\n even_lower_index = floor(n / 2) - 1\n\n # Get q2, which is the median\n q2 = cls.get_median(data)\n first_half_data = list()\n second_half_data = list()\n\n # add to first half until median, then add to second half\n if n_is_odd:\n for i in range(n):\n if i < odd_middle_index:\n first_half_data.append(sorted_data[i])\n # note how if index = middle_index, skips\n elif i > odd_middle_index:\n second_half_data.append(sorted_data[i])\n else:\n for i in range(n):\n if i <= even_lower_index:\n first_half_data.append(sorted_data[i])\n # note how if index = middle_index, skips\n else:\n second_half_data.append(sorted_data[i])\n # use median method on halves to get quartiles\n q1 = cls.get_median(first_half_data)\n q3 = cls.get_median(second_half_data)\n iqr = q3 - q1\n return q1, q2, q3, iqr","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 interquartile_range(magnitudes):\n num_obs = magnitudes.shape[0]\n per_25 = int(num_obs / 4.0)\n\n q1 = magnitudes[per_25]\n q3 = magnitudes[num_obs - per_25]\n\n return (q3 - q1)[0]","def test_profiled_quantiles(self):\n\n # this data has 4 bins, range of 3\n # with equal bin size, each bin has the width of 0.75\n\n data = [\"1.0\", \"2.0\", \"3.0\", \"4.0\"]\n df = pd.Series(data)\n profiler = FloatColumn(df.name)\n profiler.update(df)\n profile = profiler.profile\n\n est_quartiles = profile['quantiles']\n est_Q1 = est_quartiles[249]\n est_Q2 = est_quartiles[499]\n est_Q3 = est_quartiles[749]\n\n data_to_num = [float(item) for item in data]\n exact_Q1 = np.percentile(data_to_num, 25)\n exact_Q2 = np.percentile(data_to_num, 50)\n exact_Q3 = np.percentile(data_to_num, 75)\n\n self.assertEqual(est_Q1, exact_Q1)\n self.assertEqual(est_Q2, exact_Q2)\n self.assertEqual(est_Q3, exact_Q3)","def quantileValues(data, device):\n r = pd.DataFrame([])\n if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):\n minValue = data.min()\n maxValue = data.max()\n q1 = data.quantile(0.25)\n # q2 = tmp['deltaSeconds'].quantile(0.5)\n q3 = data.quantile(0.75)\n QR = q3 - q1\n upper = 1.5 * QR + q3\n lower = q1 - 1.5 * QR\n\n elif isinstance(data, np.ndarray):\n minValue = data.min()\n maxValue = data.max()\n q1 = np.percentile(data, 25)\n # q2 = np.percentile(data, 50)\n q3 = np.percentile(data, 75)\n QR = q3 - q1\n upper = 1.5 * QR + q3\n lower = q1 - 1.5 * QR\n r = (r.append(pd.DataFrame({'mac': device.mac, 'minValue': minValue,\n 'maxValue': maxValue, 'lower': lower,\n 'upper': upper, 'q1': q1, 'q3': q3},\n index=[0]), ignore_index=True))\n return r","def _computeRangeFromData(data):\n if data is None:\n return None\n\n dataRange = min_max(data, min_positive=True, finite=True)\n if dataRange.minimum is None: # Only non-finite data\n return None\n\n if dataRange is not None:\n min_positive = dataRange.min_positive\n if min_positive is None:\n min_positive = float('nan')\n return dataRange.minimum, min_positive, dataRange.maximum","def default_quantile():\n return np.logspace(-5, 0, 100)","def _quantile(data, quantile):\r\n index = quantile * (len(data) - 1)\r\n bottom_index = int(floor(index))\r\n top_index = int(ceil(index))\r\n\r\n difference = index - bottom_index\r\n output = (1 - difference) * \\\r\n data[bottom_index] + difference * data[top_index]\r\n\r\n return output","def get_limit(series, k=3):\n q1 = series.quantile(q=0.25)\n q3 = series.quantile(q=0.75)\n iqr = q3 - q1\n upper = q3 + 3 * iqr\n lower = q1 - 3 * iqr\n return upper, lower","def range(df):\r\n\r\n\tdf_range_dict = dict()\r\n\r\n\tfor i, col in enumerate(df.columns):\r\n\t\tdf_range_dict[col] = [df[col].max(), df[col].min(), df[col].max() - df[col].min()]\r\n\r\n\tdf_range = pd.DataFrame(df_range_dict, index=['Max Value', 'Min Value', 'Range (Max - Min)'])\r\n\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\r\n\r\n\treturn df_range","def data_quartiles(self):\n data = []\n for graph in self._graphs.values():\n data += graph.data.values()\n data.sort()\n datalen = len(data)\n return(data[0], data[datalen/4], data[datalen/2],\n data[3*datalen/4], data[-1])","def quartiles(x, percentile):\n length = len(x)\n\n if percentile == 25:\n center = length // 4\n elif percentile == 75:\n center = length // 2 + length // 4\n\n x.sort()\n\n if length % 2 == 0:\n return (x[center - 1] + x[center]) / 2\n else:\n return x[center]","def find_outlier_range(dfs: pd.Series, iqr_factor=1.5, clip_low=None, clip_high=None):\n quant1 = dfs.quantile(0.25)\n quant3 = dfs.quantile(0.75)\n IQR = quant3 - quant1\n low = quant1 - iqr_factor * IQR\n high = quant3 + iqr_factor * IQR\n\n if clip_low is not None:\n low = max(clip_low, low)\n if clip_high is not None:\n high = min(clip_high, high)\n return (low, high)","def compute_quantile(risk, T_max: int, scenario_numbers, quantile):\r\n\r\n print(\"\\tComputing Quantile...\")\r\n # Init quantile\r\n q = np.zeros(T_max)\r\n for t in range(T_max):\r\n risk[t].sort()\r\n q[t] = risk[t][int(np.ceil(scenario_numbers[t] * quantile)) - 1]\r\n print(\"\\tDone\")\r\n\r\n return q","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 Quantile(data, q, precision=1.0):\n N, bins = np.histogram(data, bins=precision*np.sqrt(len(data)))\n norm_cumul = 1.0*N.cumsum() / len(data)\n\n for i in range(0, len(norm_cumul)):\n if norm_cumul[i] > q:\n return bins[i]","def get_range(df, col):\n return df[col].min(), df[col].max()","def quantiles(x, qlist=[2.5, 25, 50, 75, 97.5]):\n # Make a copy of trace\n x = x.copy()\n\n # For multivariate node\n if x.ndim > 1:\n # Transpose first, then sort, then transpose back\n sx = np.transpose(np.sort(np.transpose(x)))\n else:\n # Sort univariate node\n sx = np.sort(x)\n\n try:\n # Generate specified quantiles\n quants = [sx[int(len(sx) * q / 100.0)] for q in qlist]\n\n return dict(zip(qlist, quants))\n\n except IndexError:\n print(\"Too few elements for quantile calculation\")","def _full_value_range(self):\n min_value, max_value = self._raw_data.data_range\n return max_value - min_value","def min_max_outliers(res, min=None, max=None):\n min_max_list = []\n if isinstance(min, (int, float)):\n data1 = res[res < min].reset_index()\n data1['limit type'] = 'minimum'\n data1['limit'] = min\n min_max_list.append(data1)\n if isinstance(max, (int, float)):\n data1 = res[res > max].reset_index()\n data1['limit type'] = 'maximum'\n data1['limit'] = max\n min_max_list.append(data1)\n\n min_max1 = pd.concat(min_max_list)\n\n return min_max1","def normalizeToRange(data,max=255,min=0):\n if min: return (max-min)*normalize(data)+min\n else: return max*normalize2(data) # speeds up operation","def findRanges(data_grouped):\n ranges = []\n for i in data_grouped.columns:\n theRange = (data_grouped[i].min(), data_grouped[i].max())\n ranges.append(theRange)\n return ranges","def interq_range(sig):\n #ny.percentile(sig, 75) - ny.percentile(sig, 25)\n return np.percentile(sig, 75) - np.percentile(sig, 25)","def band_quantiles(self, band):\n min_pdf = self.pvalues[self.alpha.index(band[0])]\n try:\n max_pdf = self.pvalues[self.alpha.index(band[1])]\n except IndexError:\n max_pdf = 1E6\n self.band = [min_pdf, max_pdf]\n\n pool = Pool()\n band_quantiles = pool.map(self._min_max_band, range(self.dim))\n pool.terminate()\n pool.close()\n\n band_quantiles = list(zip(*band_quantiles))\n\n return band_quantiles","def get_density_range(tds, min_range, buffer=100):\n buffered_range = min_range\n for alane in tds['lanes']:\n for atile in tds[alane]:\n dk = atile['density_k']\n\n # See if dk is going to fit on a plot bounded by current min_range.\n # The idea is that if res is 1000 and dk is 1020 we extend res to 1200\n # because we round up to the nearest 100 then add 100\n buffered_range = max(buffered_range, (ceil(dk/buffer) * buffer) + buffer)\n\n return float(buffered_range)","def calc_stats(data):\n x = np.asarray(data, np.float)\n vals_min = np.min(x)\n vals_max = np.max(x)\n q2 = np.percentile(x, 50, interpolation='linear')\n q1 = np.percentile(x, 25, interpolation='lower')\n q3 = np.percentile(x, 75, interpolation='higher')\n iqr = q3 - q1\n whisker_dist = 1.5 * iqr\n\n # in order to prevent drawing whiskers outside the interval\n # of data one defines the whisker positions as:\n d1 = np.min(x[x >= (q1 - whisker_dist)])\n d2 = np.max(x[x <= (q3 + whisker_dist)])\n return {\n 'min': vals_min,\n 'max': vals_max,\n 'q1': q1,\n 'q2': q2,\n 'q3': q3,\n 'd1': d1,\n 'd2': d2\n }","def range_to_m(self, data):\n return data * self._total_range + self._min_range_m","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 _get_quantiles(X, quantile_range):\n quantiles = []\n for feature_idx in range(X.shape[1]):\n if sparse.issparse(X):\n column_nnz_data = X.data[\n X.indptr[feature_idx]: X.indptr[feature_idx + 1]]\n column_data = np.zeros(shape=X.shape[0], dtype=X.dtype)\n column_data[:len(column_nnz_data)] = column_nnz_data\n else:\n column_data = X[:, feature_idx]\n quantiles.append(np.nanpercentile(column_data, quantile_range))\n\n quantiles = np.transpose(quantiles)\n\n return quantiles","def heckbert_interval(data_low, data_high, numticks=8, nicefunc=_nice, enclose=False):\n if data_high == data_low:\n return data_high, data_low, 0\n if numticks == 0:\n numticks = 1\n\n range = nicefunc(data_high - data_low)\n if numticks > 1:\n numticks -= 1\n d = nicefunc(range / numticks, round=True)\n if enclose:\n graphmin = ceil(data_low / d) * d\n graphmax = floor(data_high / d) * d\n else:\n graphmin = floor(data_low / d) * d\n graphmax = ceil(data_high / d) * d\n return graphmin, graphmax, d","def get_range(lst):\n return float(max(lst)) - float(min(lst))","def scale(value,rawmin=100941, rawmax=274919, rangemin=0, rangemax=100):\n\n # Convert the left range into a 0-1 range (float)\n valueScaled = float(value - rawmin) / float(rawmax - rawmin)\n\n # Convert the 0-1 range into a value in the right range.\n value = rangemin + (valueScaled * ((rangemax * 10) - rangemin))\n\n value = value // 10 * 10 // 10 # float to int\n\n return max(value, rangemin) # value must be greater or equal to rangemin","def get_quantiles(self, q, interpolation=\"linear\", lb=None):\n qarr = np.asarray(q, dtype=float)\n if np.any(np.logical_and(qarr > 1, qarr < 0)):\n raise ValueError(\"q values must fall within [0, 1].\")\n else:\n qtls, qtlhdrs = self._qtls_formatter(q=q)\n qtl_pairs = [(qtlhdrs[ii], qtls[ii]) for ii in range(len(qtls))]\n dqq = {\n str(ii[0]): [\n np.percentile(\n self.reserve_dist[self.reserve_dist.origin == origin][\"reserve\"].values,\n 100 * ii[-1], interpolation=interpolation\n ) for origin in self.summary.index] for ii in qtl_pairs\n }\n dfqq = pd.DataFrame().from_dict(dqq).set_index(self.summary.index)\n if lb is not None:\n dfqq = dfqq.applymap(lambda v: lb if v < lb else v)\n return(dfqq)","def find_min_max(data):\n v = [i[1] for i in data]\n extremes = [min(v), max(v)]\n logging.info('Calculated extremes: %s', extremes)\n return extremes","def range(series):\n return min(series), max(series)","def quantiles(self, q: int):\n return self.dist.quantiles(q)","def boxplot(values):\n percentiles = percentile(values, [0, 25, 50, 75, 100])\n result = {'min_val': percentiles[0],\n 'q1_val': percentiles[1],\n 'mean_val': percentiles[2],\n 'q3_val': percentiles[3],\n 'max_val': percentiles[4]}\n return result","def sortAndReturnQuantiles(values):\n \n values.sort()\n N = len(values)\n return (values[0], values[N/4], values[N/2], values[(3*N)/4], values[N-1])","def make_quartiles(s, q1, q3):\n return graph_objs.Scatter(\n x=[s, s],\n y=[q1, q3],\n text=['lower-quartile: ' + '{:0.2f}'.format(q1),\n 'upper-quartile: ' + '{:0.2f}'.format(q3)],\n mode='lines',\n line=graph_objs.Line(\n width=4,\n color='rgb(0,0,0)'\n ),\n hoverinfo='text'\n )","def calcrange(a4lim,data):\r\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\r\n return a4range","def select_range_and_scale(data, color_min, color_max, fac=1.0):\n scaled = ((data - color_min) * 1.0 / (color_max - color_min))\n scaled[scaled < 0.0] = 0.0\n scaled[scaled > 1.0] = 1.0\n if fac != 0.0:\n scaled = scaled * fac\n return scaled","def domain_range(domain, _range=[0, 1], return_transform=False):\n\n if not return_transform:\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\n else:\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element","def normalize_range(array, floor=0, ceil=1):\n scaler = MinMaxScaler(feature_range=(floor, ceil), copy=True)\n return scaler.fit_transform(array)","def _get_min_max_value(min, max, value=None, step=None):\n # Either min and max need to be given, or value needs to be given\n if value is None:\n if min is None or max is None:\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\n diff = max - min\n value = min + (diff / 2)\n # Ensure that value has the same type as diff\n if not isinstance(value, type(diff)):\n value = min + (diff // 2)\n else: # value is not None\n if not isinstance(value, Real):\n raise TypeError('expected a real number, got: %r' % value)\n # Infer min/max from value\n if value == 0:\n # This gives (0, 1) of the correct type\n vrange = (value, value + 1)\n elif value > 0:\n vrange = (-value, 3*value)\n else:\n vrange = (3*value, -value)\n if min is None:\n min = vrange[0]\n if max is None:\n max = vrange[1]\n if step is not None:\n # ensure value is on a step\n tick = int((value - min) / step)\n value = min + tick * step\n if not min <= value <= max:\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\n return min, max, value","def quantiles(x, num_buckets, epsilon, name=None):\n\n with tf.name_scope(name, 'quantiles'):\n spec = _QuantilesSpec(epsilon, num_buckets)\n quantile_boundaries = Analyzer(\n [x], [(spec.bucket_dtype, [1, None], False)], spec,\n 'quantiles').outputs[0]\n\n # quantile boundaries is of the form\n # [nd.arrary(first, <num_buckets-1>, last)]\n # Drop the fist and last quantile boundaries, so that we end-up with\n # num_buckets-1 boundaries, and hence num_buckets buckets.\n return quantile_boundaries[0:1, 1:-1]","def get_dec_i_range(data_decs):\n data_dec_is = map_list(lambda x: (x - 1800)//10, data_decs)\n lower_range_i = data_dec_is[0]\n upper_range_i = data_dec_is[-1] + 1\n return (lower_range_i, upper_range_i)","def __q_gxg__(series, q, tmin=None, tmax=None, by_year=True):\n if tmin is not None:\n series = series.loc[tmin:]\n if tmax is not None:\n series = series.loc[:tmax]\n series = series.resample('d').median()\n if by_year:\n return (series\n .resample('a')\n .apply(lambda s: s.quantile(q))\n .mean()\n )\n else:\n return series.quantile(q)","def quantile(data, quantiles):\r\n\r\n assert isinstance(data, list) or isinstance(data, ndarray), \"Data must be either\" +\\\r\n \" a Python list or a NumPy 1-D array\"\r\n assert isinstance(quantiles, list) or isinstance(quantiles, ndarray), \"Quantiles\" +\\\r\n \" must be either a Python list or a NumPy 1-D array\"\r\n assert all(map(lambda x: x >= 0 and x <= 1, quantiles)), \"All the elements \" +\\\r\n \"in the quantiles list must be greater than 0 and lower than one\"\r\n\r\n # unless the user wanted, do not modify the data\r\n data = deepcopy(data)\r\n\r\n if not isinstance(data, ndarray):\r\n data = array(data)\r\n data.sort()\r\n\r\n output = []\r\n # if needed different quantile methods could be used\r\n for one_quantile in quantiles:\r\n output.append(_quantile(data, one_quantile))\r\n\r\n return output","def get_dyn_range(scale, zero_point, dtype):\n if dtype == torch.quint8:\n min_val, max_val = 0, 255\n elif dtype == torch.qint8:\n min_val, max_val = -128, 127\n else:\n raise RuntimeError(f\"Unsupported quantized dtype {dtype}\")\n\n return (min_val - zero_point) * scale, (max_val - zero_point) * scale","def range_(headers, data):\n\tcolumn_matrix=data.get_data(headers).getT() # get columns as rows, as this makes analysis much easier by just perfoming operations on column list directly\n\tif column_matrix==[]:\n\t\tprint \"wrong headers, not present in data Object\"\n\t\treturn []\n\tcolumn_max=column_matrix.max(1)\n\tcolumn_min=column_matrix.min(1)\n\tfinal=np.concatenate((column_min, column_max), axis=1)\n\t\n\trng=final.tolist()\n\treturn rng","def percentile_between(self,\n min_percentile,\n max_percentile,\n mask=NotSpecified):\n return PercentileFilter(\n self,\n min_percentile=min_percentile,\n max_percentile=max_percentile,\n mask=mask,\n )","def normalise_min_max(df):\n return (df - df.min()) / (df.max() - df.min())","def normalise_min_max(df):\n return (df - df.min()) / (df.max() - df.min())","def _bound(x, min_value, max_value):\n return np.maximum(min_value, np.minimum(x, max_value))","def quantile(feature, bins):\n t = feature.sort_values().values\n w = round(len(t)/bins)\n return [t[w*i-1] for i in range(1, bins)]","def percentile_normalization(data: np.ndarray, percentile: int = 1) -> np.ndarray:\n\n min_percentile = np.percentile(data, percentile)\n max_percentile = np.percentile(data, 100 - percentile)\n\n # limit maximum intensity of data by max_percentile\n data[data >= max_percentile] = max_percentile\n\n # limit minimum intensity of data by min_percentile\n data[data <= min_percentile] = min_percentile\n\n return data","def test__quantile(self):\r\n # regular cases\r\n sample_data = array(range(25, 42))\r\n assert_almost_equal(_quantile(sample_data, 0.5), median(sample_data))\r\n\r\n # sorted data is assumed for this function\r\n sample_data = sorted(\r\n array([0.17483293, 0.99891939, 0.81377467, 0.8137437,\r\n 0.51990174, 0.35521497, 0.98751461]))\r\n assert_almost_equal(_quantile(sample_data, 0.10), 0.283062154)","def get_quantiles(data, quantiles):\n variables = list(data.data_vars)\n proxy_quant_df = pd.DataFrame(columns=[str(i) for i in quantiles], index=variables)\n for var in variables:\n for q in quantiles:\n proxy_quant_df.loc[var, str(q)] = data[var].quantile(q).values\n\n return proxy_quant_df","def variable_range(examples, var):\n if var[1] == 'd':\n range = set()\n for datum in examples:\n range.add(datum[var[0]])\n return range\n else:\n range_min, range_max = 0, 0\n for datum in examples:\n data_val = float(datum[var[0]])\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\n return (range_min, range_max)","def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\n ...","def ex_range(data):\n a, b, step = _cleanse_range_args(data)\n return list(range(a, b+sign(step), step))","def quantiles(self):\n return self._quantiles","def from_range(data, max_samples, start, end, lowpass):\n\n # handle the case of no data\n if data.shape[0] == 0:\n return data\n\n if start is None:\n start = 0\n else:\n try:\n start = data.index.get_loc(start, method=\"nearest\")\n except InvalidIndexError:\n # handle non-ordered/non-unique index\n start = np.argmin(np.abs(data.index - start))\n\n if end is None:\n end = data.shape[0]\n else:\n try:\n end = data.index.get_loc(end, method=\"nearest\") + 1\n except InvalidIndexError:\n # handle non-ordered/non-unique index\n end = np.argmin(np.abs(data.index - end)) + 1\n\n step = int(np.ceil((end - start) / max_samples))\n\n # TODO: handle NaNs at start/end\n if step == 0:\n # hacky solution for range reset\n data_new = pd.concat((data.iloc[:1], data.iloc[-1:]))\n else:\n data_new = data.iloc[start:end]\n if step > 1 and lowpass:\n # TODO make this work\n from scipy.signal import butter, filtfilt\n\n for c in data_new.columns:\n if c != \"selected\":\n coefs = butter(3, 1 / step)\n data_new[c] = filtfilt(\n coefs[0], coefs[1], data_new.loc[:, c]\n )\n data_new = data_new.iloc[::step]\n # hacky solution for range reset\n if start > 0:\n data_new = pd.concat((data.iloc[:1], data_new))\n if end < data.shape[0] - 1:\n data_new = data_new.append(data.iloc[-1])\n\n return data_new","def __q_gxg__(series, q, tmin=None, tmax=None, by_year=True):\n if tmin is not None:\n series = series.loc[tmin:]\n if tmax is not None:\n series = series.loc[:tmax]\n series = series.resample('d').median()\n if by_year:\n return (series\n .resample('a')\n .apply(lambda s: s.quantile(q))\n .mean()\n )\n else:\n return series.quantile(q)\n\n # noinspection PyIncorrectDocstring,PyIncorrectDocstring","def tau_percentile(x, tau, a=0.997):\n y = np.cumsum(tau)\n y = y/y.max()\n\n a_low = (1 - a) / 2\n a_high = (1 + a) / 2\n\n x_range = list()\n for p in [a_low, a_high]:\n i1 = max((y < p).nonzero()[0])\n i2 = i1 + 1\n slope = (y[i2] - y[i1]) / (x[i2] - x[i1])\n x_int = x[i2] + (p - y[i2])/slope\n x_range.append(x_int)\n\n return x_range","def test_returns_custom_range(self):\n img = np.arange(5)\n\n actual = util.apply_gamma(img, out_min=0, out_max=255, gamma=1)\n self.assertEqual(actual.min(), 0)\n self.assertEqual(actual.max(), 255)","def split_data(data, nq, flag=1):\n if flag == 1:\n quantiles = np.linspace(data.min(), data.max(), nq + 1)\n elif flag == 2:\n segs = np.linspace(0, 100, nq + 1)\n quantiles = np.percentile(data, segs)\n quantiles[0] = quantiles[0] - 1e-15\n quantiles[-1] = quantiles[-1] + 1e-15\n grp_names = np.digitize(data, quantiles) - 1\n return grp_names","def test_get_quartile_data(self):\n LOWER = 0\n MID = 1\n UPPER = 2\n number_of_simulations = 100\n expected_lower = 25\n expected_middle = 50\n expected_upper = 75\n quartile_tuple = investment_growth.get_quartile_data(number_of_simulations)\n self.assertEqual(expected_lower, quartile_tuple[LOWER])\n self.assertEqual(expected_middle, quartile_tuple[MID])\n self.assertEqual(expected_upper, quartile_tuple[UPPER])","def get_stats(dataframe, variable):\n\n print(\"Maximum value of \", variable, \"is: \", dataframe[variable].max(), \" in the row \", dataframe[dataframe[variable] == dataframe[variable].max()])\n print(\"Minimum value of \", variable, \"is: \", dataframe[variable].min())\n print(\"Mean of \", variable, \" is: \", dataframe[variable].mean())\n print(\"Standard deviation of \", variable, \" is: \", dataframe[variable].std())\n print(\"Mode of \", variable, \" is: \", dataframe[variable].mode())\n print(\"Median of \", variable, \" is: \", dataframe[variable].median())\n\n # For speed: disregard points that are lower than 2.5 (to avoid stationary periods) as part of the interquartile range and greater than 100, which is only a few points anyway.\n dataframeselection = dataframe.loc[(dataframe[variable] >= 2.5) & (dataframe[variable] < 100)]\n q1 = dataframeselection[variable].quantile(0.25)\n q3 = dataframeselection[variable].quantile(0.75)\n iqr = q3 - q1\n print(\"Upper quartile of \", variable, \" is: \", q3)\n print(\"Lower quartile of \", variable, \" is: \", q1)\n print(\"Interquartile range of \", variable, \" is: \", iqr)\n lower_limit = q1-1.5*iqr\n upper_limit = q3+1.5*iqr\n print(\"Lower limit for outliers from IQR for \", variable, \" is: \", lower_limit)\n print(\"Upper limit for outliers from IQR for \", variable, \" is: \", upper_limit)\n points_above_upper_limit = len(dataframe.loc[(dataframe[variable] > (q3+1.5*iqr)) & (dataframe[variable] < 100)])\n number_of_points = len(dataframe)\n print(\"Total number of data points\", number_of_points)\n print(\"There are \", points_above_upper_limit, \" points that lie above the upper bound, which corresponds to \", (points_above_upper_limit/number_of_points)*100, \" %\")\n\n return upper_limit","def quantile(x,p):\n p_index = int(p*len(x))\n return sorted(x)[p_index]","def find_outliers(data, method='iqr'):\n\n if method=='iqr':\n # Finding the interquartile range\n q1 = data.quantile(.25)\n q3 = data.quantile(.75)\n iqr = q3-q1\n\n upper = q3 + iqr*1.5\n lower = q1 - iqr*1.5\n elif method=='std':\n std = data.std()\n lower = data.mean() - 3*std\n upper = data.mean() + 3*std\n else:\n raise ValueError(\"Invalid value for 'method' passed\")\n\n\n return lower, upper","def IQR(x):\r\n\r\n x.sort()\r\n # split values into lower and upper portions at the median\r\n odd = len(x) % 2\r\n midpoint = int(len(x) / 2)\r\n if odd:\r\n low_vals = x[:midpoint]\r\n high_vals = x[midpoint + 1:]\r\n else: # if even\r\n low_vals = x[:midpoint]\r\n high_vals = x[midpoint:]\r\n # find the median of the low and high values\r\n min_val = median(low_vals)\r\n max_val = median(high_vals)\r\n return min_val, max_val","def GetRange(vDataSet,channel=None):\r\n nc = vDataSet.GetSizeC()\r\n maset = 0\r\n if channel is None:\r\n channels = range(nc)\r\n else:\r\n channels = [channel]\r\n\r\n for i in channels:\r\n ma = vDataSet.GetChannelRangeMax(i)\r\n if ma > maset:\r\n maset = ma\r\n\r\n maset = np.power(2,np.ceil(np.log2(maset)))-1\r\n return 0,maset","def _quantiles(self):\n\n trials = []\n for trial, state in self._trial_state.items():\n if state.last_score is not None and not trial.is_finished():\n trials.append(trial)\n trials.sort(key=lambda t: self._trial_state[t].last_score)\n\n if len(trials) <= 1:\n return [], []\n else:\n num_trials_in_quantile = int(\n math.ceil(len(trials) * self._quantile_fraction))\n if num_trials_in_quantile > len(trials) / 2:\n num_trials_in_quantile = int(math.floor(len(trials) / 2))\n return (trials[:num_trials_in_quantile],\n trials[-num_trials_in_quantile:])","def drop_outliers_quantile(df, upper=0.99, lower=0):\n n_initial_rows = df.shape[0]\n drop_list = set()\n quant_upper = df.quantile(upper)\n quant_lower = df.quantile(lower)\n\n print('-' * 25)\n print('OUTLIERS DELETION: QUANTILE METHOD\\n')\n\n for el in df.columns.values:\n drop_list = drop_list | \\\n set(df[el][df[el] > quant_upper[el]].index.values) | \\\n set(df[el][df[el] < quant_lower[el]].index.values)\n\n drop_list = list(set(drop_list))\n count = len(drop_list)\n df.drop(drop_list, inplace=True)\n\n print('Lower quantile: {} | Upper quantile: {}'.format(lower, upper))\n print('N of deleted rows: {} | % of deleted rows: {}%'.format(\n count, round(100 * (count / n_initial_rows), 3)))\n return df","def _parse_vrange(self, data):\n vmin = self.config.get('vmin', np.nanmin(data))\n vmax = self.config.get('vmax', np.nanmax(data))\n vrange = self.config.get('vrange', None)\n\n # Parse vmin, vmax\n if isinstance(vmin, str):\n vmin = np.nanquantile(data, q=float(vmin))\n if isinstance(vmax, str):\n vmax = np.nanquantile(data, q=float(vmax))\n\n # Parse vrange\n if vrange is True:\n vrange = max(abs(np.nanmin(data)), abs(np.nanmax(data)))\n elif isinstance(vrange, str):\n vrange = abs(np.nanquantile(data, q=(float(vrange), 1-float(vrange)))).max()\n\n if vrange is not None:\n if isinstance(vrange, (list, tuple, np.ndarray)):\n vmin, vmax = vrange\n else:\n vmin, vmax = -vrange, vrange\n return vmin, vmax","def get_range(min, max, intervals, log):\n if not log:\n min = float(min)\n max = float(max)\n difference = max-min\n step_size = difference/intervals\n output = [min + i*step_size for i in range(intervals+1)]\n return output\n else:\n from math import log10 as log\n log_min = log(min)\n log_max = log(max)\n log_difference = log_max - log_min\n step_size = log_difference/intervals\n output = [pow(10, log_min + i*step_size) for i in range(intervals+1)]\n return output","def get_bucket_boundaries(feature):\n return np.unique(np.percentile(feature, range(0, 100))).tolist()","def IQR(data):\n return percentile(data, 75) - percentile(data, 25)","def GetScalarRange(self):\n ...","def in_range(data, minval=-np.inf, maxval=np.inf):\n return (minval <= data) & (data <= maxval)","def midrange(lo, hi, mid=0, scale=1.0):\n return [min(mid, (mid + lo) / (1.0 + scale)),\n max(mid, (mid + hi) / (1.0 + scale))]","def prctile(data, p_vals=[0, 25, 50, 75, 100], sorted_=False):\r\n ps = [p_vals] if np.isscalar(p_vals) else p_vals\r\n\r\n if not sorted_:\r\n data = sorted(data)\r\n n = len(data)\r\n d = []\r\n for p in ps:\r\n fi = p * n / 100 - 0.5\r\n if fi <= 0: # maybe extrapolate?\r\n d.append(data[0])\r\n elif fi >= n - 1:\r\n d.append(data[-1])\r\n else:\r\n i = int(fi)\r\n d.append((i+1 - fi) * data[i] + (fi - i) * data[i+1])\r\n return d[0] if np.isscalar(p_vals) else d","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def quantile(x, p):\n p_index = int(p * len(x))\n return sorted(x)[p_index]","def get_minmax_stats(dataframe, variable):\n\n print(\"Maximum value of \", variable, \"is: \", dataframe[variable].max())\n print(\"Minimum value of \", variable, \"is: \", dataframe[variable].min())"],"string":"[\n \"def Quartiles(data):\\n q = np.percentile(data, [25, 50, 75])\\n\\n return q[0], q[1], q[2]\",\n \"def interquartile_range(x):\\n return (quantile(x,0.75) - quantile(x,0.25))\",\n \"def interquartile_range(xs: List[float]) -> float:\\n return quantile(xs, 0.75) - quantile(xs, 0.25)\",\n \"def data_range(x):\\n return max(x)-min(x)\",\n \"def getquantile(df, low=0.1, high=0.9):\\n q1 = df.quantile(low)\\n q3 = df.quantile(high)\\n print(q1)\\n print(q3)\\n return df[df<q1],df[df>q3]\",\n \"def data_range(xs: List[float]) -> float:\\n return max(xs) - min(xs)\",\n \"def get_quantile_thresholds(ds, quantile, dim, lat_name='lat', lon_name='lon', lat_chunk=1, lon_chunk=1):\\n ds = ds.chunk({**{lat_name: 1, lon_name: 1},\\n **{d: -1 for d in dim}})\\n return ds.quantile(quantile, dim)\",\n \"def m_to_range(self, data):\\n return (data - self._min_range_m) / self._total_range\",\n \"def get_range(cls, data: tuple or list) -> float:\\n cls._data_validation(data)\\n max_ = cls.get_max(data)\\n min_ = cls.get_min(data)\\n return float(max_ - min_)\",\n \"def outlier_thresholds(dataframe, col_name, low_quantile, up_quantile):\\n quartile1 = dataframe[col_name].quantile(low_quantile)\\n quartile3 = dataframe[col_name].quantile(up_quantile)\\n interquantile_range = quartile3 - quartile1\\n up_limit = quartile3 + 1.5 * interquantile_range\\n low_limit = quartile1 - 1.5 * interquantile_range\\n return low_limit, up_limit\",\n \"def get_quartile_data(cls, data: tuple or list) -> tuple:\\n cls._data_validation(data)\\n # Sort the data\\n sorted_data = sorted(list(data))\\n # Get q2, which is the median\\n q2 = cls.get_median(data)\\n first_half_data = list()\\n second_half_data = list()\\n # add to first half until median, then add to second half\\n for i in range(len(sorted_data)):\\n # if less than q2, first half\\n if sorted_data[i] < q2:\\n first_half_data.append(sorted_data[i])\\n # if greather than q2, second half, skips q2\\n elif sorted_data[i] > q2:\\n second_half_data.append(sorted_data[i])\\n # use median method on halves to get quartiles\\n q1 = cls.get_median(first_half_data)\\n q3 = cls.get_median(second_half_data)\\n iqr = q3-q1\\n return q1, q2, q3, iqr\",\n \"def quartile(db: pd.DataFrame, col: str) -> pd.DataFrame:\\n _, bins = pd.qcut(x=db[col],\\n q=[0.25, 0.75], # [0.0, 0.25, 0.5, 0.75, 1.0],\\n retbins=True, duplicates='drop')\\n q1 = bins[0] # lower (first) quartile\\n q3 = bins[1] # upper (third) quartile\\n iqr = q3 - q1 # InterQuartile Range\\n lower_fence = (q1 - 1.5 * iqr)\\n upper_fence = (q3 + 1.5 * iqr)\\n db.loc[db[col] < lower_fence, col] = q1\\n db.loc[db[col] > upper_fence, col] = q3\\n return db\",\n \"def performance_quantiles(data, performance_measure):\\n quantiles = pd.qcut(x=data[performance_measure], q=4, labels=['q1', 'q2', 'q3', 'q4'])\\n bins = quantiles.to_frame(name=performance_measure + '_quantiles')\\n data_quantiles = pd.merge(data, bins, right_index=True, left_index=True)\\n data_quantiles.dropna(inplace=True)\\n data_quantiles.sort_values(performance_measure + '_quantiles', inplace=True)\\n return data_quantiles\",\n \"def get_quartile_data(cls, data: tuple or list) -> tuple:\\n cls._data_validation(data)\\n from math import floor\\n # Sort the data\\n n = cls.get_n(data)\\n if n == 0:\\n # Empty dataset, returns zeroes\\n return 0, 0, 0, 0\\n sorted_data = sorted(list(data))\\n n_is_odd = True if n % 2 == 1 else False\\n\\n # Get middle index\\n odd_middle_index = floor(n / 2)\\n even_upper_index = floor(n / 2)\\n even_lower_index = floor(n / 2) - 1\\n\\n # Get q2, which is the median\\n q2 = cls.get_median(data)\\n first_half_data = list()\\n second_half_data = list()\\n\\n # add to first half until median, then add to second half\\n if n_is_odd:\\n for i in range(n):\\n if i < odd_middle_index:\\n first_half_data.append(sorted_data[i])\\n # note how if index = middle_index, skips\\n elif i > odd_middle_index:\\n second_half_data.append(sorted_data[i])\\n else:\\n for i in range(n):\\n if i <= even_lower_index:\\n first_half_data.append(sorted_data[i])\\n # note how if index = middle_index, skips\\n else:\\n second_half_data.append(sorted_data[i])\\n # use median method on halves to get quartiles\\n q1 = cls.get_median(first_half_data)\\n q3 = cls.get_median(second_half_data)\\n iqr = q3 - q1\\n return q1, q2, q3, iqr\",\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 interquartile_range(magnitudes):\\n num_obs = magnitudes.shape[0]\\n per_25 = int(num_obs / 4.0)\\n\\n q1 = magnitudes[per_25]\\n q3 = magnitudes[num_obs - per_25]\\n\\n return (q3 - q1)[0]\",\n \"def test_profiled_quantiles(self):\\n\\n # this data has 4 bins, range of 3\\n # with equal bin size, each bin has the width of 0.75\\n\\n data = [\\\"1.0\\\", \\\"2.0\\\", \\\"3.0\\\", \\\"4.0\\\"]\\n df = pd.Series(data)\\n profiler = FloatColumn(df.name)\\n profiler.update(df)\\n profile = profiler.profile\\n\\n est_quartiles = profile['quantiles']\\n est_Q1 = est_quartiles[249]\\n est_Q2 = est_quartiles[499]\\n est_Q3 = est_quartiles[749]\\n\\n data_to_num = [float(item) for item in data]\\n exact_Q1 = np.percentile(data_to_num, 25)\\n exact_Q2 = np.percentile(data_to_num, 50)\\n exact_Q3 = np.percentile(data_to_num, 75)\\n\\n self.assertEqual(est_Q1, exact_Q1)\\n self.assertEqual(est_Q2, exact_Q2)\\n self.assertEqual(est_Q3, exact_Q3)\",\n \"def quantileValues(data, device):\\n r = pd.DataFrame([])\\n if isinstance(data, pd.DataFrame) or isinstance(data, pd.Series):\\n minValue = data.min()\\n maxValue = data.max()\\n q1 = data.quantile(0.25)\\n # q2 = tmp['deltaSeconds'].quantile(0.5)\\n q3 = data.quantile(0.75)\\n QR = q3 - q1\\n upper = 1.5 * QR + q3\\n lower = q1 - 1.5 * QR\\n\\n elif isinstance(data, np.ndarray):\\n minValue = data.min()\\n maxValue = data.max()\\n q1 = np.percentile(data, 25)\\n # q2 = np.percentile(data, 50)\\n q3 = np.percentile(data, 75)\\n QR = q3 - q1\\n upper = 1.5 * QR + q3\\n lower = q1 - 1.5 * QR\\n r = (r.append(pd.DataFrame({'mac': device.mac, 'minValue': minValue,\\n 'maxValue': maxValue, 'lower': lower,\\n 'upper': upper, 'q1': q1, 'q3': q3},\\n index=[0]), ignore_index=True))\\n return r\",\n \"def _computeRangeFromData(data):\\n if data is None:\\n return None\\n\\n dataRange = min_max(data, min_positive=True, finite=True)\\n if dataRange.minimum is None: # Only non-finite data\\n return None\\n\\n if dataRange is not None:\\n min_positive = dataRange.min_positive\\n if min_positive is None:\\n min_positive = float('nan')\\n return dataRange.minimum, min_positive, dataRange.maximum\",\n \"def default_quantile():\\n return np.logspace(-5, 0, 100)\",\n \"def _quantile(data, quantile):\\r\\n index = quantile * (len(data) - 1)\\r\\n bottom_index = int(floor(index))\\r\\n top_index = int(ceil(index))\\r\\n\\r\\n difference = index - bottom_index\\r\\n output = (1 - difference) * \\\\\\r\\n data[bottom_index] + difference * data[top_index]\\r\\n\\r\\n return output\",\n \"def get_limit(series, k=3):\\n q1 = series.quantile(q=0.25)\\n q3 = series.quantile(q=0.75)\\n iqr = q3 - q1\\n upper = q3 + 3 * iqr\\n lower = q1 - 3 * iqr\\n return upper, lower\",\n \"def range(df):\\r\\n\\r\\n\\tdf_range_dict = dict()\\r\\n\\r\\n\\tfor i, col in enumerate(df.columns):\\r\\n\\t\\tdf_range_dict[col] = [df[col].max(), df[col].min(), df[col].max() - df[col].min()]\\r\\n\\r\\n\\tdf_range = pd.DataFrame(df_range_dict, index=['Max Value', 'Min Value', 'Range (Max - Min)'])\\r\\n\\tpd.set_option('precision', 2) # set output display precision in 2 decimal places\\r\\n\\r\\n\\treturn df_range\",\n \"def data_quartiles(self):\\n data = []\\n for graph in self._graphs.values():\\n data += graph.data.values()\\n data.sort()\\n datalen = len(data)\\n return(data[0], data[datalen/4], data[datalen/2],\\n data[3*datalen/4], data[-1])\",\n \"def quartiles(x, percentile):\\n length = len(x)\\n\\n if percentile == 25:\\n center = length // 4\\n elif percentile == 75:\\n center = length // 2 + length // 4\\n\\n x.sort()\\n\\n if length % 2 == 0:\\n return (x[center - 1] + x[center]) / 2\\n else:\\n return x[center]\",\n \"def find_outlier_range(dfs: pd.Series, iqr_factor=1.5, clip_low=None, clip_high=None):\\n quant1 = dfs.quantile(0.25)\\n quant3 = dfs.quantile(0.75)\\n IQR = quant3 - quant1\\n low = quant1 - iqr_factor * IQR\\n high = quant3 + iqr_factor * IQR\\n\\n if clip_low is not None:\\n low = max(clip_low, low)\\n if clip_high is not None:\\n high = min(clip_high, high)\\n return (low, high)\",\n \"def compute_quantile(risk, T_max: int, scenario_numbers, quantile):\\r\\n\\r\\n print(\\\"\\\\tComputing Quantile...\\\")\\r\\n # Init quantile\\r\\n q = np.zeros(T_max)\\r\\n for t in range(T_max):\\r\\n risk[t].sort()\\r\\n q[t] = risk[t][int(np.ceil(scenario_numbers[t] * quantile)) - 1]\\r\\n print(\\\"\\\\tDone\\\")\\r\\n\\r\\n return q\",\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 Quantile(data, q, precision=1.0):\\n N, bins = np.histogram(data, bins=precision*np.sqrt(len(data)))\\n norm_cumul = 1.0*N.cumsum() / len(data)\\n\\n for i in range(0, len(norm_cumul)):\\n if norm_cumul[i] > q:\\n return bins[i]\",\n \"def get_range(df, col):\\n return df[col].min(), df[col].max()\",\n \"def quantiles(x, qlist=[2.5, 25, 50, 75, 97.5]):\\n # Make a copy of trace\\n x = x.copy()\\n\\n # For multivariate node\\n if x.ndim > 1:\\n # Transpose first, then sort, then transpose back\\n sx = np.transpose(np.sort(np.transpose(x)))\\n else:\\n # Sort univariate node\\n sx = np.sort(x)\\n\\n try:\\n # Generate specified quantiles\\n quants = [sx[int(len(sx) * q / 100.0)] for q in qlist]\\n\\n return dict(zip(qlist, quants))\\n\\n except IndexError:\\n print(\\\"Too few elements for quantile calculation\\\")\",\n \"def _full_value_range(self):\\n min_value, max_value = self._raw_data.data_range\\n return max_value - min_value\",\n \"def min_max_outliers(res, min=None, max=None):\\n min_max_list = []\\n if isinstance(min, (int, float)):\\n data1 = res[res < min].reset_index()\\n data1['limit type'] = 'minimum'\\n data1['limit'] = min\\n min_max_list.append(data1)\\n if isinstance(max, (int, float)):\\n data1 = res[res > max].reset_index()\\n data1['limit type'] = 'maximum'\\n data1['limit'] = max\\n min_max_list.append(data1)\\n\\n min_max1 = pd.concat(min_max_list)\\n\\n return min_max1\",\n \"def normalizeToRange(data,max=255,min=0):\\n if min: return (max-min)*normalize(data)+min\\n else: return max*normalize2(data) # speeds up operation\",\n \"def findRanges(data_grouped):\\n ranges = []\\n for i in data_grouped.columns:\\n theRange = (data_grouped[i].min(), data_grouped[i].max())\\n ranges.append(theRange)\\n return ranges\",\n \"def interq_range(sig):\\n #ny.percentile(sig, 75) - ny.percentile(sig, 25)\\n return np.percentile(sig, 75) - np.percentile(sig, 25)\",\n \"def band_quantiles(self, band):\\n min_pdf = self.pvalues[self.alpha.index(band[0])]\\n try:\\n max_pdf = self.pvalues[self.alpha.index(band[1])]\\n except IndexError:\\n max_pdf = 1E6\\n self.band = [min_pdf, max_pdf]\\n\\n pool = Pool()\\n band_quantiles = pool.map(self._min_max_band, range(self.dim))\\n pool.terminate()\\n pool.close()\\n\\n band_quantiles = list(zip(*band_quantiles))\\n\\n return band_quantiles\",\n \"def get_density_range(tds, min_range, buffer=100):\\n buffered_range = min_range\\n for alane in tds['lanes']:\\n for atile in tds[alane]:\\n dk = atile['density_k']\\n\\n # See if dk is going to fit on a plot bounded by current min_range.\\n # The idea is that if res is 1000 and dk is 1020 we extend res to 1200\\n # because we round up to the nearest 100 then add 100\\n buffered_range = max(buffered_range, (ceil(dk/buffer) * buffer) + buffer)\\n\\n return float(buffered_range)\",\n \"def calc_stats(data):\\n x = np.asarray(data, np.float)\\n vals_min = np.min(x)\\n vals_max = np.max(x)\\n q2 = np.percentile(x, 50, interpolation='linear')\\n q1 = np.percentile(x, 25, interpolation='lower')\\n q3 = np.percentile(x, 75, interpolation='higher')\\n iqr = q3 - q1\\n whisker_dist = 1.5 * iqr\\n\\n # in order to prevent drawing whiskers outside the interval\\n # of data one defines the whisker positions as:\\n d1 = np.min(x[x >= (q1 - whisker_dist)])\\n d2 = np.max(x[x <= (q3 + whisker_dist)])\\n return {\\n 'min': vals_min,\\n 'max': vals_max,\\n 'q1': q1,\\n 'q2': q2,\\n 'q3': q3,\\n 'd1': d1,\\n 'd2': d2\\n }\",\n \"def range_to_m(self, data):\\n return data * self._total_range + self._min_range_m\",\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 _get_quantiles(X, quantile_range):\\n quantiles = []\\n for feature_idx in range(X.shape[1]):\\n if sparse.issparse(X):\\n column_nnz_data = X.data[\\n X.indptr[feature_idx]: X.indptr[feature_idx + 1]]\\n column_data = np.zeros(shape=X.shape[0], dtype=X.dtype)\\n column_data[:len(column_nnz_data)] = column_nnz_data\\n else:\\n column_data = X[:, feature_idx]\\n quantiles.append(np.nanpercentile(column_data, quantile_range))\\n\\n quantiles = np.transpose(quantiles)\\n\\n return quantiles\",\n \"def heckbert_interval(data_low, data_high, numticks=8, nicefunc=_nice, enclose=False):\\n if data_high == data_low:\\n return data_high, data_low, 0\\n if numticks == 0:\\n numticks = 1\\n\\n range = nicefunc(data_high - data_low)\\n if numticks > 1:\\n numticks -= 1\\n d = nicefunc(range / numticks, round=True)\\n if enclose:\\n graphmin = ceil(data_low / d) * d\\n graphmax = floor(data_high / d) * d\\n else:\\n graphmin = floor(data_low / d) * d\\n graphmax = ceil(data_high / d) * d\\n return graphmin, graphmax, d\",\n \"def get_range(lst):\\n return float(max(lst)) - float(min(lst))\",\n \"def scale(value,rawmin=100941, rawmax=274919, rangemin=0, rangemax=100):\\n\\n # Convert the left range into a 0-1 range (float)\\n valueScaled = float(value - rawmin) / float(rawmax - rawmin)\\n\\n # Convert the 0-1 range into a value in the right range.\\n value = rangemin + (valueScaled * ((rangemax * 10) - rangemin))\\n\\n value = value // 10 * 10 // 10 # float to int\\n\\n return max(value, rangemin) # value must be greater or equal to rangemin\",\n \"def get_quantiles(self, q, interpolation=\\\"linear\\\", lb=None):\\n qarr = np.asarray(q, dtype=float)\\n if np.any(np.logical_and(qarr > 1, qarr < 0)):\\n raise ValueError(\\\"q values must fall within [0, 1].\\\")\\n else:\\n qtls, qtlhdrs = self._qtls_formatter(q=q)\\n qtl_pairs = [(qtlhdrs[ii], qtls[ii]) for ii in range(len(qtls))]\\n dqq = {\\n str(ii[0]): [\\n np.percentile(\\n self.reserve_dist[self.reserve_dist.origin == origin][\\\"reserve\\\"].values,\\n 100 * ii[-1], interpolation=interpolation\\n ) for origin in self.summary.index] for ii in qtl_pairs\\n }\\n dfqq = pd.DataFrame().from_dict(dqq).set_index(self.summary.index)\\n if lb is not None:\\n dfqq = dfqq.applymap(lambda v: lb if v < lb else v)\\n return(dfqq)\",\n \"def find_min_max(data):\\n v = [i[1] for i in data]\\n extremes = [min(v), max(v)]\\n logging.info('Calculated extremes: %s', extremes)\\n return extremes\",\n \"def range(series):\\n return min(series), max(series)\",\n \"def quantiles(self, q: int):\\n return self.dist.quantiles(q)\",\n \"def boxplot(values):\\n percentiles = percentile(values, [0, 25, 50, 75, 100])\\n result = {'min_val': percentiles[0],\\n 'q1_val': percentiles[1],\\n 'mean_val': percentiles[2],\\n 'q3_val': percentiles[3],\\n 'max_val': percentiles[4]}\\n return result\",\n \"def sortAndReturnQuantiles(values):\\n \\n values.sort()\\n N = len(values)\\n return (values[0], values[N/4], values[N/2], values[(3*N)/4], values[N-1])\",\n \"def make_quartiles(s, q1, q3):\\n return graph_objs.Scatter(\\n x=[s, s],\\n y=[q1, q3],\\n text=['lower-quartile: ' + '{:0.2f}'.format(q1),\\n 'upper-quartile: ' + '{:0.2f}'.format(q3)],\\n mode='lines',\\n line=graph_objs.Line(\\n width=4,\\n color='rgb(0,0,0)'\\n ),\\n hoverinfo='text'\\n )\",\n \"def calcrange(a4lim,data):\\r\\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\\r\\n return a4range\",\n \"def select_range_and_scale(data, color_min, color_max, fac=1.0):\\n scaled = ((data - color_min) * 1.0 / (color_max - color_min))\\n scaled[scaled < 0.0] = 0.0\\n scaled[scaled > 1.0] = 1.0\\n if fac != 0.0:\\n scaled = scaled * fac\\n return scaled\",\n \"def domain_range(domain, _range=[0, 1], return_transform=False):\\n\\n if not return_transform:\\n return interp1d([min(domain), max(domain)], [min(_range), max(_range)], bounds_error=False)\\n else:\\n m = interp1d([min(domain), max(domain)], [min(_range), max(_range)])\\n return [float(m(v)) for v in domain] # Take float, else returns weird numpy.ndarray element\",\n \"def normalize_range(array, floor=0, ceil=1):\\n scaler = MinMaxScaler(feature_range=(floor, ceil), copy=True)\\n return scaler.fit_transform(array)\",\n \"def _get_min_max_value(min, max, value=None, step=None):\\n # Either min and max need to be given, or value needs to be given\\n if value is None:\\n if min is None or max is None:\\n raise ValueError('unable to infer range, value from: ({0}, {1}, {2})'.format(min, max, value))\\n diff = max - min\\n value = min + (diff / 2)\\n # Ensure that value has the same type as diff\\n if not isinstance(value, type(diff)):\\n value = min + (diff // 2)\\n else: # value is not None\\n if not isinstance(value, Real):\\n raise TypeError('expected a real number, got: %r' % value)\\n # Infer min/max from value\\n if value == 0:\\n # This gives (0, 1) of the correct type\\n vrange = (value, value + 1)\\n elif value > 0:\\n vrange = (-value, 3*value)\\n else:\\n vrange = (3*value, -value)\\n if min is None:\\n min = vrange[0]\\n if max is None:\\n max = vrange[1]\\n if step is not None:\\n # ensure value is on a step\\n tick = int((value - min) / step)\\n value = min + tick * step\\n if not min <= value <= max:\\n raise ValueError('value must be between min and max (min={0}, value={1}, max={2})'.format(min, value, max))\\n return min, max, value\",\n \"def quantiles(x, num_buckets, epsilon, name=None):\\n\\n with tf.name_scope(name, 'quantiles'):\\n spec = _QuantilesSpec(epsilon, num_buckets)\\n quantile_boundaries = Analyzer(\\n [x], [(spec.bucket_dtype, [1, None], False)], spec,\\n 'quantiles').outputs[0]\\n\\n # quantile boundaries is of the form\\n # [nd.arrary(first, <num_buckets-1>, last)]\\n # Drop the fist and last quantile boundaries, so that we end-up with\\n # num_buckets-1 boundaries, and hence num_buckets buckets.\\n return quantile_boundaries[0:1, 1:-1]\",\n \"def get_dec_i_range(data_decs):\\n data_dec_is = map_list(lambda x: (x - 1800)//10, data_decs)\\n lower_range_i = data_dec_is[0]\\n upper_range_i = data_dec_is[-1] + 1\\n return (lower_range_i, upper_range_i)\",\n \"def __q_gxg__(series, q, tmin=None, tmax=None, by_year=True):\\n if tmin is not None:\\n series = series.loc[tmin:]\\n if tmax is not None:\\n series = series.loc[:tmax]\\n series = series.resample('d').median()\\n if by_year:\\n return (series\\n .resample('a')\\n .apply(lambda s: s.quantile(q))\\n .mean()\\n )\\n else:\\n return series.quantile(q)\",\n \"def quantile(data, quantiles):\\r\\n\\r\\n assert isinstance(data, list) or isinstance(data, ndarray), \\\"Data must be either\\\" +\\\\\\r\\n \\\" a Python list or a NumPy 1-D array\\\"\\r\\n assert isinstance(quantiles, list) or isinstance(quantiles, ndarray), \\\"Quantiles\\\" +\\\\\\r\\n \\\" must be either a Python list or a NumPy 1-D array\\\"\\r\\n assert all(map(lambda x: x >= 0 and x <= 1, quantiles)), \\\"All the elements \\\" +\\\\\\r\\n \\\"in the quantiles list must be greater than 0 and lower than one\\\"\\r\\n\\r\\n # unless the user wanted, do not modify the data\\r\\n data = deepcopy(data)\\r\\n\\r\\n if not isinstance(data, ndarray):\\r\\n data = array(data)\\r\\n data.sort()\\r\\n\\r\\n output = []\\r\\n # if needed different quantile methods could be used\\r\\n for one_quantile in quantiles:\\r\\n output.append(_quantile(data, one_quantile))\\r\\n\\r\\n return output\",\n \"def get_dyn_range(scale, zero_point, dtype):\\n if dtype == torch.quint8:\\n min_val, max_val = 0, 255\\n elif dtype == torch.qint8:\\n min_val, max_val = -128, 127\\n else:\\n raise RuntimeError(f\\\"Unsupported quantized dtype {dtype}\\\")\\n\\n return (min_val - zero_point) * scale, (max_val - zero_point) * scale\",\n \"def range_(headers, data):\\n\\tcolumn_matrix=data.get_data(headers).getT() # get columns as rows, as this makes analysis much easier by just perfoming operations on column list directly\\n\\tif column_matrix==[]:\\n\\t\\tprint \\\"wrong headers, not present in data Object\\\"\\n\\t\\treturn []\\n\\tcolumn_max=column_matrix.max(1)\\n\\tcolumn_min=column_matrix.min(1)\\n\\tfinal=np.concatenate((column_min, column_max), axis=1)\\n\\t\\n\\trng=final.tolist()\\n\\treturn rng\",\n \"def percentile_between(self,\\n min_percentile,\\n max_percentile,\\n mask=NotSpecified):\\n return PercentileFilter(\\n self,\\n min_percentile=min_percentile,\\n max_percentile=max_percentile,\\n mask=mask,\\n )\",\n \"def normalise_min_max(df):\\n return (df - df.min()) / (df.max() - df.min())\",\n \"def normalise_min_max(df):\\n return (df - df.min()) / (df.max() - df.min())\",\n \"def _bound(x, min_value, max_value):\\n return np.maximum(min_value, np.minimum(x, max_value))\",\n \"def quantile(feature, bins):\\n t = feature.sort_values().values\\n w = round(len(t)/bins)\\n return [t[w*i-1] for i in range(1, bins)]\",\n \"def percentile_normalization(data: np.ndarray, percentile: int = 1) -> np.ndarray:\\n\\n min_percentile = np.percentile(data, percentile)\\n max_percentile = np.percentile(data, 100 - percentile)\\n\\n # limit maximum intensity of data by max_percentile\\n data[data >= max_percentile] = max_percentile\\n\\n # limit minimum intensity of data by min_percentile\\n data[data <= min_percentile] = min_percentile\\n\\n return data\",\n \"def test__quantile(self):\\r\\n # regular cases\\r\\n sample_data = array(range(25, 42))\\r\\n assert_almost_equal(_quantile(sample_data, 0.5), median(sample_data))\\r\\n\\r\\n # sorted data is assumed for this function\\r\\n sample_data = sorted(\\r\\n array([0.17483293, 0.99891939, 0.81377467, 0.8137437,\\r\\n 0.51990174, 0.35521497, 0.98751461]))\\r\\n assert_almost_equal(_quantile(sample_data, 0.10), 0.283062154)\",\n \"def get_quantiles(data, quantiles):\\n variables = list(data.data_vars)\\n proxy_quant_df = pd.DataFrame(columns=[str(i) for i in quantiles], index=variables)\\n for var in variables:\\n for q in quantiles:\\n proxy_quant_df.loc[var, str(q)] = data[var].quantile(q).values\\n\\n return proxy_quant_df\",\n \"def variable_range(examples, var):\\n if var[1] == 'd':\\n range = set()\\n for datum in examples:\\n range.add(datum[var[0]])\\n return range\\n else:\\n range_min, range_max = 0, 0\\n for datum in examples:\\n data_val = float(datum[var[0]])\\n range_min, range_max = min(range_min, data_val), max(range_max, data_val)\\n return (range_min, range_max)\",\n \"def minmax_scale(X, feature_range=..., *, axis=..., copy=...):\\n ...\",\n \"def ex_range(data):\\n a, b, step = _cleanse_range_args(data)\\n return list(range(a, b+sign(step), step))\",\n \"def quantiles(self):\\n return self._quantiles\",\n \"def from_range(data, max_samples, start, end, lowpass):\\n\\n # handle the case of no data\\n if data.shape[0] == 0:\\n return data\\n\\n if start is None:\\n start = 0\\n else:\\n try:\\n start = data.index.get_loc(start, method=\\\"nearest\\\")\\n except InvalidIndexError:\\n # handle non-ordered/non-unique index\\n start = np.argmin(np.abs(data.index - start))\\n\\n if end is None:\\n end = data.shape[0]\\n else:\\n try:\\n end = data.index.get_loc(end, method=\\\"nearest\\\") + 1\\n except InvalidIndexError:\\n # handle non-ordered/non-unique index\\n end = np.argmin(np.abs(data.index - end)) + 1\\n\\n step = int(np.ceil((end - start) / max_samples))\\n\\n # TODO: handle NaNs at start/end\\n if step == 0:\\n # hacky solution for range reset\\n data_new = pd.concat((data.iloc[:1], data.iloc[-1:]))\\n else:\\n data_new = data.iloc[start:end]\\n if step > 1 and lowpass:\\n # TODO make this work\\n from scipy.signal import butter, filtfilt\\n\\n for c in data_new.columns:\\n if c != \\\"selected\\\":\\n coefs = butter(3, 1 / step)\\n data_new[c] = filtfilt(\\n coefs[0], coefs[1], data_new.loc[:, c]\\n )\\n data_new = data_new.iloc[::step]\\n # hacky solution for range reset\\n if start > 0:\\n data_new = pd.concat((data.iloc[:1], data_new))\\n if end < data.shape[0] - 1:\\n data_new = data_new.append(data.iloc[-1])\\n\\n return data_new\",\n \"def __q_gxg__(series, q, tmin=None, tmax=None, by_year=True):\\n if tmin is not None:\\n series = series.loc[tmin:]\\n if tmax is not None:\\n series = series.loc[:tmax]\\n series = series.resample('d').median()\\n if by_year:\\n return (series\\n .resample('a')\\n .apply(lambda s: s.quantile(q))\\n .mean()\\n )\\n else:\\n return series.quantile(q)\\n\\n # noinspection PyIncorrectDocstring,PyIncorrectDocstring\",\n \"def tau_percentile(x, tau, a=0.997):\\n y = np.cumsum(tau)\\n y = y/y.max()\\n\\n a_low = (1 - a) / 2\\n a_high = (1 + a) / 2\\n\\n x_range = list()\\n for p in [a_low, a_high]:\\n i1 = max((y < p).nonzero()[0])\\n i2 = i1 + 1\\n slope = (y[i2] - y[i1]) / (x[i2] - x[i1])\\n x_int = x[i2] + (p - y[i2])/slope\\n x_range.append(x_int)\\n\\n return x_range\",\n \"def test_returns_custom_range(self):\\n img = np.arange(5)\\n\\n actual = util.apply_gamma(img, out_min=0, out_max=255, gamma=1)\\n self.assertEqual(actual.min(), 0)\\n self.assertEqual(actual.max(), 255)\",\n \"def split_data(data, nq, flag=1):\\n if flag == 1:\\n quantiles = np.linspace(data.min(), data.max(), nq + 1)\\n elif flag == 2:\\n segs = np.linspace(0, 100, nq + 1)\\n quantiles = np.percentile(data, segs)\\n quantiles[0] = quantiles[0] - 1e-15\\n quantiles[-1] = quantiles[-1] + 1e-15\\n grp_names = np.digitize(data, quantiles) - 1\\n return grp_names\",\n \"def test_get_quartile_data(self):\\n LOWER = 0\\n MID = 1\\n UPPER = 2\\n number_of_simulations = 100\\n expected_lower = 25\\n expected_middle = 50\\n expected_upper = 75\\n quartile_tuple = investment_growth.get_quartile_data(number_of_simulations)\\n self.assertEqual(expected_lower, quartile_tuple[LOWER])\\n self.assertEqual(expected_middle, quartile_tuple[MID])\\n self.assertEqual(expected_upper, quartile_tuple[UPPER])\",\n \"def get_stats(dataframe, variable):\\n\\n print(\\\"Maximum value of \\\", variable, \\\"is: \\\", dataframe[variable].max(), \\\" in the row \\\", dataframe[dataframe[variable] == dataframe[variable].max()])\\n print(\\\"Minimum value of \\\", variable, \\\"is: \\\", dataframe[variable].min())\\n print(\\\"Mean of \\\", variable, \\\" is: \\\", dataframe[variable].mean())\\n print(\\\"Standard deviation of \\\", variable, \\\" is: \\\", dataframe[variable].std())\\n print(\\\"Mode of \\\", variable, \\\" is: \\\", dataframe[variable].mode())\\n print(\\\"Median of \\\", variable, \\\" is: \\\", dataframe[variable].median())\\n\\n # For speed: disregard points that are lower than 2.5 (to avoid stationary periods) as part of the interquartile range and greater than 100, which is only a few points anyway.\\n dataframeselection = dataframe.loc[(dataframe[variable] >= 2.5) & (dataframe[variable] < 100)]\\n q1 = dataframeselection[variable].quantile(0.25)\\n q3 = dataframeselection[variable].quantile(0.75)\\n iqr = q3 - q1\\n print(\\\"Upper quartile of \\\", variable, \\\" is: \\\", q3)\\n print(\\\"Lower quartile of \\\", variable, \\\" is: \\\", q1)\\n print(\\\"Interquartile range of \\\", variable, \\\" is: \\\", iqr)\\n lower_limit = q1-1.5*iqr\\n upper_limit = q3+1.5*iqr\\n print(\\\"Lower limit for outliers from IQR for \\\", variable, \\\" is: \\\", lower_limit)\\n print(\\\"Upper limit for outliers from IQR for \\\", variable, \\\" is: \\\", upper_limit)\\n points_above_upper_limit = len(dataframe.loc[(dataframe[variable] > (q3+1.5*iqr)) & (dataframe[variable] < 100)])\\n number_of_points = len(dataframe)\\n print(\\\"Total number of data points\\\", number_of_points)\\n print(\\\"There are \\\", points_above_upper_limit, \\\" points that lie above the upper bound, which corresponds to \\\", (points_above_upper_limit/number_of_points)*100, \\\" %\\\")\\n\\n return upper_limit\",\n \"def quantile(x,p):\\n p_index = int(p*len(x))\\n return sorted(x)[p_index]\",\n \"def find_outliers(data, method='iqr'):\\n\\n if method=='iqr':\\n # Finding the interquartile range\\n q1 = data.quantile(.25)\\n q3 = data.quantile(.75)\\n iqr = q3-q1\\n\\n upper = q3 + iqr*1.5\\n lower = q1 - iqr*1.5\\n elif method=='std':\\n std = data.std()\\n lower = data.mean() - 3*std\\n upper = data.mean() + 3*std\\n else:\\n raise ValueError(\\\"Invalid value for 'method' passed\\\")\\n\\n\\n return lower, upper\",\n \"def IQR(x):\\r\\n\\r\\n x.sort()\\r\\n # split values into lower and upper portions at the median\\r\\n odd = len(x) % 2\\r\\n midpoint = int(len(x) / 2)\\r\\n if odd:\\r\\n low_vals = x[:midpoint]\\r\\n high_vals = x[midpoint + 1:]\\r\\n else: # if even\\r\\n low_vals = x[:midpoint]\\r\\n high_vals = x[midpoint:]\\r\\n # find the median of the low and high values\\r\\n min_val = median(low_vals)\\r\\n max_val = median(high_vals)\\r\\n return min_val, max_val\",\n \"def GetRange(vDataSet,channel=None):\\r\\n nc = vDataSet.GetSizeC()\\r\\n maset = 0\\r\\n if channel is None:\\r\\n channels = range(nc)\\r\\n else:\\r\\n channels = [channel]\\r\\n\\r\\n for i in channels:\\r\\n ma = vDataSet.GetChannelRangeMax(i)\\r\\n if ma > maset:\\r\\n maset = ma\\r\\n\\r\\n maset = np.power(2,np.ceil(np.log2(maset)))-1\\r\\n return 0,maset\",\n \"def _quantiles(self):\\n\\n trials = []\\n for trial, state in self._trial_state.items():\\n if state.last_score is not None and not trial.is_finished():\\n trials.append(trial)\\n trials.sort(key=lambda t: self._trial_state[t].last_score)\\n\\n if len(trials) <= 1:\\n return [], []\\n else:\\n num_trials_in_quantile = int(\\n math.ceil(len(trials) * self._quantile_fraction))\\n if num_trials_in_quantile > len(trials) / 2:\\n num_trials_in_quantile = int(math.floor(len(trials) / 2))\\n return (trials[:num_trials_in_quantile],\\n trials[-num_trials_in_quantile:])\",\n \"def drop_outliers_quantile(df, upper=0.99, lower=0):\\n n_initial_rows = df.shape[0]\\n drop_list = set()\\n quant_upper = df.quantile(upper)\\n quant_lower = df.quantile(lower)\\n\\n print('-' * 25)\\n print('OUTLIERS DELETION: QUANTILE METHOD\\\\n')\\n\\n for el in df.columns.values:\\n drop_list = drop_list | \\\\\\n set(df[el][df[el] > quant_upper[el]].index.values) | \\\\\\n set(df[el][df[el] < quant_lower[el]].index.values)\\n\\n drop_list = list(set(drop_list))\\n count = len(drop_list)\\n df.drop(drop_list, inplace=True)\\n\\n print('Lower quantile: {} | Upper quantile: {}'.format(lower, upper))\\n print('N of deleted rows: {} | % of deleted rows: {}%'.format(\\n count, round(100 * (count / n_initial_rows), 3)))\\n return df\",\n \"def _parse_vrange(self, data):\\n vmin = self.config.get('vmin', np.nanmin(data))\\n vmax = self.config.get('vmax', np.nanmax(data))\\n vrange = self.config.get('vrange', None)\\n\\n # Parse vmin, vmax\\n if isinstance(vmin, str):\\n vmin = np.nanquantile(data, q=float(vmin))\\n if isinstance(vmax, str):\\n vmax = np.nanquantile(data, q=float(vmax))\\n\\n # Parse vrange\\n if vrange is True:\\n vrange = max(abs(np.nanmin(data)), abs(np.nanmax(data)))\\n elif isinstance(vrange, str):\\n vrange = abs(np.nanquantile(data, q=(float(vrange), 1-float(vrange)))).max()\\n\\n if vrange is not None:\\n if isinstance(vrange, (list, tuple, np.ndarray)):\\n vmin, vmax = vrange\\n else:\\n vmin, vmax = -vrange, vrange\\n return vmin, vmax\",\n \"def get_range(min, max, intervals, log):\\n if not log:\\n min = float(min)\\n max = float(max)\\n difference = max-min\\n step_size = difference/intervals\\n output = [min + i*step_size for i in range(intervals+1)]\\n return output\\n else:\\n from math import log10 as log\\n log_min = log(min)\\n log_max = log(max)\\n log_difference = log_max - log_min\\n step_size = log_difference/intervals\\n output = [pow(10, log_min + i*step_size) for i in range(intervals+1)]\\n return output\",\n \"def get_bucket_boundaries(feature):\\n return np.unique(np.percentile(feature, range(0, 100))).tolist()\",\n \"def IQR(data):\\n return percentile(data, 75) - percentile(data, 25)\",\n \"def GetScalarRange(self):\\n ...\",\n \"def in_range(data, minval=-np.inf, maxval=np.inf):\\n return (minval <= data) & (data <= maxval)\",\n \"def midrange(lo, hi, mid=0, scale=1.0):\\n return [min(mid, (mid + lo) / (1.0 + scale)),\\n max(mid, (mid + hi) / (1.0 + scale))]\",\n \"def prctile(data, p_vals=[0, 25, 50, 75, 100], sorted_=False):\\r\\n ps = [p_vals] if np.isscalar(p_vals) else p_vals\\r\\n\\r\\n if not sorted_:\\r\\n data = sorted(data)\\r\\n n = len(data)\\r\\n d = []\\r\\n for p in ps:\\r\\n fi = p * n / 100 - 0.5\\r\\n if fi <= 0: # maybe extrapolate?\\r\\n d.append(data[0])\\r\\n elif fi >= n - 1:\\r\\n d.append(data[-1])\\r\\n else:\\r\\n i = int(fi)\\r\\n d.append((i+1 - fi) * data[i] + (fi - i) * data[i+1])\\r\\n return d[0] if np.isscalar(p_vals) else d\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def quantile(x, p):\\n p_index = int(p * len(x))\\n return sorted(x)[p_index]\",\n \"def get_minmax_stats(dataframe, variable):\\n\\n print(\\\"Maximum value of \\\", variable, \\\"is: \\\", dataframe[variable].max())\\n print(\\\"Minimum value of \\\", variable, \\\"is: \\\", dataframe[variable].min())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7523062","0.71719885","0.7050786","0.69144285","0.6811111","0.67421144","0.6629707","0.66259694","0.65270203","0.6509629","0.65053487","0.64967763","0.64555305","0.6433195","0.6423888","0.63779706","0.6359893","0.63541","0.6300196","0.62596935","0.6217419","0.6204851","0.6163549","0.6150769","0.6142867","0.6139212","0.61339134","0.6114709","0.6104786","0.6096357","0.6093949","0.6092661","0.6089155","0.6053451","0.60490113","0.6048328","0.6039404","0.6008291","0.59855825","0.5979645","0.5966402","0.5956207","0.593267","0.59232646","0.59180474","0.58900434","0.58673054","0.58601665","0.5851384","0.5847994","0.58470064","0.58354557","0.58353645","0.5810559","0.5800765","0.578386","0.57498837","0.5747354","0.572711","0.5726981","0.5724414","0.5709477","0.5700967","0.56967115","0.5690586","0.5690586","0.5689972","0.56807464","0.5677404","0.56717587","0.5650724","0.5647534","0.56466573","0.56372714","0.56351906","0.56346446","0.56330895","0.5622172","0.56154054","0.56135345","0.56063545","0.55924195","0.55901927","0.55858827","0.5585793","0.5579497","0.5571483","0.55684036","0.55594957","0.55575675","0.55536413","0.5546163","0.5546143","0.55438584","0.5541197","0.55373347","0.552888","0.552888","0.552888","0.5523592"],"string":"[\n \"0.7523062\",\n \"0.71719885\",\n \"0.7050786\",\n \"0.69144285\",\n \"0.6811111\",\n \"0.67421144\",\n \"0.6629707\",\n \"0.66259694\",\n \"0.65270203\",\n \"0.6509629\",\n \"0.65053487\",\n \"0.64967763\",\n \"0.64555305\",\n \"0.6433195\",\n \"0.6423888\",\n \"0.63779706\",\n \"0.6359893\",\n \"0.63541\",\n \"0.6300196\",\n \"0.62596935\",\n \"0.6217419\",\n \"0.6204851\",\n \"0.6163549\",\n \"0.6150769\",\n \"0.6142867\",\n \"0.6139212\",\n \"0.61339134\",\n \"0.6114709\",\n \"0.6104786\",\n \"0.6096357\",\n \"0.6093949\",\n \"0.6092661\",\n \"0.6089155\",\n \"0.6053451\",\n \"0.60490113\",\n \"0.6048328\",\n \"0.6039404\",\n \"0.6008291\",\n \"0.59855825\",\n \"0.5979645\",\n \"0.5966402\",\n \"0.5956207\",\n \"0.593267\",\n \"0.59232646\",\n \"0.59180474\",\n \"0.58900434\",\n \"0.58673054\",\n \"0.58601665\",\n \"0.5851384\",\n \"0.5847994\",\n \"0.58470064\",\n \"0.58354557\",\n \"0.58353645\",\n \"0.5810559\",\n \"0.5800765\",\n \"0.578386\",\n \"0.57498837\",\n \"0.5747354\",\n \"0.572711\",\n \"0.5726981\",\n \"0.5724414\",\n \"0.5709477\",\n \"0.5700967\",\n \"0.56967115\",\n \"0.5690586\",\n \"0.5690586\",\n \"0.5689972\",\n \"0.56807464\",\n \"0.5677404\",\n \"0.56717587\",\n \"0.5650724\",\n \"0.5647534\",\n \"0.56466573\",\n \"0.56372714\",\n \"0.56351906\",\n \"0.56346446\",\n \"0.56330895\",\n \"0.5622172\",\n \"0.56154054\",\n \"0.56135345\",\n \"0.56063545\",\n \"0.55924195\",\n \"0.55901927\",\n \"0.55858827\",\n \"0.5585793\",\n \"0.5579497\",\n \"0.5571483\",\n \"0.55684036\",\n \"0.55594957\",\n \"0.55575675\",\n \"0.55536413\",\n \"0.5546163\",\n \"0.5546143\",\n \"0.55438584\",\n \"0.5541197\",\n \"0.55373347\",\n \"0.552888\",\n \"0.552888\",\n \"0.552888\",\n \"0.5523592\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67295194"},"document_rank":{"kind":"string","value":"6"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":784,"numItemsPerPage":100,"numTotalItems":95772,"offset":78400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMyNzEwNywianRpIjoiNzFiY2RkYjUtZTllOC00ODI4LWFjZWYtMzdkNGQ3OTMwYjJmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMzA3MDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.4qp2cmOxNWiJA9uwyEzfjp5OBy7Q4-Ep7ZzbEH0doqVKZRIU_A8IV2gySAjkxKtpg8qt50i2_71B3ivfUBfuBQ","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 |
|---|---|---|---|---|---|---|
The units used for variables within. This should be overridden in children. | def get_units(self,):
self.UNITS = {'pressure':'Pa',}
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def units(self):\n pass",
"def unit_of_measurement(self):\n return self.var_units",
"def units(self):\n return self._units",
"def units(self):\n return self._units",
"def unit_of_measurement(self):\n return self._var_unit",
"def unit_of_measurement(self):\n retur... | [
"0.8475738",
"0.82523423",
"0.7962671",
"0.7962671",
"0.78302574",
"0.78302574",
"0.7656947",
"0.7647602",
"0.763098",
"0.75417906",
"0.7417572",
"0.7415579",
"0.74116683",
"0.73817796",
"0.73459446",
"0.73356164",
"0.71914446",
"0.717996",
"0.7169595",
"0.71674466",
"0.71674... | 0.74156046 | 11 |
Return the index to load a requested level (in hPa). If level doesn't exist, throw an exception. | def idx_from_lv(self,vrblkey,lv=None):
rows = N.where(self.available_fields_array == vrblkey)[0]
# idxs = self.available_fields_array[rows,5]
if len(rows) == 1 and lv == None:
# return idxs[0]
return 0
lv_choice = self.available_fields_array[rows,5]
# pdb.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def level_to_index(level: int) -> int:\n\n level_data = {\n 15: 1,\n 25: 2,\n 30: 3,\n 35: 4,\n 40: 5,\n 45: 6,\n 50: 7,\n }\n return level_data[level]",
"def level_index(self, level):\n try:\n return list(self._levels).index(str(level))... | [
"0.68838525",
"0.63543373",
"0.6246571",
"0.61276937",
"0.6102357",
"0.60659957",
"0.60261744",
"0.5963071",
"0.5932447",
"0.5925082",
"0.58323705",
"0.5814966",
"0.5791093",
"0.57674646",
"0.57245857",
"0.5688138",
"0.5678364",
"0.5652685",
"0.56450814",
"0.5619901",
"0.5617... | 0.0 | -1 |
I don't think we need utc/lv aren't all grib files one time? but it is here to enable compatibility with other get() APIs. | def get(self,vrbl,idx=0,utc=None,level=None,lons=None,lats=None):
# TODO: look up level in available fields array, return index
vrblkey = self.lookup_vrbl(vrbl)
print("Variable {0} has key {1} in Grib data.".format(vrbl,vrblkey))
# gg = self.get_record(vrblkey,idx=idx)
# idx look... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svn_info_t_prop_time_get(svn_info_t_self): # real signature unknown; restored from __doc__\n pass",
"def get(self, filename, from_time, to_time):\n raise NotImplementedError()",
"def get():",
"def get():",
"def _get_time_info(self, keys: list[str]):\n if self.is_info_v2:\n i... | [
"0.552266",
"0.53847766",
"0.5327144",
"0.5327144",
"0.5288795",
"0.5284251",
"0.51308817",
"0.5111512",
"0.5103746",
"0.5102246",
"0.50884247",
"0.5059077",
"0.50417954",
"0.50307804",
"0.4973795",
"0.4973238",
"0.49729574",
"0.49729574",
"0.4964048",
"0.49491337",
"0.494704... | 0.55045795 | 1 |
Look for record entries based on a keyword. | def search_keyword(self,keyword):
for entry in self.available_fields_list:
for x in entry:
if keyword in x:
print(entry)
break
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def searchRecords(self, filterChoice, keyword):\r\n session = wx.GetApp().session\r\n model = getattr(db, self.modelName)\r\n\r\n result = None\r\n if filterChoice == \"Person\":\r\n qry = session.query(model)\r\n logging.debug(qry)\r\n result = qry.filt... | [
"0.6326545",
"0.6215973",
"0.6141149",
"0.60207176",
"0.59056956",
"0.58672076",
"0.58531576",
"0.58378905",
"0.58213276",
"0.5780427",
"0.57540876",
"0.57399154",
"0.571995",
"0.5706627",
"0.5669257",
"0.5653376",
"0.5625087",
"0.5598351",
"0.559667",
"0.55940646",
"0.556526... | 0.7411851 | 0 |
Perform the BLASTing of the proteins in an input file (inputFile) against those in another file (databaseFile). Returns a dictionary of the similarities between proteins, as determined by BLAST. The dictionary is indexed by a alphanumerically ordered tuple (index[0] < index[1]), and the entry for each index is a dictio... | def main(inputFile, databaseFile, blastOperationID, SEG=False, cores=2, minAlignLength=20, maxEValue=1.0, verboseOutput=False):
# Get the location of the BLAST executables.
srcLocation = os.path.abspath(__file__)
srcLocation = '\\'.join(srcLocation.split('\\')[:-1])
BLASTExecutables = srcLocation +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addBlastFilesToStream(fileMap,fragIndex,inputFragment):\n # TODO: return False if output files are missing completely\n\n # get list of reads from input fragment\n records={}\n fastaRecordRE=fileTypeMap['fasta'].sepRE\n with open(inputFragment,'rt') as f:\n for line in f:\n m=f... | [
"0.57911015",
"0.57641923",
"0.5724841",
"0.56280184",
"0.55734056",
"0.5516204",
"0.5510528",
"0.54538035",
"0.5439656",
"0.5411389",
"0.5381811",
"0.5352944",
"0.534707",
"0.534198",
"0.52927357",
"0.5241423",
"0.5195701",
"0.5192132",
"0.5173747",
"0.5169282",
"0.51647925"... | 0.5815675 | 0 |
Will perform the process of BLAST > PROCESS OUTPUT on inputFile. | def sequence_BLAST(processedBLAST, inputFile, database, BLASTLoc, SEG, cores):
# Setup the parameters for the BLASTing.
outputLoc = inputFile.split('.')[0] + '.tmp'
query = ' -query ' + inputFile
out = ' -out ' + outputLoc
evalue = ' -evalue 1'
inclusionEThresh = ' -inclusion_ethresh 0.000... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self,fileobj_out,fileobj_in):\n pass",
"def process_file(input_file = 'NC_012655.ffn',output_file = 'NC_012655.output'):\n #prepare\n f = open(input_file, 'r')\n o = open(output_file,'w')\n seq = ''\n header = f.readline()\n o.write('GeneID Length GC \\n')\n #work\... | [
"0.62266076",
"0.60749716",
"0.5962994",
"0.59588873",
"0.5911635",
"0.58566844",
"0.5830632",
"0.58203375",
"0.5813754",
"0.57374686",
"0.5724027",
"0.5714571",
"0.5711974",
"0.5665211",
"0.56526506",
"0.5626592",
"0.5592834",
"0.559092",
"0.55641717",
"0.5556468",
"0.554570... | 0.5891977 | 5 |
Runs the chosen algoirthm until one of the two break criteria are met. | def neighbour_search(
orders_dict: dict,
algorithm: str,
factories_dict: dict,
sku_dict: dict,
time_limit=600000,
iteration_limit=4,
):
algorithm = algorithm.lower()
if algorithm not in ["naive", "max", "min"]:
raise ValueError("Please only select one of naive, max or min as the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_74_break(self):\n\t\tinput = \"\"\"procedure main(); var x:integer;\n\t\tbegin while(true)do begin\n\t\twith x:integer; do with x:real; do begin\n\t\t\tif (x>0) then break;\n\t\t\twith x:integer; do if (x=0) then return;\n\t\tend{with} break; end{while} break; end\"\"\"\n\t\texpect = \"Break Not In Loop\"... | [
"0.6149245",
"0.6020976",
"0.59952736",
"0.5882346",
"0.57830894",
"0.5751992",
"0.5666575",
"0.5641377",
"0.5601723",
"0.5586441",
"0.5559049",
"0.554734",
"0.5497915",
"0.5416353",
"0.54055893",
"0.53711516",
"0.53647",
"0.5342509",
"0.5317392",
"0.53048575",
"0.5278566",
... | 0.0 | -1 |
Returns a path to a fixture via the given fname and label | def fixture(fname, label="reference"):
return os.path.join(FIXTURES, label, fname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fixture_file(*path):\n return os.path.join(os.path.dirname(__file__), 'fixtures', *path)",
"def get_test_fname(fname):\n path = get_test_path()\n full_path = os.path.join(path, fname)\n return full_path",
"def get_filename(label):\n return op.splitext(op.splitext(op.basename(label))[0])[0]",... | [
"0.6520794",
"0.6382769",
"0.63656783",
"0.6110005",
"0.5983235",
"0.5950241",
"0.5911903",
"0.59048057",
"0.59048057",
"0.59048057",
"0.5869462",
"0.5829332",
"0.5817864",
"0.58178484",
"0.58095974",
"0.5808435",
"0.57983226",
"0.57849145",
"0.5742818",
"0.5695899",
"0.56913... | 0.8895459 | 0 |
Reads a file in FASTA format, returning a tuple, (label, sequence). | def fasta(path):
label = None
sequence = None
with open(path, 'r') as data:
for line in data:
line = line.strip()
if line.startswith('>'):
if label and sequence:
yield (label, sequence)
label = line[1:]
se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_fasta(sequence_file :str):\n\n #for gziped files:\n\n if sequence_file.endswith(\".gz\"):\n with gzip.open(sequence_file, \"rt\") as file:\n seqDict = SeqIO.to_dict(SeqIO.parse(file, 'fasta'))\n ident = ident.split(\"|\")[1]\n return seqDict\n\n # for no gz... | [
"0.7599585",
"0.7488535",
"0.7305853",
"0.72761166",
"0.7245398",
"0.71999073",
"0.711566",
"0.70988804",
"0.69952655",
"0.6989163",
"0.69828224",
"0.691334",
"0.6869248",
"0.68569374",
"0.6752505",
"0.6749362",
"0.67348534",
"0.6690506",
"0.6614239",
"0.66042876",
"0.6526621... | 0.73308635 | 2 |
Wrapper function for timing function calls | def timeit(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
finit = time.time()
delta = finit-start
return result, delta
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timed(f):\n\n def wrapper(*args, **kwargs):\n start = time.time()\n ret = f(*args, **kwargs)\n end = time.time()\n\n return ret, (end - start)\n\n return wrapper",
"def time_it(func):\n\n def wrapper(*args, **kwargs):\n start = timer()\n func(*args, **kwargs... | [
"0.7829795",
"0.7792269",
"0.7790988",
"0.7769397",
"0.7762282",
"0.7744963",
"0.77080756",
"0.7681372",
"0.7661294",
"0.7654119",
"0.75102586",
"0.75028896",
"0.74699044",
"0.74616414",
"0.74550444",
"0.74546194",
"0.7453743",
"0.7424639",
"0.7387927",
"0.7381818",
"0.73659"... | 0.7135359 | 49 |
Returns the complement of the DNA sequence | def revc(sequence):
complements = {
'A': 'T',
'T': 'A',
'C': 'G',
'G': 'C',
'N': 'N',
'.': '.',
}
def inner(sequence):
for char in reversed(sequence):
yield complements[char]
sequence = sequence.upper()
return ''.join(inner(sequen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def complement(seq):\n if PY3:\n table = str.maketrans('ACTGNactg', 'TGACNtgac')\n elif PY2:\n table = string.maketrans('ACTGNactg', 'TGACNtgac')\n return str(seq).translate(table)",
"def get_reverse_complement(dna):\r\n\r\n seq = Seq(dna)\r\n rev_seq = seq.reverse_complement()\r\n ... | [
"0.7816923",
"0.7662132",
"0.7593875",
"0.7514506",
"0.74755436",
"0.73782635",
"0.7311068",
"0.73018074",
"0.7296013",
"0.7293187",
"0.72908664",
"0.7290187",
"0.7283251",
"0.7267131",
"0.7253721",
"0.7249284",
"0.72297704",
"0.7224757",
"0.7220809",
"0.7193174",
"0.7168171"... | 0.0 | -1 |
Creates a meta_data instance for the model at the time point (appointment) for the given registered_subject. might return None and meta data not created based on visit reason (e.g. missed). | def create_meta_data(self):
if self.visit_instance.reason not in self.skip_create_visit_reasons:
try:
entry = self.entry_model.objects.get(
app_label=self.model._meta.app_label.lower(),
model_name=self.model._meta.object_name.lower(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def informed_consent_on_post_save(sender, instance, raw, created, **kwargs):\n if not raw:\n if created:\n pass\n # instance.registration_update_or_create()\n # update_model_fields(instance=instance,\n # model_cls=['subject_identifier', inst... | [
"0.5472681",
"0.52024764",
"0.512791",
"0.48788267",
"0.48686114",
"0.48406184",
"0.47583947",
"0.4736606",
"0.47161746",
"0.47055674",
"0.46937343",
"0.46804252",
"0.46649593",
"0.46285155",
"0.4618309",
"0.45941997",
"0.4592607",
"0.45912987",
"0.45581073",
"0.45331988",
"0... | 0.772739 | 0 |
Retrieve an organization Return details on an individual organization including various details such as membership access, features, and teams. {method} {path} | def get(self, request, organization):
team_list = list(Team.objects.filter(
organization=organization,
status=TeamStatus.VISIBLE,
))
feature_list = []
if features.has('organizations:sso', organization, actor=request.user):
feature_list.append('sso')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_organization(organization):\n return fetch_json(organization_url, organization)",
"def test_get_organization(self):\n pass",
"def test_retrieve_l_organization(self):\n pass",
"def GetOrganization(**argd):\n flag, ret = CGateway.core.GetOrganizationName(argd[\"session\"])\n ... | [
"0.7148548",
"0.7105574",
"0.6952284",
"0.65545195",
"0.6552218",
"0.64303905",
"0.64210945",
"0.63243663",
"0.6256752",
"0.6247144",
"0.6243915",
"0.6230795",
"0.61991656",
"0.6193295",
"0.6187062",
"0.6177847",
"0.61678433",
"0.6031752",
"0.6031751",
"0.6006261",
"0.5959868... | 0.64187884 | 7 |
Update an organization Update various attributes and configurable settings for the given organization. {method} {path} {{ | def put(self, request, organization):
serializer = OrganizationSerializer(organization, data=request.DATA,
partial=True)
if serializer.is_valid():
organization = serializer.save()
self.create_audit_entry(
request=reques... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, request, pk=None):\n serializer = OrganizationUpdateBody(data=request.data)\n if serializer.is_valid(raise_exception=True):\n name = serializer.validated_data.get(\"name\")\n # agents = serializer.validated_data.get(\"agents\")\n # network = serialize... | [
"0.7464905",
"0.7344722",
"0.72334814",
"0.6991192",
"0.68280673",
"0.6780415",
"0.66433245",
"0.6163794",
"0.6163794",
"0.6163794",
"0.6006318",
"0.5986513",
"0.5846596",
"0.57903427",
"0.5783204",
"0.5736965",
"0.57127297",
"0.57026005",
"0.57019323",
"0.5627186",
"0.553396... | 0.7070443 | 3 |
Delete an organization Schedules an organization for deletion. {method} {path} | def delete(self, request, organization):
if organization.is_default:
return Response({'detail': ERR_DEFAULT_ORG}, status=400)
logging.getLogger('sentry.deletions').info(
'Organization %s (id=%s) removal requested by user (id=%s)',
organization.slug, organization.id, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_organization(self):\n pass",
"def delete(self, organization_id):\n if organization_id is not None:\n # fetch org to delete\n try:\n org = Organization.query.filter_by(id=organization_id).first()\n # return 404 if org does not exist... | [
"0.70051813",
"0.6944466",
"0.67821133",
"0.65625185",
"0.6549952",
"0.6258782",
"0.6244123",
"0.6154723",
"0.6129886",
"0.6023895",
"0.59733737",
"0.59061176",
"0.58606285",
"0.58501047",
"0.58364564",
"0.58216476",
"0.56640875",
"0.56540847",
"0.5620168",
"0.5593044",
"0.55... | 0.7104207 | 0 |
Start an application in a subprocess. | def __init__(self, *args, **kwargs):
mp.Process.__init__(self)
self._args = args
self._kwargs = kwargs
self._host_conn, self._proc_conn = mp.Pipe()
self.daemon = True
self.start()
reply = self._host_conn.recv()
if isinstance(reply, Exception):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Start(self):\n\n\n\n assert not self._process, 'Start() can only be called once'\n self._process = subprocess.Popen(self._args)",
"def start(self):\n self._proc = self._get_subprocess()\n self._pid = self._proc.pid\n self._return_code = None",
"def run_app(self):\n # Updat... | [
"0.7369324",
"0.7195297",
"0.70307446",
"0.7023959",
"0.69730425",
"0.6970679",
"0.683562",
"0.6766922",
"0.6708134",
"0.6668066",
"0.66187245",
"0.654548",
"0.6529274",
"0.64943254",
"0.64486915",
"0.640595",
"0.64022136",
"0.63618714",
"0.6325139",
"0.631463",
"0.62968546",... | 0.0 | -1 |
Redirect method calls to the subprocess. | def __getattr__(self, name):
def _send(*args, **kwargs):
self._host_conn.send((name, args, kwargs))
reply = self._host_conn.recv()
if isinstance(reply, Exception):
raise reply
return reply
return _send | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_subprocess(self, monkeypatch):\n monkeypatch.setattr('subprocess.check_call', self.fake_check_call)",
"def wrap_command(self, prog_name, command, preserve_files):\n raise NotImplementedError(\"Pure virtual method wrap_command() called\")",
"def _override_command_method(self, name):\n ... | [
"0.6421962",
"0.59309554",
"0.55841166",
"0.5566177",
"0.5490214",
"0.53713787",
"0.5369807",
"0.53612804",
"0.5358685",
"0.5349538",
"0.5338001",
"0.53358626",
"0.5319026",
"0.52982914",
"0.5297855",
"0.52841663",
"0.52483004",
"0.52227914",
"0.52191365",
"0.521012",
"0.5161... | 0.0 | -1 |
Run the application in a subprocess. | def run(self):
try:
# import here to prevent Panda3D from loading in the host process
from .viewer_app import ViewerApp
app = ViewerApp(*self._args, **self._kwargs)
self._proc_conn.send(None)
def _execute(task):
for _ in range(100):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_app(self):\n # Update system arguments\n sys.argv[0] = sys.executable\n sys.argv[1] = '{}.py'.format(sys.argv[1])\n\n # Make sure to exit with the return value from the subprocess call\n self._app_process = subprocess.Popen(sys.argv)\n return self._app_process.wait... | [
"0.7752048",
"0.7020225",
"0.6981871",
"0.6956881",
"0.6930996",
"0.69175863",
"0.689937",
"0.68447065",
"0.68109673",
"0.6805248",
"0.6789014",
"0.6736907",
"0.66935885",
"0.66848093",
"0.6647466",
"0.66381854",
"0.6635647",
"0.66031396",
"0.66024846",
"0.6504287",
"0.641390... | 0.60383326 | 77 |
Test wether or not `path` is absolute url. | def is_absolute_url(path):
return path.startswith("http") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_absolute_path(path: str) -> bool:\n # This is a rather weak test, may be enhanced if desired\n return \"//\" in path \\\n or \":\" in path \\\n or path.startswith(\"/\")",
"def isabs(path):\n # If detected as storage path, it is an absolute path.\n return True",
"def is_a... | [
"0.85445476",
"0.8208567",
"0.73892355",
"0.736103",
"0.72351986",
"0.68886465",
"0.6864662",
"0.6810893",
"0.67265016",
"0.6722769",
"0.6581062",
"0.6573491",
"0.65669185",
"0.6557852",
"0.6554364",
"0.65135294",
"0.6481539",
"0.64398235",
"0.64357907",
"0.64325374",
"0.6398... | 0.8398912 | 1 |
Return a path as an absolute url. | def get_absolute_url(path):
if is_absolute_url(path):
return path
site = settings.SITES['front']
return build_url(path, scheme=site['scheme'], domain=site['domain']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def full_url(self, path):\n if path[0] == '/':\n path = path[1:]\n return urljoin(self.absolute_root, path)",
"def build_absolute_url(self, path_or_url):\n return urllib.parse.urljoin(self.parsed_url.geturl(), path_or_url)",
"def create_absolute_url(path: str) -> str:\n domai... | [
"0.8106669",
"0.78375137",
"0.7732806",
"0.75587624",
"0.7432354",
"0.7375705",
"0.7318042",
"0.727619",
"0.72687167",
"0.7228609",
"0.71804714",
"0.7169504",
"0.7164312",
"0.7094387",
"0.7032917",
"0.6995915",
"0.69660145",
"0.68689567",
"0.68408626",
"0.6804187",
"0.6791408... | 0.78109497 | 2 |
Same behavior as django's reverse but uses django_sites to compute absolute url. | def reverse(viewname, *args, **kwargs):
return get_absolute_url(django_reverse(viewname, *args, **kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_absolute_url(self):\n\n url = reverse('comicsite.views.site', args=[self.short_name])\n return url",
"def reverse(*args, **kw):\n return make_absolute_url(django_reverse(*args, **kw))",
"def url_abs(name, *args):\n\tprotocol = settings.PROTOCOL\n\tdomain = settings.DOMAIN\n\turl = reve... | [
"0.7787592",
"0.7709379",
"0.76670426",
"0.73699325",
"0.73201346",
"0.73201346",
"0.69739074",
"0.69669706",
"0.69336665",
"0.69207036",
"0.69077927",
"0.6861142",
"0.6835743",
"0.67903143",
"0.6759977",
"0.6747809",
"0.6734185",
"0.67224824",
"0.67141503",
"0.67096394",
"0.... | 0.68545514 | 12 |
Hook if plugin wants to do something on initialization | def setup(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_initialize(self) -> None:\n pass",
"def on_startup(self) -> None:\n ...",
"def on_load(self):\n self.__init__()",
"def plugin_init():\n\n global _recreate_omf_objects\n\n _logger.debug(\"{0} - URL {1}\".format(\"plugin_init\", _config['URL']))\n\n try:\n\n _recreat... | [
"0.7507647",
"0.7504341",
"0.7496409",
"0.7494931",
"0.74793804",
"0.74655914",
"0.7393103",
"0.73722833",
"0.73722833",
"0.73722833",
"0.73722833",
"0.73652464",
"0.7331865",
"0.7323755",
"0.72868645",
"0.7274375",
"0.7180136",
"0.71684223",
"0.7052333",
"0.7052333",
"0.7042... | 0.0 | -1 |
Return dtype of computed data; used only if no dtype attribute defined | def infer_dtype(self):
# Don't raise NotImplementedError, IDE will complain you're not
# implementing all abstract methods...
raise RuntimeError("No infer dtype method defined") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dtype(a):\n return a.dtype",
"def dtype(self) -> np.dtype:\n ...",
"def dtype(self):\n return self.data.dtype",
"def infer_dtype(self):\n raise NotImplementedError",
"def dtype(self):\n return self._data.dtype",
"def dtype(self):\n return self._data.dtype",
"de... | [
"0.8160277",
"0.8091967",
"0.78537405",
"0.7848468",
"0.7772697",
"0.7772697",
"0.77548546",
"0.77424324",
"0.77381605",
"0.7717209",
"0.7709745",
"0.7655319",
"0.76532096",
"0.762091",
"0.7618867",
"0.7592245",
"0.7592245",
"0.7592245",
"0.7457054",
"0.743728",
"0.733613",
... | 0.72716284 | 21 |
Return version number applicable to the run_id. Most plugins just have a single version (in .__version__) but some may be at different versions for different runs (e.g. timedependent corrections). | def version(self, run_id=None):
return self.__version__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def version_id(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"version_id\")",
"def get_version(self):\r\n\r\n return self.versions[0].number",
"def plugin_version(self):\n return self.__plugin_version",
"def get_version(self):\n return self.cur_config['version'... | [
"0.6729067",
"0.6524676",
"0.64457977",
"0.64410496",
"0.6421774",
"0.638525",
"0.6285096",
"0.6263206",
"0.6241869",
"0.62201875",
"0.62045753",
"0.61937886",
"0.6150016",
"0.61450565",
"0.61103964",
"0.6099586",
"0.6094055",
"0.6089521",
"0.60501593",
"0.6048226",
"0.604449... | 0.8039038 | 1 |
Metadata to save along with produced data | def metadata(self, run_id, data_type):
if not data_type in self.provides:
raise RuntimeError(f"{data_type} not in {self.provides}?")
return dict(
run_id=run_id,
data_type=data_type,
data_kind=self.data_kind_for(data_type),
dtype=self.dtype_for(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, metadata):\n pass",
"def saveMetadata(self):\n pickle.dump(self.metadata, open(self.metadataFile, 'w+b'))",
"def save_meta(self):\n # jOut = os.path.join(self.meta[\"wdir\"], meta_file)\n with open(self.meta_filepath, \"w\") as f:\n json.dump(self.meta, f)"... | [
"0.77472275",
"0.77155846",
"0.7143829",
"0.71382594",
"0.7115775",
"0.7076076",
"0.7007138",
"0.6980497",
"0.6932532",
"0.69278365",
"0.6896692",
"0.68722975",
"0.68544436",
"0.68350136",
"0.67774874",
"0.67684793",
"0.6745481",
"0.67393374",
"0.66593844",
"0.6621759",
"0.65... | 0.0 | -1 |
Return whether the chunk chunk_i is ready for reading. Returns True by default; override if you make an online input plugin. | def is_ready(self, chunk_i):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isComplete(self):\n return self.bytesToRead == 0",
"def readable(self):\n self._check_not_closed()\n return False",
"def readable(self):\n return self.interface.in_waiting",
"def wantsReadEvent(self):\r\n if self.result != None:\r\n return self.result == 0\r\... | [
"0.69202155",
"0.66135347",
"0.64482975",
"0.6399048",
"0.6347218",
"0.63396084",
"0.6247333",
"0.6240271",
"0.6226292",
"0.6206879",
"0.61784005",
"0.61481017",
"0.6137742",
"0.6130014",
"0.6119764",
"0.6119764",
"0.6114823",
"0.61147493",
"0.61111355",
"0.61077726",
"0.6064... | 0.8069259 | 0 |
Return whether all chunks the plugin wants to read have been written. Only called for online input plugins. | def source_finished(self):
# Don't raise NotImplementedError, IDE complains
raise RuntimeError("source_finished called on a regular plugin") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_readings(self):\n # loading data from log file\n if self.filepath is not None:\n if self.all_read is None:\n return False\n else:\n ei = self.curr_indexi + self.read_step\n if ei >= self.all_read.shape[0]:\n ... | [
"0.6492002",
"0.6469171",
"0.63446265",
"0.6324339",
"0.6238816",
"0.6206547",
"0.6205954",
"0.6199328",
"0.61821496",
"0.61651605",
"0.6162274",
"0.6162274",
"0.61592495",
"0.6116448",
"0.60340613",
"0.6015801",
"0.5949607",
"0.59428126",
"0.5938531",
"0.59170115",
"0.587718... | 0.0 | -1 |
Iterate over dependencies and yield results | def iter(self, iters, executor=None):
deps_by_kind = self.dependencies_by_kind()
# Merge iterators of data that has the same kind
kind_iters = dict()
for kind, deps in deps_by_kind.items():
kind_iters[kind] = strax.merge_iters(
strax.sync_iters(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_dependencies(target, dep_context):\n for dep in target.closure(bfs=True, **dep_context.target_closure_kwargs):\n yield dep",
"def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:\n raise NotImplementedError()",
"def _jar_dependencies(self, dep):\r\n if isins... | [
"0.7130062",
"0.6738838",
"0.67295426",
"0.66484344",
"0.6448103",
"0.6326727",
"0.62433416",
"0.62354714",
"0.6179864",
"0.60664564",
"0.5945691",
"0.5933414",
"0.59150857",
"0.59114265",
"0.5876124",
"0.5872147",
"0.5864354",
"0.58548445",
"0.5850609",
"0.58492243",
"0.5845... | 0.5817837 | 22 |
Wrapper for the userdefined compute method This is the 'job' that gets executed in different processes/threads during multiprocessing | def do_compute(self, chunk_i=None, **kwargs):
if self.compute_takes_chunk_i:
result = self.compute(chunk_i=chunk_i, **kwargs)
else:
result = self.compute(**kwargs)
return self._fix_output(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute(self, *args):\n\n pass",
"async def compute(self, *args):\n\n if self.is_output:\n await self.output_compute(*args)\n else:\n await self.input_compute(*args)",
"def compute(self, **kwargs):\n raise NotImplementedError",
"def compute(*args, **kwarg... | [
"0.7612346",
"0.7391647",
"0.73353815",
"0.7278398",
"0.7083773",
"0.68990755",
"0.6735223",
"0.66403323",
"0.66300184",
"0.66108423",
"0.66101986",
"0.64207846",
"0.6332434",
"0.6248518",
"0.6230195",
"0.6211428",
"0.6190991",
"0.6186588",
"0.6131487",
"0.6117481",
"0.609191... | 0.6578323 | 11 |
Return the required window size in nanoseconds | def get_window_size(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determine_window_size(rectified_signal):\n logging.debug('running determine_window_size function')\n first_peak = first_peak_detect(rectified_signal, 1)\n second_peak = first_peak_detect(rectified_signal, first_peak + 1)\n return (second_peak - first_peak) * WINDOW_MULTIPLIER",
"def window_size(s... | [
"0.6956439",
"0.692949",
"0.6680659",
"0.6524226",
"0.6438083",
"0.643161",
"0.64152575",
"0.6410299",
"0.6361257",
"0.63495505",
"0.63490444",
"0.6307991",
"0.625709",
"0.6253582",
"0.6225795",
"0.6221469",
"0.618813",
"0.6102591",
"0.6072447",
"0.60635877",
"0.6054567",
"... | 0.6643748 | 3 |
returns number of 'instagram' stickers needed to make a phrase | def stickers_for(phrase):
stic_dict = {}
for ltr in 'instagram':
if ltr not in stic_dict:
stic_dict[ltr] = 1
else:
stic_dict[ltr] += 1
print(ltr)
phr_dict = {}
for ltr in phrase:
if ltr not in phr_dict:
phr_dict[ltr] = 1
else:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(text):\n return len(text)",
"def total_phrases(target_text):\n\n nbphrase = 0\n separators = '.!?;'\n for char in target_text:\n if char in separators:\n nbphrase = nbphrase + 1\n return nbphrase",
"def loop_through_text(phrase_length):\n\n # get text\n tanach =... | [
"0.6402699",
"0.62502104",
"0.62345266",
"0.61822414",
"0.6158409",
"0.61361337",
"0.6079605",
"0.6060118",
"0.6012842",
"0.6003197",
"0.59709525",
"0.5940616",
"0.58799154",
"0.5834511",
"0.5813628",
"0.5810768",
"0.5804959",
"0.5762326",
"0.57615393",
"0.57399106",
"0.57376... | 0.7720326 | 0 |
Loads config from the given paths. A handful of seed values will be set to act as if specified in the loaded config file's DEFAULT section, and be available for use in substitutions. The caller may override some of these seed values. | def load(cls, configpaths, seed_values=None):
if not configpaths:
return _EmptyConfig()
single_file_configs = []
for configpath in configpaths:
parser = cls._create_parser(seed_values)
with open(configpath, 'r') as ini:
parser.readfp(ini)
single_file_configs.append(_SingleFi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(paths):\n if not paths:\n raise ConfigException(message='No configuration file specified',\n reason=paths)\n yaml_dict = {}\n if type(paths) == str:\n paths = [paths]\n # for every filename in list...\n for path in paths:\n # read config fil... | [
"0.7207116",
"0.6690684",
"0.6671056",
"0.6507221",
"0.62847865",
"0.61621714",
"0.6146892",
"0.6069338",
"0.6026834",
"0.60224783",
"0.59600526",
"0.5925976",
"0.5920861",
"0.58888274",
"0.58582234",
"0.58458626",
"0.58401996",
"0.5825556",
"0.582437",
"0.58228505",
"0.58212... | 0.7786894 | 0 |
Creates a config parser that supports %([keyname])s value substitution. A handful of seed values will be set to act as if specified in the loaded config file's DEFAULT section, and be available for use in substitutions. The caller may override some of these seed values. | def _create_parser(cls, seed_values=None):
seed_values = seed_values or {}
buildroot = seed_values.get('buildroot', get_buildroot())
all_seed_values = {
'buildroot': buildroot,
'homedir': os.path.expanduser('~'),
'user': getpass.getuser(),
'pants_bootstrapdir': get_pants_cachedir(),... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _new():\n\treturn ConfigParser(\n\tdelimiters = ('=',),\n\tcomment_prefixes = ('#', ';'),\n\tdefault_section = 'default',\n\tallow_no_value = False,\n\tstrict = False,\n\tinterpolation = ExtendedInterpolation(),\n\tdefaults = {\n\t\t'debug': False,\n\t\t'datadir': path.join(path.expanduser('~'), '.local', 'ros... | [
"0.5458247",
"0.5408141",
"0.5199554",
"0.50978345",
"0.5079219",
"0.4990985",
"0.497882",
"0.49530998",
"0.49407214",
"0.49386162",
"0.49364063",
"0.49315286",
"0.4930387",
"0.49081331",
"0.4890862",
"0.48780882",
"0.4861418",
"0.48542067",
"0.48509136",
"0.48480615",
"0.483... | 0.5753604 | 0 |
Retrieves option from the specified section (or 'DEFAULT') and attempts to parse it as type. If the specified section does not exist or is missing a definition for the option, the value is looked up in the DEFAULT section. If there is still no definition found, the default value supplied is returned. | def get(self, section, option, type_=six.string_types, default=None):
return self._getinstance(section, option, type_, default) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, section, option, default=None, **kwargs):\n section = section.lower()\n option = option.lower()\n if self.has_section(section) and self.has_option(section, option):\n # Super does not work for ConfigParser as not inherited from object\n out = configparser.Co... | [
"0.73788524",
"0.7365858",
"0.7304894",
"0.7237488",
"0.71810937",
"0.6949195",
"0.6876211",
"0.686278",
"0.6829772",
"0.67827827",
"0.67400485",
"0.6720243",
"0.6594856",
"0.6542349",
"0.65182227",
"0.64763665",
"0.6465788",
"0.64603096",
"0.64568794",
"0.64402354",
"0.64163... | 0.7418041 | 0 |
Returns the underlying singlefile configs represented by this object. | def configs(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def configs(self):\n return self._configs",
"def configs(self):\n\n return self.__configs",
"def get_full_config(self):\n return self._read_config()",
"def config(self) -> dict:\n return self._configs",
"def config(self):\n return self._cfg",
"def config(self):\r\n r... | [
"0.71781963",
"0.71364343",
"0.70960563",
"0.6913402",
"0.69121945",
"0.66923416",
"0.6692044",
"0.6692044",
"0.6688849",
"0.6688849",
"0.6688849",
"0.6674267",
"0.6649714",
"0.66398054",
"0.65898687",
"0.6565974",
"0.65383905",
"0.65109235",
"0.65039575",
"0.650033",
"0.6458... | 0.6552234 | 16 |
Returns the sources of this config as a list of filenames. | def sources(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def source_name_list(self):\n return list(self._sources.keys())",
"def sources(self):\n return self._sources",
"def sources(self):\n return self._sources.keys()",
"def Sources():\n return _sources",
"def sources(self) -> Sequence[Any]:\n return pulumi.get(self, \"sources\")",... | [
"0.7786413",
"0.77240646",
"0.7713705",
"0.7628546",
"0.75150096",
"0.7434362",
"0.72902656",
"0.7239786",
"0.72359085",
"0.71616554",
"0.71586025",
"0.71586025",
"0.7079919",
"0.7046149",
"0.7037049",
"0.6996502",
"0.69905746",
"0.69320965",
"0.6907242",
"0.688997",
"0.68408... | 0.6767311 | 22 |
Returns the sections in this config (not including DEFAULT). | def sections(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def section_list(self):\n return self._config_parser.sections()",
"def getSections(self):\n answer = self._configParser.sections()\n for item in self._defaultValues:\n if item not in answer:\n answer.append(item)\n return answer",
"def sections(self):\n ... | [
"0.8512301",
"0.8508229",
"0.8307163",
"0.7925625",
"0.79061824",
"0.7736119",
"0.76756203",
"0.766217",
"0.76578575",
"0.7541391",
"0.7338333",
"0.7338333",
"0.72865856",
"0.72596097",
"0.7200811",
"0.71924216",
"0.71607226",
"0.7013504",
"0.69939464",
"0.69557583",
"0.68077... | 0.6593047 | 22 |
Returns whether this config has the section. | def has_section(self, section):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_section(self,name):\n return self.__config.has_section(name)",
"def has_section(self, section):\r\n return self.configparser.has_section(section)",
"def has_section(self, section):\n\n return self.cfg.has_section(section)",
"def has_section(self, section):\n return section in self... | [
"0.8642762",
"0.84708226",
"0.8450783",
"0.83417547",
"0.82778883",
"0.82477504",
"0.81383157",
"0.8037954",
"0.768683",
"0.7682951",
"0.7524755",
"0.711535",
"0.7076341",
"0.7069764",
"0.6811312",
"0.67209554",
"0.6706611",
"0.67006975",
"0.6656741",
"0.66467994",
"0.6576400... | 0.7412496 | 11 |
Returns whether this config specified a value the option. | def has_option(self, section, option):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_option(self, name):\n return self.option_settings[name]",
"def has_option(self, key):\n\n return key in self.__opt",
"def has_option(self, option):\n splitvals = option.split('/')\n section, key = \"/\".join(splitvals[:-1]), splitvals[-1]\n\n return RawConfigParser.ha... | [
"0.77919054",
"0.7458672",
"0.7176345",
"0.7071135",
"0.7064684",
"0.69743544",
"0.69613177",
"0.6923256",
"0.6885776",
"0.6852783",
"0.684224",
"0.68362474",
"0.6797654",
"0.6762468",
"0.67084855",
"0.6697023",
"0.6682692",
"0.6671115",
"0.66410077",
"0.6624669",
"0.6616862"... | 0.61884606 | 48 |
Returns the value of the option in this config as a string, or None if no value specified. | def get_value(self, section, option):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_value(self):\n return self._get_value(self.optionType, self.value, self.defaultValue)",
"def fmt_option_val(option):\n if option is None:\n return \"\"\n return str(option)",
"def opt_value(self):\n return self._opt_value",
"def OptionValue(self):\n if self.force_aut... | [
"0.7286254",
"0.72754765",
"0.71678287",
"0.7146978",
"0.71148956",
"0.690592",
"0.68540543",
"0.6821994",
"0.67486674",
"0.6748038",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0.67415774",
"0... | 0.6038727 | 100 |
Returns the path to the source file the given option was defined in. | def get_source_for_option(self, section, option):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def source_file_path(self) -> str:\n return self._source_file_path",
"def _get_source_path(self, docmeta: DocMetadata) -> Optional[str]:\n identifier = docmeta.arxiv_identifier\n version = docmeta.version\n file_noex = identifier.filename\n if not docmeta.is_latest:\n ... | [
"0.70683277",
"0.6915933",
"0.68622655",
"0.6847837",
"0.66117984",
"0.6302336",
"0.6269676",
"0.6259663",
"0.6240513",
"0.6234616",
"0.6230491",
"0.6221738",
"0.62008744",
"0.6191012",
"0.6189371",
"0.61713874",
"0.6149972",
"0.61361355",
"0.6125448",
"0.60671276",
"0.604563... | 0.74370855 | 0 |
initialize the tmean cluster | def __init__(self,
n_clusters=0,
centroids=None,
data=None,
labels=[],
distance='cov',
threshold=0.38,
dimension=128,
update_centroids=True):
self.n_clusters = n_clusters
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_cluster(self):\n self._Init_Cluster()",
"def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n ... | [
"0.6738208",
"0.63276654",
"0.63108695",
"0.62052727",
"0.60864115",
"0.6062684",
"0.60300195",
"0.5981466",
"0.59145635",
"0.5901523",
"0.5853843",
"0.5845921",
"0.58449733",
"0.5808943",
"0.5794397",
"0.5763279",
"0.5758935",
"0.574938",
"0.57491726",
"0.57318556",
"0.57304... | 0.5286891 | 75 |
solve argmin_{beta} ||y X dot beta ||_1 | def IRLS(self, y, X, beta, w, delta = 1e-8):
W = sparse.diags(w)
beta = inv(X.T @ W @ X) @ X.T @ W @ y
w = 1 / np.maximum(delta, np.abs(y - X @ beta))
return beta, w | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def minfunc(beta, yvec, xmat ):\n return yvec - exp(dot(xmat, beta))",
"def objective(beta, lambdat, X, y):\n return 1/len(y) * (np.sum(\n (np.maximum(0, 1-((y[:, np.newaxis]*X).dot(beta)))**2)))\\\n + lambdat * np.linalg.norm(beta)**2",
"def solve_beta_lasso(X, Y, t):\n p = X.shape[1]\n... | [
"0.76020336",
"0.66610235",
"0.6239103",
"0.6199994",
"0.5979489",
"0.59647894",
"0.5962795",
"0.5930549",
"0.588228",
"0.5881008",
"0.58784705",
"0.5788748",
"0.5787775",
"0.57678",
"0.57592976",
"0.57562065",
"0.5743531",
"0.5743035",
"0.57398003",
"0.57210016",
"0.57176596... | 0.0 | -1 |
Provides specific explanation data. | def data(self, key=None):
# NOTE: When a non-default provider is used, it's represented as ("provider", key).
if isinstance(key, tuple) and len(key) == 2:
_, key = key
# NOTE: Currently returns full internal object, open to change.
if key == -1:
return self._inte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def explain(self):",
"def _describe(self) -> Dict[str, Any]:",
"def explanation(self, explanation):\n\n self._explanation = explanation",
"def get_explain_details2(match_explanation):\n expl = []\n matchers = match_explanation[\"details\"] # at times the explanation is not in 'details' list!!\n if... | [
"0.66131544",
"0.65381855",
"0.6452191",
"0.6341137",
"0.63367254",
"0.6238496",
"0.60453624",
"0.60426176",
"0.6004104",
"0.5966842",
"0.596472",
"0.59641504",
"0.5941501",
"0.5920873",
"0.5890071",
"0.58864754",
"0.58783513",
"0.58569354",
"0.58312625",
"0.5824691",
"0.5818... | 0.0 | -1 |
cached request to github to avoid requesting this too often | def _fetch_data(url: str, d: datetime) -> pd.DataFrame:
return pd.read_json(url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def github_api(request):\n if not request.startswith('https://api.github.com/'):\n request = 'https://api.github.com/' + request\n d = time.time() - github_api.last_time\n if d < 1:\n time.sleep(1 - d) # wait at least one second between GitHub API calls\n key = os.getenv('GITHUB_API_KEY'... | [
"0.6290903",
"0.6110685",
"0.6091229",
"0.6054084",
"0.58456695",
"0.58443004",
"0.58402115",
"0.58225346",
"0.579956",
"0.5798013",
"0.5787587",
"0.57315785",
"0.5699487",
"0.5694648",
"0.562111",
"0.5616564",
"0.56037015",
"0.55681086",
"0.5555009",
"0.55348444",
"0.5524224... | 0.0 | -1 |
Tests the ability to submit machine flags | def test_machine_flags(mock_htb_client: HTBClient):
# Create a fake machine to test with
machine = Machine({
"id": 1,
"name": "Lame",
"os": "Linux",
"points": 0,
"release": "2021-02-27T17:00:00.000000Z",
"user_owns_count": 0,
"root_owns_count": 0,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_checkFlags(self):\n self.failUnlessEqual(self.nice.opts['aflag'], 1)\n self.failUnlessEqual(self.nice.opts['flout'], 0)",
"def test_handle_flag_error(self):\n pass",
"def test_fortress_flags(mock_htb_client: HTBClient):\n # Create a fake fortress to test with\n fortress = Fo... | [
"0.6605318",
"0.65299326",
"0.64944285",
"0.64357823",
"0.6367936",
"0.62655514",
"0.6254911",
"0.62415195",
"0.60922045",
"0.6091679",
"0.60882485",
"0.60709053",
"0.6067145",
"0.60066473",
"0.5954045",
"0.59530026",
"0.5952983",
"0.59263897",
"0.59212893",
"0.5817619",
"0.5... | 0.79896796 | 0 |
Tests the ability to submit challenge flags | def test_challenge_flags(mock_htb_client: HTBClient):
# Create a fake challenge to test with
challenge = Challenge({
"id": 1,
"name": "Crack This",
"retired": True,
"points": 0,
"difficulty_chart": "0",
"release_date": "2018-04-25",
"solves": 0,
"a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fortress_flags(mock_htb_client: HTBClient):\n # Create a fake fortress to test with\n fortress = Fortress({\n \"id\": 1,\n \"name\": \"Jet\",\n \"ip\": \"10.13.37.10\",\n \"image\": \"https://www.hackthebox.eu/storage/companies/3.png\",\n \"number_of_flags\": 11\n ... | [
"0.7046961",
"0.6523449",
"0.6378727",
"0.615151",
"0.59990907",
"0.5966798",
"0.59481794",
"0.594684",
"0.5943263",
"0.5833452",
"0.58245754",
"0.5815917",
"0.5809349",
"0.5805617",
"0.5789382",
"0.57777566",
"0.5737647",
"0.5709123",
"0.5697028",
"0.56850445",
"0.5678845",
... | 0.82451797 | 0 |
Tests the ability to submit endgame flags | def test_endgame_flags(mock_htb_client: HTBClient):
# Create a fake endgame to test with
endgame = Endgame({
"id": 1,
"name": "P.O.O.",
"avatar_url": "nothing.png",
"cover_image_url": "nothing.png",
"retired": True,
"vip": True,
"creators": [{
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_challenge_flags(mock_htb_client: HTBClient):\n # Create a fake challenge to test with\n challenge = Challenge({\n \"id\": 1,\n \"name\": \"Crack This\",\n \"retired\": True,\n \"points\": 0,\n \"difficulty_chart\": \"0\",\n \"release_date\": \"2018-04-25\",\... | [
"0.6466769",
"0.63374233",
"0.62643325",
"0.61247206",
"0.61133975",
"0.61104405",
"0.609314",
"0.60709924",
"0.59978354",
"0.58942944",
"0.5889562",
"0.5853111",
"0.58342797",
"0.5833326",
"0.58182824",
"0.5808839",
"0.580797",
"0.5788669",
"0.5773043",
"0.57706904",
"0.5754... | 0.77757776 | 0 |
Tests the ability to submit fortress flags | def test_fortress_flags(mock_htb_client: HTBClient):
# Create a fake fortress to test with
fortress = Fortress({
"id": 1,
"name": "Jet",
"ip": "10.13.37.10",
"image": "https://www.hackthebox.eu/storage/companies/3.png",
"number_of_flags": 11
}, mock_htb_client, summar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_checkFlags(self):\n self.failUnlessEqual(self.nice.opts['aflag'], 1)\n self.failUnlessEqual(self.nice.opts['flout'], 0)",
"def test_flags(self):\n self.check_search(\n dict(flag_contact=u'yes'),\n [u'Tackle', u'DoubleSlap', u'Ice Punch', u'Bite', u'Fly'],\n ... | [
"0.6779397",
"0.6575178",
"0.64314836",
"0.6311009",
"0.620359",
"0.61329275",
"0.6104035",
"0.6099779",
"0.6085823",
"0.6070564",
"0.60327524",
"0.60288745",
"0.60206354",
"0.59562874",
"0.5912869",
"0.5899586",
"0.5886937",
"0.5829158",
"0.57350963",
"0.57208604",
"0.571990... | 0.77798915 | 0 |
Test explicit value creation. | def test_creation(site):
attr = models.Attribute.objects.create(
resource_name='Device',
site=site, name='test_attribute'
)
dev = models.Device.objects.create(
hostname='foo-bar1', site=site
)
# Explicitly create a Value without providing site_id
val = models.Value.objec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_creation_dict():\n with pytest.raises(ValueError) as __:\n value = dict()\n __ = param.Integer(value=value)",
"def test_creation_str():\n with pytest.raises(ValueError) as __:\n value = \"42\"\n __ = param.Integer(value=value)",
"def test_creat... | [
"0.73240423",
"0.71990496",
"0.7117133",
"0.70802635",
"0.68730843",
"0.66622335",
"0.64344686",
"0.6415248",
"0.63561475",
"0.6349691",
"0.6336331",
"0.6328015",
"0.6309541",
"0.62116146",
"0.61904067",
"0.61900926",
"0.61748517",
"0.6167833",
"0.6157425",
"0.61522233",
"0.6... | 0.61966324 | 14 |
Return the url to use to get a video thumbnail. | def _get_url(self, video, thumbnail):
return f"/api/videos/{video.pk}/thumbnails/{thumbnail.id}/" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail_url(self):\n if self.thumbnail_url:\n return self.thumbnail_url\n \n if not self.get_video_id():\n return ''\n \n if not self.thumbnail_url:\n api_url = 'https://api.dailymotion.com/video/%s?fields=thumbnail_url' % self.get_video_id()\n ... | [
"0.8509363",
"0.8491865",
"0.8400712",
"0.8359779",
"0.8358022",
"0.8317948",
"0.813222",
"0.8024413",
"0.7839949",
"0.77882147",
"0.77798337",
"0.76739687",
"0.76691765",
"0.7563553",
"0.7558059",
"0.7404783",
"0.7250487",
"0.72193384",
"0.71992475",
"0.7136481",
"0.709769",... | 0.8081987 | 7 |
Assert the user cannot retrieve a thumbnail. | def assert_user_cannot_retrieve_thumbnail(self, user, thumbnail):
jwt_token = UserAccessTokenFactory(user=user)
response = self.client.get(
self._get_url(thumbnail.video, thumbnail),
HTTP_AUTHORIZATION=f"Bearer {jwt_token}",
)
self.assertEqual(response.status_co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_retrieve_by_random_user(self):\n user = UserFactory()\n\n self.assert_user_cannot_retrieve_thumbnail(user, self.some_thumbnail)",
"def assert_user_can_retrieve_thumbnail(self, user, thumbnail):\n jwt_token = UserAccessTokenFactory(user=user)\n\n response = self.... | [
"0.7858373",
"0.6750369",
"0.67265964",
"0.66662884",
"0.6562147",
"0.65335554",
"0.6521999",
"0.6404572",
"0.63752455",
"0.63744694",
"0.6354989",
"0.6335756",
"0.6335132",
"0.63183075",
"0.6306187",
"0.62036556",
"0.6201066",
"0.6169549",
"0.6157951",
"0.61430115",
"0.60936... | 0.8417783 | 0 |
Assert the user can retrieve a thumbnail. | def assert_user_can_retrieve_thumbnail(self, user, thumbnail):
jwt_token = UserAccessTokenFactory(user=user)
response = self.client.get(
self._get_url(thumbnail.video, thumbnail),
HTTP_AUTHORIZATION=f"Bearer {jwt_token}",
)
self.assertEqual(response.status_code,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_retrieve_by_random_user(self):\n user = UserFactory()\n\n self.assert_user_cannot_retrieve_thumbnail(user, self.some_thumbnail)",
"def assert_user_cannot_retrieve_thumbnail(self, user, thumbnail):\n jwt_token = UserAccessTokenFactory(user=user)\n\n response = se... | [
"0.7861407",
"0.76095414",
"0.75132185",
"0.71113604",
"0.70641714",
"0.68966985",
"0.68929076",
"0.6885267",
"0.68603885",
"0.6830988",
"0.6725639",
"0.67165977",
"0.66617674",
"0.66551024",
"0.661036",
"0.6549719",
"0.65310204",
"0.6513257",
"0.6444996",
"0.6356796",
"0.634... | 0.79718024 | 0 |
Anonymous users should not be allowed to retrieve a thumbnail. | def test_api_thumbnail_read_detail_anonymous(self):
video = VideoFactory()
thumbnail = ThumbnailFactory(video=video)
response = self.client.get(self._get_url(video, thumbnail))
self.assertEqual(response.status_code, 401)
content = json.loads(response.content)
self.assertE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_home_as_anonymous(self):\n response = self.client.get(\"/images/contents/\")\n self.assertEqual(response.status_code, 401)",
"def test_home_as_anonymous(self):\n response = self.client.get(\"/images/contents/\")\n self.assertEqual(response.status_code, 401)",
"def assert_us... | [
"0.68530566",
"0.68530566",
"0.67204446",
"0.6701233",
"0.63773066",
"0.6366298",
"0.6249894",
"0.624031",
"0.6135416",
"0.6123689",
"0.6103045",
"0.6043306",
"0.5995901",
"0.59817123",
"0.59473157",
"0.58821845",
"0.5838749",
"0.58223754",
"0.57953495",
"0.5790194",
"0.57737... | 0.7287502 | 0 |
Authenticated user without access cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_random_user(self):
user = UserFactory()
self.assert_user_cannot_retrieve_thumbnail(user, self.some_thumbnail) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_user_cannot_retrieve_thumbnail(self, user, thumbnail):\n jwt_token = UserAccessTokenFactory(user=user)\n\n response = self.client.get(\n self._get_url(thumbnail.video, thumbnail),\n HTTP_AUTHORIZATION=f\"Bearer {jwt_token}\",\n )\n\n self.assertEqual(res... | [
"0.75183046",
"0.70896447",
"0.6801665",
"0.6583585",
"0.6538382",
"0.6501151",
"0.6361877",
"0.6343528",
"0.633494",
"0.6316429",
"0.63046277",
"0.6302587",
"0.61078155",
"0.6107007",
"0.6094753",
"0.6094753",
"0.6067809",
"0.60633063",
"0.60210025",
"0.6020656",
"0.60054046... | 0.71911126 | 1 |
Organization students cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_organization_student(self):
organization_access = OrganizationAccessFactory(
organization=self.some_organization,
role=STUDENT,
)
self.assert_user_cannot_retrieve_thumbnail(
organization_access.user, self.some_thumbnail
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_user_cannot_retrieve_thumbnail(self, user, thumbnail):\n jwt_token = UserAccessTokenFactory(user=user)\n\n response = self.client.get(\n self._get_url(thumbnail.video, thumbnail),\n HTTP_AUTHORIZATION=f\"Bearer {jwt_token}\",\n )\n\n self.assertEqual(res... | [
"0.6759956",
"0.6608878",
"0.6606777",
"0.65997195",
"0.63853014",
"0.6371965",
"0.62514627",
"0.61948556",
"0.61474854",
"0.6042091",
"0.60399956",
"0.59651506",
"0.58786523",
"0.5877402",
"0.5835692",
"0.58111465",
"0.5799567",
"0.5793276",
"0.5775071",
"0.5764711",
"0.5759... | 0.73315066 | 0 |
Organization instructors cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_organization_instructor(self):
organization_access = OrganizationAccessFactory(
organization=self.some_organization,
role=INSTRUCTOR,
)
self.assert_user_cannot_retrieve_thumbnail(
organization_access.user, self.some_thumbnai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_retrieve_by_organization_student(self):\n organization_access = OrganizationAccessFactory(\n organization=self.some_organization,\n role=STUDENT,\n )\n\n self.assert_user_cannot_retrieve_thumbnail(\n organization_access.user, self.some_th... | [
"0.6952235",
"0.6369274",
"0.6285176",
"0.6232424",
"0.6225232",
"0.61745995",
"0.6172444",
"0.61498815",
"0.6121853",
"0.6116987",
"0.594136",
"0.58232135",
"0.5762892",
"0.57019526",
"0.56708616",
"0.5668787",
"0.5641343",
"0.5612725",
"0.5612397",
"0.5575803",
"0.5553606",... | 0.75101215 | 0 |
Organization administrators can retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_organization_administrator(self):
organization_access = OrganizationAccessFactory(
organization=self.some_organization,
role=ADMINISTRATOR,
)
self.assert_user_can_retrieve_thumbnail(
organization_access.user, self.some_thumb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail_url():",
"def test_api_thumbnail_retrieve_by_playlist_admin(self):\n playlist_access = PlaylistAccessFactory(\n playlist=self.some_video.playlist,\n role=ADMINISTRATOR,\n )\n\n self.assert_user_can_retrieve_thumbnail(\n playlist_access.user,... | [
"0.69568473",
"0.6949048",
"0.69144523",
"0.6782628",
"0.67104197",
"0.66854703",
"0.65969235",
"0.6590126",
"0.6586846",
"0.6573921",
"0.65533423",
"0.64994305",
"0.6378205",
"0.636926",
"0.6366648",
"0.6348245",
"0.62879926",
"0.6287473",
"0.62491494",
"0.62364477",
"0.6232... | 0.71771973 | 0 |
Consumer site roles cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_consumer_site_any_role(self):
consumer_site_access = ConsumerSiteAccessFactory(
consumer_site=self.some_video.playlist.consumer_site,
)
self.assert_user_cannot_retrieve_thumbnail(
consumer_site_access.user, self.some_thumbnail
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_user_cannot_retrieve_thumbnail(self, user, thumbnail):\n jwt_token = UserAccessTokenFactory(user=user)\n\n response = self.client.get(\n self._get_url(thumbnail.video, thumbnail),\n HTTP_AUTHORIZATION=f\"Bearer {jwt_token}\",\n )\n\n self.assertEqual(res... | [
"0.68565124",
"0.6401451",
"0.62354344",
"0.6173921",
"0.6166922",
"0.6150965",
"0.6077196",
"0.60095006",
"0.59961003",
"0.5961394",
"0.59391886",
"0.5873697",
"0.5857408",
"0.56985843",
"0.5674253",
"0.56423765",
"0.56163293",
"0.55962807",
"0.55887306",
"0.5585544",
"0.558... | 0.75406796 | 0 |
Playlist student cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_playlist_student(self):
playlist_access = PlaylistAccessFactory(
playlist=self.some_video.playlist,
role=STUDENT,
)
self.assert_user_cannot_retrieve_thumbnail(
playlist_access.user, self.some_thumbnail
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail(self):\r\n raise Exception('get_thumbnail is Not Implemented in base class \"Video\"')",
"def test_api_thumbnail_read_detail_student(self):\n video = VideoFactory()\n thumbnail = ThumbnailFactory(video=video)\n\n jwt_token = StudentLtiTokenFactory(playlist=video.play... | [
"0.72964805",
"0.7294963",
"0.7204757",
"0.66731846",
"0.661595",
"0.6610957",
"0.65946805",
"0.6585006",
"0.6512752",
"0.6450439",
"0.63490075",
"0.63181674",
"0.6197807",
"0.6148186",
"0.61198866",
"0.6115284",
"0.609608",
"0.6090407",
"0.60756737",
"0.60405296",
"0.6007919... | 0.76357526 | 0 |
Playlist instructor cannot retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_playlist_instructor(self):
playlist_access = PlaylistAccessFactory(
playlist=self.some_video.playlist,
role=INSTRUCTOR,
)
self.assert_user_can_retrieve_thumbnail(
playlist_access.user, self.some_thumbnail
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail(self):\r\n raise Exception('get_thumbnail is Not Implemented in base class \"Video\"')",
"def test_api_thumbnail_retrieve_by_playlist_student(self):\n playlist_access = PlaylistAccessFactory(\n playlist=self.some_video.playlist,\n role=STUDENT,\n )\n\n... | [
"0.754921",
"0.72657204",
"0.7022425",
"0.6922864",
"0.6887758",
"0.6872325",
"0.68639344",
"0.6854711",
"0.6709114",
"0.65598696",
"0.647682",
"0.6444286",
"0.63603157",
"0.63512784",
"0.6273392",
"0.6267445",
"0.6266809",
"0.62609625",
"0.62433076",
"0.62410164",
"0.6197724... | 0.7200989 | 2 |
Playlist administrator can retrieve a thumbnail. | def test_api_thumbnail_retrieve_by_playlist_admin(self):
playlist_access = PlaylistAccessFactory(
playlist=self.some_video.playlist,
role=ADMINISTRATOR,
)
self.assert_user_can_retrieve_thumbnail(
playlist_access.user, self.some_thumbnail
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail(self):\r\n raise Exception('get_thumbnail is Not Implemented in base class \"Video\"')",
"def test_api_thumbnail_retrieve_by_playlist_instructor(self):\n playlist_access = PlaylistAccessFactory(\n playlist=self.some_video.playlist,\n role=INSTRUCTOR,\n ... | [
"0.7072114",
"0.7043516",
"0.7031702",
"0.70205593",
"0.68750274",
"0.6830887",
"0.67835605",
"0.67505544",
"0.669611",
"0.66419655",
"0.66401845",
"0.66229904",
"0.6611108",
"0.66012394",
"0.6589992",
"0.65843177",
"0.6499029",
"0.6455152",
"0.6356071",
"0.63520384",
"0.6281... | 0.7956929 | 0 |
Students users should not be allowed to read a thumbnail detail. | def test_api_thumbnail_read_detail_student(self):
video = VideoFactory()
thumbnail = ThumbnailFactory(video=video)
jwt_token = StudentLtiTokenFactory(playlist=video.playlist)
response = self.client.get(
self._get_url(video, thumbnail),
HTTP_AUTHORIZATION=f"Beare... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_administrator_read_detail_in_read_only(self):\n thumbnail = ThumbnailFactory()\n\n jwt_token = InstructorOrAdminLtiTokenFactory(\n playlist=thumbnail.video.playlist,\n permissions__can_update=False,\n )\n\n response = self.client.get(\n ... | [
"0.72766185",
"0.70698196",
"0.6967689",
"0.6460065",
"0.6312292",
"0.6261655",
"0.61761296",
"0.61653566",
"0.60412514",
"0.5985592",
"0.59407854",
"0.59155726",
"0.58906955",
"0.5862425",
"0.586175",
"0.5833028",
"0.5833028",
"0.5773634",
"0.57534486",
"0.5732344",
"0.56791... | 0.6705593 | 3 |
Instructor should not be able to read thumbnails in a read_only mode. | def test_api_thumbnail_instructor_read_detail_in_read_only(self):
thumbnail = ThumbnailFactory()
jwt_token = InstructorOrAdminLtiTokenFactory(
playlist=thumbnail.video.playlist,
permissions__can_update=False,
)
response = self.client.get(
self._get_u... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_administrator_read_detail_in_read_only(self):\n thumbnail = ThumbnailFactory()\n\n jwt_token = InstructorOrAdminLtiTokenFactory(\n playlist=thumbnail.video.playlist,\n permissions__can_update=False,\n )\n\n response = self.client.get(\n ... | [
"0.7128775",
"0.6064049",
"0.5956134",
"0.59525853",
"0.5946476",
"0.5924403",
"0.5898635",
"0.58588713",
"0.5841984",
"0.5751428",
"0.5735692",
"0.57163644",
"0.5715092",
"0.5666382",
"0.56368256",
"0.56359357",
"0.5584379",
"0.55173814",
"0.55173814",
"0.54943883",
"0.54872... | 0.6774711 | 1 |
Instructors should be able to read details of thumbnail associated to their video. | def test_api_thumbnail_read_detail_token_user(self):
video = VideoFactory(
uploaded_on=datetime(2018, 8, 8, tzinfo=timezone.utc), upload_state="ready"
)
thumbnail = ThumbnailFactory(video=video, upload_state="pending")
jwt_token = InstructorOrAdminLtiTokenFactory(playlist=vi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail(self):\r\n raise Exception('get_thumbnail is Not Implemented in base class \"Video\"')",
"def test_api_thumbnail_read_detail_student(self):\n video = VideoFactory()\n thumbnail = ThumbnailFactory(video=video)\n\n jwt_token = StudentLtiTokenFactory(playlist=video.play... | [
"0.79106504",
"0.71708935",
"0.711236",
"0.70729136",
"0.70006025",
"0.6909872",
"0.6901868",
"0.68766785",
"0.6864849",
"0.68309647",
"0.6824591",
"0.68066835",
"0.6778094",
"0.67371124",
"0.6660454",
"0.6659213",
"0.66370344",
"0.6631762",
"0.66140234",
"0.6612588",
"0.6609... | 0.7088053 | 3 |
Admin should not be able to read thumbnails in a read_only mode. | def test_api_thumbnail_administrator_read_detail_in_read_only(self):
thumbnail = ThumbnailFactory()
jwt_token = InstructorOrAdminLtiTokenFactory(
playlist=thumbnail.video.playlist,
permissions__can_update=False,
)
response = self.client.get(
self._ge... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_api_thumbnail_instructor_read_detail_in_read_only(self):\n thumbnail = ThumbnailFactory()\n\n jwt_token = InstructorOrAdminLtiTokenFactory(\n playlist=thumbnail.video.playlist,\n permissions__can_update=False,\n )\n\n response = self.client.get(\n ... | [
"0.661828",
"0.6382733",
"0.6356342",
"0.6159073",
"0.6037804",
"0.6037804",
"0.5990374",
"0.59651357",
"0.59140724",
"0.5866006",
"0.58399206",
"0.5734935",
"0.5719596",
"0.5685072",
"0.5679178",
"0.56767166",
"0.5566921",
"0.5552464",
"0.5542619",
"0.55314493",
"0.55218256"... | 0.71898 | 0 |
Admin should be able to read details of thumbnail associated to their video. | def test_api_thumbnail_read_detail_admin_user(self):
video = VideoFactory(
uploaded_on=datetime(2018, 8, 8, tzinfo=timezone.utc), upload_state="ready"
)
thumbnail = ThumbnailFactory(video=video, upload_state="pending")
jwt_token = InstructorOrAdminLtiTokenFactory(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail(self):\r\n raise Exception('get_thumbnail is Not Implemented in base class \"Video\"')",
"def get_thumbnail_url(self):\n if self.thumbnail_url:\n return self.thumbnail_url\n \n if not self.get_video_id() or not self.get_username():\n return ''\n \n ... | [
"0.7471359",
"0.68928635",
"0.68879104",
"0.68605113",
"0.683838",
"0.679808",
"0.6788042",
"0.6787663",
"0.67236894",
"0.67226833",
"0.66978943",
"0.66908675",
"0.66846454",
"0.6566404",
"0.6513157",
"0.64605933",
"0.64442825",
"0.64260656",
"0.6422254",
"0.641737",
"0.64100... | 0.7063691 | 1 |
A ready thumbnail should have computed urls. | def test_api_thumbnail_read_ready_thumbnail(self):
video = VideoFactory(
pk="78338c1c-356e-4156-bd95-5bed71ffb655",
uploaded_on=datetime(2018, 8, 8, tzinfo=timezone.utc),
upload_state="ready",
)
thumbnail = ThumbnailFactory(
video=video,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_thumbnail_url():",
"def thumbnail_url(self):\n return None",
"def prepare_thumbnail_url(self, object):\n if object.media is not None:\n return os.path.join(settings.MEDIA_URL, object.media.media_thumb_file.name)\n else:\n return ''",
"def thumbnail_url_if_se... | [
"0.7071324",
"0.6947205",
"0.64887977",
"0.64814335",
"0.645994",
"0.6422525",
"0.6387085",
"0.63043034",
"0.6263864",
"0.6248888",
"0.6232873",
"0.6228274",
"0.6215955",
"0.6176703",
"0.61678946",
"0.6028321",
"0.6024606",
"0.60037696",
"0.60035664",
"0.59153795",
"0.5912750... | 0.6284165 | 8 |
Trying to retrieve a thumbnail using an other video in the url should return a 404. | def test_api_thumbnail_retrieve_from_another_video(self):
thumbnail = ThumbnailFactory()
other_video = VideoFactory(playlist=thumbnail.video.playlist)
jwt_token = InstructorOrAdminLtiTokenFactory(playlist=thumbnail.video.playlist)
response = self.client.get(
self._get_url(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_url(self, video, thumbnail):\n return f\"/api/videos/{video.pk}/thumbnails/{thumbnail.id}/\"",
"def test_video_thumbnail(self):\n data = TestData().load_users().load_galleries()\n album = data.gallery_b7w.top_album\n\n video1 = Video.objects.create(album=album, uid='56433514'... | [
"0.7110042",
"0.7059349",
"0.70160884",
"0.6730062",
"0.666879",
"0.6634168",
"0.6619411",
"0.6557481",
"0.6487372",
"0.6479977",
"0.6477736",
"0.6452395",
"0.644955",
"0.63289744",
"0.6300859",
"0.62483877",
"0.6219747",
"0.6173391",
"0.6165181",
"0.61574286",
"0.6088163",
... | 0.78344685 | 0 |
Check if the line has already an active route | def pre_save_route(sender, **kwargs):
instance = kwargs.get('instance')
if instance.is_active and RouteModel.objects.filter(line_id=instance.line_id,
is_active=True)\
.exclude(id=instance.id or -1).exists():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visited(self, route=[], connection=None):\r\n\r\n visited_airports = [self.flights[flight].source for flight in route]\r\n\r\n if self.flights[connection].source in visited_airports:\r\n # find index of connection source in visited airports on route\r\n segment_start = visit... | [
"0.65387857",
"0.6377769",
"0.6372641",
"0.6372641",
"0.6365585",
"0.62267476",
"0.6223022",
"0.6218845",
"0.619473",
"0.6103653",
"0.6094104",
"0.6076136",
"0.6058769",
"0.60385406",
"0.599384",
"0.5954393",
"0.59505534",
"0.58803916",
"0.5868137",
"0.5857777",
"0.5817007",
... | 0.6748292 | 0 |
This function plots an ellipse that represents a covariance matrix. The ellipse is centered at (x, y) and its shape, size and rotation are determined by the covariance matrix. | def plot_covariance_ellipse(x, y, cov, chi2=3.0, color="-r", ax=None):
eig_val, eig_vec = np.linalg.eig(cov)
if eig_val[0] >= eig_val[1]:
big_ind = 0
small_ind = 1
else:
big_ind = 1
small_ind = 0
a = math.sqrt(chi2 * eig_val[big_ind])
b = math.sqrt(chi2 * eig_val[sma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_ellipse(center, covariance, alpha, color):\n # eigenvalues and eigenvector of matrix covariance\n eigenvalues, eigenvector = np.linalg.eigh(covariance)\n order = eigenvalues.argsort()[::-1]\n eigenvector = eigenvector[:, order]\n\n # Calculate Angle of ellipse\n angle = np.degrees(np.arc... | [
"0.8121411",
"0.786105",
"0.7851154",
"0.7836551",
"0.7788456",
"0.77731025",
"0.7677366",
"0.75016886",
"0.74661875",
"0.74517506",
"0.7439261",
"0.74343836",
"0.74177426",
"0.7180367",
"0.6976172",
"0.69502145",
"0.68941927",
"0.68941927",
"0.68941927",
"0.68461376",
"0.665... | 0.7838968 | 3 |
This function plots an ellipse based on the given parameters. | def plot_ellipse(x, y, a, b, angle, color="-r", ax=None, **kwargs):
t = np.arange(0, 2 * math.pi + 0.1, 0.1)
px = [a * math.cos(it) for it in t]
py = [b * math.sin(it) for it in t]
fx = rot_mat_2d(angle) @ (np.array([px, py]))
px = np.array(fx[0, :] + x).flatten()
py = np.array(fx[1, :] + y).fl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_ellipse(center, covariance, alpha, color):\n # eigenvalues and eigenvector of matrix covariance\n eigenvalues, eigenvector = np.linalg.eigh(covariance)\n order = eigenvalues.argsort()[::-1]\n eigenvector = eigenvector[:, order]\n\n # Calculate Angle of ellipse\n angle = np.degrees(np.arc... | [
"0.7876582",
"0.75598735",
"0.7379512",
"0.7341711",
"0.725592",
"0.72097546",
"0.7179025",
"0.71503866",
"0.7085659",
"0.70802534",
"0.7069205",
"0.7030703",
"0.70065445",
"0.6996101",
"0.6995528",
"0.6958151",
"0.69569767",
"0.6942199",
"0.6931811",
"0.68900853",
"0.6841160... | 0.73253155 | 4 |
Plot an arrow or arrows based on 2D state (x, y, yaw) All optional settings of matplotlib.pyplot.arrow can be used. | def plot_arrow(x, y, yaw, arrow_length=1.0,
origin_point_plot_style="xr",
head_width=0.1, fc="r", ec="k", **kwargs):
if not isinstance(x, float):
for (i_x, i_y, i_yaw) in zip(x, y, yaw):
plot_arrow(i_x, i_y, i_yaw, head_width=head_width,
fc=fc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _plot(self, **kwargs):\n XY = self.positions\n plt.plot(XY[0,:], XY[1,:], 'o')\n plt.gca().set_aspect('equal')\n SS = np.abs(self.S)\n SS /= SS.max()\n\n for i in range(self.N):\n for j in range(self.N):\n if i == j or SS[i,j] < 1e-2:\n ... | [
"0.6329709",
"0.6254767",
"0.6178017",
"0.5998989",
"0.5936659",
"0.59270495",
"0.5884406",
"0.58207273",
"0.5796814",
"0.57445866",
"0.5731595",
"0.5682117",
"0.56536233",
"0.5604874",
"0.5574216",
"0.5567082",
"0.54870504",
"0.5486324",
"0.54488695",
"0.54224336",
"0.542128... | 0.73107964 | 0 |
Plot curvature on 2D path. This plot is a line from the original path, the lateral distance from the original path shows curvature magnitude. Left turning shows right side plot, right turning shows left side plot. For straight path, the curvature plot will be on the path, because curvature is 0 on the straight path. | def plot_curvature(x_list, y_list, heading_list, curvature,
k=0.01, c="-c", label="Curvature"):
cx = [x + d * k * np.cos(yaw - np.pi / 2.0) for x, y, yaw, d in
zip(x_list, y_list, heading_list, curvature)]
cy = [y + d * k * np.sin(yaw - np.pi / 2.0) for x, y, yaw, d in
zip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curvature(x, y):\n dalpha = np.pi/1000\n xd1 = np.gradient(x, 2)\n xd2 = np.gradient(xd1, 2)\n yd1 = np.gradient(y, 2)\n yd2 = np.gradient(yd1, 2)\n\n return np.abs(xd1*yd2 - yd1*xd2) / np.power(xd1**2 + yd1**2, 3.0/2.0)",
"def curvature(self):\n if self.x[0] == self.x[-1] and self.y... | [
"0.6502923",
"0.6433723",
"0.6230932",
"0.60672617",
"0.5971525",
"0.59171945",
"0.58404565",
"0.5807356",
"0.56144226",
"0.5591963",
"0.5420314",
"0.5400934",
"0.53681475",
"0.53225476",
"0.5318358",
"0.5312725",
"0.52968705",
"0.5250027",
"0.5185593",
"0.51690495",
"0.51435... | 0.6097678 | 3 |
Helper function to set equal axis | def set_equal_3d_axis(ax, x_lims, y_lims, z_lims):
x_lims = np.asarray(x_lims)
y_lims = np.asarray(y_lims)
z_lims = np.asarray(z_lims)
# compute max required range
max_range = np.array([x_lims.max() - x_lims.min(),
y_lims.max() - y_lims.min(),
z_li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_equal(ax):\n scaling = array([getattr(ax, 'get_{}lim'.format(dim))() for dim in 'xyz'])\n ax.auto_scale_xyz(*[[min(scaling), max(scaling)]]*3)",
"def equal_axis(frame):\n limits = frame.axis()\n zmin = np.min([limits[0], limits[2]])\n zmax = np.max([limits[1], limits[3]])\n frame.set_xl... | [
"0.67071664",
"0.6518004",
"0.63109624",
"0.6267606",
"0.6167906",
"0.60394734",
"0.5803293",
"0.57901895",
"0.57079023",
"0.57079023",
"0.5660312",
"0.5647207",
"0.56240493",
"0.56233215",
"0.56170815",
"0.5615651",
"0.56054443",
"0.55858827",
"0.55755645",
"0.55601573",
"0.... | 0.55455345 | 21 |
Detects harris corners. Make sure the returned coordinates are x major!!! | def harris_corner_detector(im):
Ix = derivative(im, axis=0)
Iy = derivative(im, axis=1)
Ixy = sol4_utils.blur_spatial(Ix * Iy, BLUR_KERNEL_SIZE)
Ixx = sol4_utils.blur_spatial(Ix * Ix, BLUR_KERNEL_SIZE)
Iyy = sol4_utils.blur_spatial(Iy * Iy, BLUR_KERNEL_SIZE)
det = Ixx * Iyy - Ixy*Ixy
trace... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def harris_corner_detector(im):\n\n conv_vec = np.array([[1, 0, -1]])\n\n x_der = convolve(im, conv_vec)\n y_der = convolve(im, conv_vec.transpose())\n\n x_der_2 = sol4_utils.blur_spatial(x_der * x_der, 3)\n\n y_der_2 = sol4_utils.blur_spatial(y_der*y_der, 3)\n x_y_der = sol4_utils.blur_spatial(x... | [
"0.7338353",
"0.7133686",
"0.7005946",
"0.6849036",
"0.6735868",
"0.66729707",
"0.66553104",
"0.6582876",
"0.6573205",
"0.6538724",
"0.6484621",
"0.6438694",
"0.63991416",
"0.636579",
"0.63362527",
"0.6308946",
"0.62801975",
"0.62695485",
"0.62327456",
"0.6218055",
"0.6199252... | 0.7379283 | 0 |
Samples descriptors at the given corners. | def sample_descriptor(im, pos, desc_rad):
k = 2 * desc_rad + 1
pos = 2**DESCRIPOTR_LEVEL_DIFF * pos
window = (np.ones((pos.shape[0],1)) * np.arange(k) ) - desc_rad
x = window +np.expand_dims(pos[:,0], 1)
y = window +np.expand_dims(pos[:,1], 1)
xx = np.tile(x, (1,1,k)).flatten()
yy = np.rep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_features(pyr):\n descriptor_radius = DESC_RAD\n patch_amount = PATCH_AM\n min_distance_from_edge = DIST_FROM_EDGE\n corners = spread_out_corners(pyr[ORG_IMG], patch_amount, patch_amount, min_distance_from_edge)\n level_3_pos = np.array(pyr_point_translator(corners[:, X], corners[:, Y], ORG_... | [
"0.6397295",
"0.6256895",
"0.59952456",
"0.58769244",
"0.5599015",
"0.5399331",
"0.5395432",
"0.53945875",
"0.53690636",
"0.53454524",
"0.52510166",
"0.52326304",
"0.52222836",
"0.52011186",
"0.5174105",
"0.51144576",
"0.50981003",
"0.508238",
"0.5077964",
"0.5068688",
"0.505... | 0.55129343 | 5 |
Detects and extracts feature points from a pyramid. | def find_features(pyr):
feature_pnts = spread_out_corners(pyr[0], SPREAD_N, SPREAD_M ,SPREAD_CORNERS_RADIUS)
descriptors = sample_descriptor(pyr[2], feature_pnts, SAMPLE_RAD)
return feature_pnts, descriptors | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_features(pyr):\n\n feature_lst = spread_out_corners(pyr[0], 3, 3, 3)\n descriptors = sample_descriptor(pyr[2],feature_lst/4,3)\n return [feature_lst,descriptors]",
"def find_features(pyr):\n descriptor_radius = DESC_RAD\n patch_amount = PATCH_AM\n min_distance_from_edge = DIST_FROM_EDG... | [
"0.7035094",
"0.669588",
"0.6503971",
"0.63814044",
"0.6307368",
"0.61140066",
"0.6062323",
"0.6053611",
"0.60419255",
"0.59824055",
"0.59824055",
"0.59658",
"0.59382474",
"0.59103197",
"0.5740096",
"0.5705487",
"0.57028913",
"0.569599",
"0.56659395",
"0.5660129",
"0.5603166"... | 0.7127179 | 0 |
Return indices of matching descriptors. | def match_features(desc1, desc2, min_score):
## Reshape D1,2 to (N1, k^2), (k^2, N2)
D1 = desc1.reshape((desc1.shape[0], -1))
D2 = desc2.reshape((desc2.shape[0], -1)).T
## Calc M = D1 * D2, shape (N1, N2)
## Mi,j = match score of pt i from I1 and pt 2 from I2.
M = D1.dot(D2)
## Get cand... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_predicate_indices(tags: List[str]) -> List[int]:\n return [ind for ind, tag in enumerate(tags) if \"V\" in tag]",
"def indices(self):\n i, j, _edge = self.indicesAndEdge()\n return i, j",
"def find_indices_of_matched_samples(self, X, a):\n\n matching_weights = self.matching.matc... | [
"0.6563392",
"0.6433877",
"0.636279",
"0.6334142",
"0.63318443",
"0.63143104",
"0.6308538",
"0.6285328",
"0.62668735",
"0.6181223",
"0.615383",
"0.61386955",
"0.6127922",
"0.6117723",
"0.61068016",
"0.60706395",
"0.6065159",
"0.6048736",
"0.59917486",
"0.59818524",
"0.5966697... | 0.0 | -1 |
Apply homography to inhomogenous points. | def apply_homography(pos1, H12):
## Expand dims of pos1 to [x,y,1]
pos1 = np.concatenate(
(pos1 , np.ones((pos1.shape[0], 1))), axis=-1)
## dot with H12
pos2_extended = H12.dot(pos1.T).T
## Reduce dims
pos2 = pos2_extended[:,[0,1]] / pos2_extended[:,[2,2]]
return pos2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeHomography(src_pnt: np.ndarray, dst_pnt: np.ndarray) -> (np.ndarray, float):\r\n\r\n A = []\r\n for i in range(0, len(src_pnt)):\r\n x, y = src_pnt[i][0], src_pnt[i][1]\r\n u, v = dst_pnt[i][0], dst_pnt[i][1]\r\n A.append([x, y, 1, 0, 0, 0, -u * x, -u * y, -u])# like we saw in... | [
"0.7001385",
"0.6763035",
"0.671395",
"0.66501546",
"0.66149807",
"0.64726466",
"0.6456443",
"0.64406973",
"0.6315962",
"0.6219856",
"0.602618",
"0.594029",
"0.59350526",
"0.5921374",
"0.59114695",
"0.5814162",
"0.57273835",
"0.5723179",
"0.57077605",
"0.57067144",
"0.5596657... | 0.6579365 | 5 |
Computes homography between two sets of points using RANSAC. | def ransac_homography(points1, points2, num_iter, inlier_tol, translation_only=False):
inliners = np.array([])
pairs_num = 1 + (not translation_only)
for i in range(num_iter):
## try random match
pairs = np.random.randint(0, points1.shape[0],pairs_num)
pos1, pos2 = points1[pairs], ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def final_homography(pts1, pts2, feats1, feats2):\n\n #\n # Your code here\n #\n\n idxs1, idxs2 = find_matches(feats1, feats2)\n ransac_return = ransac(pts1[idxs1], pts2[idxs2])\n\n return ransac_return, idxs1, idxs2",
"def ransac_homography(keypoints1, keypoints2, matches, sampling_ratio=0.5, ... | [
"0.75701237",
"0.7454456",
"0.71248895",
"0.6936703",
"0.67340356",
"0.66742325",
"0.66653675",
"0.66420114",
"0.6500048",
"0.60429156",
"0.6041068",
"0.6006896",
"0.5996779",
"0.59723634",
"0.5836983",
"0.5752668",
"0.5745174",
"0.5689338",
"0.5664019",
"0.5643932",
"0.56021... | 0.6625923 | 8 |
Convert a list of succesive homographies to a list of homographies to a common reference frame. | def accumulate_homographies(H_succesive, m):
h2m = [np.eye(3)]
if len(H_succesive) == 0:
return h2m
[h2m.append( h2m[-1].dot(H_succesive[i]) )
for i in range(m-1,-1,-1)]
h2m.reverse()
[h2m.append( np.linalg.inv(H_succesive[i]).dot(h2m[-1]) )
for i in ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hyperedge_concat(*H_list):\n H = None\n for h in H_list:\n if h is not None:\n # for the first H appended to fused hypergraph incidence matrix\n if H is None:\n H = h\n else:\n H = np.hstack((H, h))\n return H",
"def hexlist_to_ge... | [
"0.56202364",
"0.52784044",
"0.5173602",
"0.50553465",
"0.50095004",
"0.50068694",
"0.5002364",
"0.49897015",
"0.4984743",
"0.49719393",
"0.48041353",
"0.4802245",
"0.47971445",
"0.47926477",
"0.47808725",
"0.47345135",
"0.47344205",
"0.47225136",
"0.47150758",
"0.47113198",
... | 0.467676 | 22 |
computes bounding box of warped image under homography, without actually warping the image | def compute_bounding_box(homography, w, h):
corners = np.array([[0,0],
[0,h],
[w,0],
[w,h]])
t_corners = apply_homography(corners, homography)
return np.array([t_corners.min(axis=0),t_corners.max(axis=0)],
dtype= np.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_bounding_box(homography, w, h):\n top_left_x, top_left_y = apply_homography(np.array([[0, 0]]), homography).transpose()\n top_right_x, top_right_y = apply_homography(np.array([[w, 0]]), homography).transpose()\n bottem_left_x, bottem_left_y = apply_homography(np.array([[0, h]]), homography).tr... | [
"0.68395644",
"0.68263465",
"0.6565394",
"0.65440303",
"0.65215236",
"0.63024795",
"0.6185591",
"0.6115287",
"0.60751134",
"0.6052541",
"0.59913546",
"0.5959734",
"0.59432757",
"0.59432757",
"0.5937751",
"0.59291124",
"0.5924142",
"0.59106493",
"0.5907376",
"0.59039426",
"0.5... | 0.6808969 | 2 |
Warps a 2D image with a given homography. | def warp_channel(image, homography):
## calc canvas
top, bottom = compute_bounding_box(homography, image.shape[1],
image.shape[0])
canvas_shape = tuple(np.diff([top,bottom], axis=0).flatten()[::-1])
## create index map
x,y = np.meshgrid(np.arange(top[0], bot... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def warp_channel(image, homography):\n\n\n boundings = compute_bounding_box(homography,image.shape[1],image.shape[0])\n x_vals = np.arange(boundings[0][0], boundings[1][0])\n y_vals = np.arange(boundings[0][1], boundings[1][1])\n x_vals,y_vals = np.meshgrid(x_vals,y_vals)\n\n x_vals_f, y_vals_f = x_... | [
"0.7345839",
"0.6907998",
"0.682956",
"0.6758212",
"0.6758212",
"0.66904014",
"0.6446177",
"0.6243719",
"0.6226596",
"0.62007666",
"0.61647147",
"0.61616576",
"0.6121813",
"0.6111707",
"0.59788084",
"0.59439003",
"0.59374386",
"0.5885356",
"0.58439845",
"0.58154804",
"0.57919... | 0.70242566 | 1 |
Warps an RGB image with a given homography. | def warp_image(image, homography):
return np.dstack([warp_channel(image[..., channel], homography) for channel in range(3)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def warp_channel(image, homography):\n\n\n boundings = compute_bounding_box(homography,image.shape[1],image.shape[0])\n x_vals = np.arange(boundings[0][0], boundings[1][0])\n y_vals = np.arange(boundings[0][1], boundings[1][1])\n x_vals,y_vals = np.meshgrid(x_vals,y_vals)\n\n x_vals_f, y_vals_f = x_... | [
"0.6858929",
"0.64860207",
"0.64229715",
"0.6370132",
"0.6330629",
"0.6271079",
"0.6197037",
"0.5913447",
"0.5638907",
"0.5629886",
"0.5541217",
"0.55241203",
"0.54386544",
"0.5392584",
"0.53646666",
"0.5351558",
"0.5351546",
"0.5324591",
"0.53157",
"0.5295544",
"0.5268346",
... | 0.6242118 | 7 |
Filters rigid transformations encoded as homographies by the amount of translation from left to right. | def filter_homographies_with_translation(homographies, minimum_right_translation):
translation_over_thresh = [0]
last = homographies[0][0, -1]
for i in range(1, len(homographies)):
if abs(homographies[i][0, -1] - last) > minimum_right_translation:
translation_over_thresh.append(i)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_homographies_with_translation(homographies, minimum_right_translation):\n translation_over_thresh = [0]\n last = homographies[0][0,-1]\n for i in range(1, len(homographies)):\n if homographies[i][0,-1] - last > minimum_right_translation:\n translation_over_thresh.append(i)\n last = homog... | [
"0.6446996",
"0.6349221",
"0.5705963",
"0.55155295",
"0.5404492",
"0.5364814",
"0.5335949",
"0.5306663",
"0.5300621",
"0.5253372",
"0.5253372",
"0.5253372",
"0.5253372",
"0.5253372",
"0.5208703",
"0.520631",
"0.51603156",
"0.51567453",
"0.5116342",
"0.5115032",
"0.5105264",
... | 0.6257986 | 2 |
Computes rigid transforming points1 towards points2, using least squares method. | def estimate_rigid_transform(points1, points2, translation_only=False):
centroid1 = points1.mean(axis=0)
centroid2 = points2.mean(axis=0)
if translation_only:
rotation = np.eye(2)
translation = centroid2 - centroid1
else:
centered_points1 = points1 - centroid1
centered_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transformation_from_points(points1, points2):\n points1 = points1.astype(np.float64)\n points2 = points2.astype(np.float64)\n\n c1 = np.mean(points1, axis=0)\n c2 = np.mean(points2, axis=0)\n points1 -= c1\n points2 -= c2\n\n s1 = np.std(points1)\n s2 = np.std(points2)\n points1 /= s... | [
"0.7304165",
"0.70865107",
"0.673969",
"0.6356167",
"0.6285698",
"0.6282726",
"0.62205327",
"0.6169337",
"0.6140601",
"0.61327386",
"0.61087453",
"0.60888803",
"0.6048376",
"0.60207796",
"0.5988855",
"0.5973158",
"0.59728986",
"0.5908945",
"0.5903124",
"0.58705467",
"0.583474... | 0.6581751 | 4 |
Finds local maximas of an image. | def non_maximum_suppression(image):
# Find local maximas.
neighborhood = generate_binary_structure(2, 2)
local_max = maximum_filter(image, footprint=neighborhood) == image
local_max[image < (image.max() * 0.1)] = False
# Erode areas to single points.
lbs, num = label(local_max)
centers = ce... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def local_max(img, size=(70,100,100)):\n # Apply a maximum filter.\n max_f = ndi.maximum_filter(img, size=size)\n # Find pixels that are local maxima.\n local_max = np.where(max_f == img, 1, 0)\n return(local_max)",
"def findMax(img):\n\td = minMaxLoc(img)\n\treturn {\"maxVal\":d[\"maxVal\"], \"ma... | [
"0.81915313",
"0.7625611",
"0.68985856",
"0.6832104",
"0.67985094",
"0.6775226",
"0.6725332",
"0.66870373",
"0.66672045",
"0.65558475",
"0.6497807",
"0.64525133",
"0.64096",
"0.63515335",
"0.634579",
"0.6333941",
"0.6321105",
"0.6305051",
"0.6277516",
"0.62486374",
"0.6246329... | 0.6336719 | 16 |
Splits the image im to m by n rectangles and uses harris_corner_detector on each. | def spread_out_corners(im, m, n, radius):
corners = [np.empty((0, 2), dtype=np.int)]
x_bound = np.linspace(0, im.shape[1], n + 1, dtype=np.int)
y_bound = np.linspace(0, im.shape[0], m + 1, dtype=np.int)
for i in range(n):
for j in range(m):
# Use Harris detector on every sub image.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spread_out_corners(im, m, n, radius):\n corners = [np.empty((0,2), dtype=np.int)]\n x_bound = np.linspace(0, im.shape[1], n+1, dtype=np.int)\n y_bound = np.linspace(0, im.shape[0], m+1, dtype=np.int)\n for i in range(n):\n for j in range(m):\n # Use Harris detector on every sub image.\n sub_im... | [
"0.7192716",
"0.63815415",
"0.6211173",
"0.60078424",
"0.5932329",
"0.5887943",
"0.5871418",
"0.58623314",
"0.578299",
"0.57816726",
"0.57581216",
"0.5722521",
"0.56884426",
"0.56871694",
"0.56726635",
"0.56665385",
"0.56598103",
"0.5608869",
"0.5607788",
"0.5546984",
"0.5483... | 0.7179764 | 2 |
The naming convention for a sequence of images is file_prefixN.jpg, where N is a running number 001, 002, 003... | def __init__(self, data_dir, file_prefix, num_images):
self.file_prefix = file_prefix
self.files = [os.path.join(data_dir, '%s%03d.jpg' % (file_prefix, i + 1)) for i in range(num_images)]
self.files = list(filter(os.path.exists, self.files))
self.panoramas = None
self.homographie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_prefix() :\n \n import glob\n filenames = glob.glob(picture_folder+'*.jpg')\n max_prefix = 0\n for filename in filenames :\n parts = filenames.split('_')\n if len(parts) > 1 :\n possible_prefix = parse_int(parts[0])\n if possible_prefix > max_prefix :\n max_prefix = possible_pre... | [
"0.769489",
"0.73024964",
"0.6996918",
"0.695735",
"0.6912876",
"0.68801117",
"0.6853592",
"0.67820257",
"0.6771336",
"0.67199373",
"0.6704712",
"0.66808397",
"0.6628377",
"0.658693",
"0.6585913",
"0.65571696",
"0.65143126",
"0.6469766",
"0.64489675",
"0.64109373",
"0.6376563... | 0.58315897 | 73 |
compute homographies between all images to a common coordinate system | def align_images(self, translation_only=False):
# Extract feature point locations and descriptors.
points_and_descriptors = []
for file in self.files:
image = sol4_utils.read_image(file, 1)
self.images.append(image)
self.h, self.w = image.shape
pyr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_homography(self):\n src = np.array(self._metadata[:4])\n\n h_units = self._config.h_units\n v_units = self._config.v_units\n dst = np.array(\n [(0, v_units), (h_units, v_units), (0, 0), (h_units, 0)])\n\n h_m, _ = cv2.findHomography(src, dst)\n se... | [
"0.70967317",
"0.67565054",
"0.6647977",
"0.6640233",
"0.6524193",
"0.6376031",
"0.6365266",
"0.6343077",
"0.6188618",
"0.6002113",
"0.5964076",
"0.59238464",
"0.58914006",
"0.58824134",
"0.5871231",
"0.5748752",
"0.57079154",
"0.5679168",
"0.5676379",
"0.5661097",
"0.5622856... | 0.5631594 | 20 |
combine slices from input images to panoramas. | def generate_panoramic_images(self, number_of_panoramas):
assert self.homographies is not None
# compute bounding boxes of all warped input images in the coordinate system of the middle image (as given by the homographies)
self.bounding_boxes = np.zeros((self.frames_for_panoramas.size, 2, 2))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_panoramic_images(self, number_of_panoramas):\n assert self.homographies is not None\n\n # compute bounding boxes of all warped input images in the coordinate system of the middle image (as given by the homographies)\n self.bounding_boxes = np.zeros((self.frames_for_panoramas.size, 2, 2))\n ... | [
"0.6989787",
"0.69521314",
"0.63546145",
"0.61053276",
"0.59612685",
"0.5914441",
"0.5825741",
"0.582431",
"0.5722109",
"0.56852674",
"0.56654567",
"0.5582949",
"0.5580172",
"0.55788565",
"0.55557424",
"0.5504493",
"0.54561037",
"0.54267657",
"0.54023594",
"0.53983194",
"0.53... | 0.69521314 | 2 |
Calculates cost and its gradient using Mean Squared Error. (1/2m)sum(Y Y_hat)^.2 | def mean_squared_error(Y, Y_hat):
m = Y.shape[0]
# calc cost
cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))
cost = np.squeeze(cost)
# calc gradient
dY_hat = - (1 / m) * (Y - Y_hat)
return cost, dY_hat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat",
"def com... | [
"0.80790156",
"0.80790156",
"0.7456379",
"0.73937976",
"0.7304459",
"0.7289378",
"0.72770244",
"0.7272426",
"0.7232527",
"0.7229088",
"0.7182291",
"0.7179993",
"0.71723986",
"0.71631444",
"0.71498054",
"0.71384823",
"0.7122224",
"0.7103611",
"0.7058416",
"0.70522356",
"0.7051... | 0.79877114 | 2 |
Calculates cost and its gradient using Binary Cross Entropy. (1/m) np.sum(np.log(Y_hat) Y np.log(1Y_hat) (1Y)) | def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):
m = Y.shape[0]
# make data safe
Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))
# calc cost
cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))
cost = np.squeeze(cost)
# calc gradient
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_cost(Y_hat, Y):\r\n\r\n m = Y.shape[1]\r\n\r\n\r\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\r\n\r\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\... | [
"0.79731613",
"0.79660696",
"0.77614254",
"0.7753233",
"0.7751599",
"0.7738234",
"0.7619114",
"0.7614405",
"0.756269",
"0.74779886",
"0.7462293",
"0.74533564",
"0.74393666",
"0.74089724",
"0.73822963",
"0.7329635",
"0.7329065",
"0.7310318",
"0.725654",
"0.72156954",
"0.719657... | 0.71322453 | 26 |
Calculates cost and its gradient using Cross Entropy. (1 / m) np.sum(Y np.log(Y_hat)) | def cross_entropy(Y, Y_hat, epsilon=1e-8):
m = Y.shape[0]
# make data safe
Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))
# calc cost
cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))
cost = np.squeeze(cost)
# calc gradient
dY_hat = -Y / Y_hat
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_cost(Y_hat, Y):\r\n\r\n m = Y.shape[1]\r\n\r\n\r\n cost = (1. / m) * np.sum(np.multiply(-np.log(Y_hat + 0.000000001),Y) + np.multiply(-np.log(1 - Y_hat + 0.000000001), 1 - Y))\r\n\r\n cost = np.squeeze(cost) # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).\... | [
"0.8094435",
"0.79508626",
"0.7784622",
"0.7753385",
"0.77234364",
"0.7718602",
"0.76510054",
"0.75447094",
"0.74698293",
"0.74428225",
"0.7442382",
"0.7431407",
"0.742752",
"0.742752",
"0.73978907",
"0.7375569",
"0.7369099",
"0.7367389",
"0.73666364",
"0.73191875",
"0.728816... | 0.74783975 | 8 |
Convert a number to unicode, with appropriate substitutions. | def unicode_number(x):
output = u"%g" % x
if output[0] == u"-":
output = u"\u2012" + output[1:]
index = output.find(u"e")
if index != -1:
uniout = unicode(output[:index]) + u"\u00d710"
saw_nonzero = False
for n in output[index+1:]:
if n == u"+": pass # uniout += u"\u207a"
elif n =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_u(val, encoding='utf-8'):\r\n if isinstance(val, text_type):\r\n return val\r\n elif isinstance(val, numeric_types):\r\n return text_type(val)\r\n\r\n return val.decode(encoding)",
"def translate_number(number):\n return NUMBER_TRANSLATOR[number]",
"def _to_cn(number):\n\n c... | [
"0.64799064",
"0.6462614",
"0.6408784",
"0.61651",
"0.6087401",
"0.59796566",
"0.5951445",
"0.58721507",
"0.58155435",
"0.5808134",
"0.57698685",
"0.5736867",
"0.57064986",
"0.5688757",
"0.5659142",
"0.56527704",
"0.56455475",
"0.56412405",
"0.5638056",
"0.56291896",
"0.56287... | 0.7085641 | 0 |
Return a function that can be used to draw regular grid lines or tick marks. | def regular(step, start=0.):
def output(low, high):
newstart = math.ceil((low - start)/step) * step + start
return numpy.arange(newstart, high, step, dtype=numpy.float)
output.func_name = "regular(%g, start=%g)" % (step, start)
return output | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawGrid(self,gridLines=True):\n if not self.changed: self.edit()\n cGrid = Fmap.GRID\n cBorder = Fmap.BORDER\n if gridLines: #--Some fools don't want the grid!\n #--Grid\n for uv in range(-25,26,5):\n xy = 512/2 - 9*uv + 4\n self.... | [
"0.61834234",
"0.6008772",
"0.59259754",
"0.5909034",
"0.5832352",
"0.57928234",
"0.5755209",
"0.5727162",
"0.5662317",
"0.56454045",
"0.56073934",
"0.5587352",
"0.5586233",
"0.5584013",
"0.555687",
"0.5555793",
"0.5554617",
"0.5530118",
"0.55236983",
"0.5503275",
"0.55012906... | 0.0 | -1 |
Return a function that can be used to set standard tick marks. | def tickmarks(major=-10, minor=True, logbase=0, format=unicode_number):
if not callable(format):
tmp = format
format = lambda x: tmp % x
format.func_name = tmp
def linear_tickmarks(low, high):
if low >= high:
raise ValueError, "To compute tick-marks, 'low' must be l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_style(func):\n def wrapper(*args, **kwargs):\n fig = plt.figure(figsize=(18,18))\n sns.set_context(\"talk\", font_scale=0.9)\n plt.xlim(-3, 3)\n plt.tick_params(grid_alpha=0.2)\n func(*args, **kwargs)\n plt.clf()\n return wrapper",
"def create_tick_mark(\n fmin: f... | [
"0.6055695",
"0.5834575",
"0.5709799",
"0.5684322",
"0.56447107",
"0.5592472",
"0.5586648",
"0.55707574",
"0.55437565",
"0.55194885",
"0.54999316",
"0.5466122",
"0.5416735",
"0.539491",
"0.53574145",
"0.5304559",
"0.5293611",
"0.5277207",
"0.52736354",
"0.5267641",
"0.524143"... | 0.60170686 | 1 |
Return the range (min, max) of a dataset, excluding any NANs. | def calcrange(data, log=False):
xmin, xmax = None, None
for x in data:
if not log or x > 0.:
if xmin is None or x < xmin: xmin = x
if xmax is None or x > xmax: xmax = x
if xmin is None and xmax is None:
if log:
return 0.1, 1.
else:
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_range(x):\n return max(x)-min(x)",
"def _full_value_range(self):\n min_value, max_value = self._raw_data.data_range\n return max_value - min_value",
"def _computeRangeFromData(data):\n if data is None:\n return None\n\n dataRange = min_max(data, min_positive=True, fin... | [
"0.7928218",
"0.759846",
"0.7561937",
"0.7432182",
"0.72924185",
"0.716103",
"0.7079898",
"0.7077026",
"0.7050836",
"0.68989515",
"0.6853273",
"0.677322",
"0.67359143",
"0.669912",
"0.66874564",
"0.66771185",
"0.6630462",
"0.65873176",
"0.65851694",
"0.65726477",
"0.6569491",... | 0.0 | -1 |
Return the range (min, max) of a dataset, based on quartiles (stable against large numbers). | def calcrange_quartile(data, log=False):
if not isinstance(data, numpy.ndarray):
data = numpy.array(data)
if log:
data = data[data > 0.]
if len(data) == 0:
if log: return 0.1, 1.
else: return 0., 1.
data = numpy.sort(data)
q1 = data[int(math.floor(0.25*len(data)))]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Quartiles(data):\n q = np.percentile(data, [25, 50, 75])\n\n return q[0], q[1], q[2]",
"def interquartile_range(x):\n return (quantile(x,0.75) - quantile(x,0.25))",
"def interquartile_range(xs: List[float]) -> float:\n return quantile(xs, 0.75) - quantile(xs, 0.25)",
"def data_range(x):\n ... | [
"0.7523062",
"0.71719885",
"0.7050786",
"0.69144285",
"0.6811111",
"0.67421144",
"0.6629707",
"0.66259694",
"0.65270203",
"0.6509629",
"0.65053487",
"0.64967763",
"0.64555305",
"0.6433195",
"0.6423888",
"0.63779706",
"0.6359893",
"0.63541",
"0.6300196",
"0.62596935",
"0.62174... | 0.67295194 | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.